um/x86: merge (and trim) 32- and 64-bit variants of ptrace.h

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

um/x86: merge (and trim) 32- and 64-bit variants of ptrace.h
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Al Viro
1 parent c6802f4370
Showing 13 changed files with 150 additions and 279 deletions Side-by-side Diff
arch/um/kernel/process.c
arch/um/kernel/skas/syscall.c
arch/x86/um/asm/elf.h
arch/x86/um/asm/ptrace.h
arch/x86/um/asm/ptrace_32.h
arch/x86/um/asm/ptrace_64.h
arch/x86/um/shared/sysdep/ptrace.h
arch/x86/um/shared/sysdep/ptrace_32.h
arch/x86/um/shared/sysdep/ptrace_64.h
arch/x86/um/signal.c
arch/x86/um/sysrq_32.c
arch/x86/um/sysrq_64.c
arch/x86/um/tls_32.c
@@ -196,7 +196,7 @@
 	if (current->thread.forking) {
 	  	memcpy(&p->thread.regs.regs, &regs->regs,
 		       sizeof(p->thread.regs.regs));
-		REGS_SET_SYSCALL_RETURN(p->thread.regs.regs.gp, 0);
+		UPT_SET_SYSCALL_RETURN(&p->thread.regs.regs, 0);
 		if (sp != 0)
 			REGS_SP(p->thread.regs.regs.gp) = sp;
  
@@ -34,7 +34,7 @@
 		result = -ENOSYS;
 	else result = EXECUTE_SYSCALL(syscall, regs);
  
-	REGS_SET_SYSCALL_RETURN(r->gp, result);
+	UPT_SET_SYSCALL_RETURN(r, result);
  
 	syscall_trace(r, 1);
 }
@@ -34,25 +34,25 @@
 #define ELF_ARCH        EM_386
  
 #define ELF_PLAT_INIT(regs, load_addr) do { \
-	PT_REGS_EBX(regs) = 0; \
-	PT_REGS_ECX(regs) = 0; \
-	PT_REGS_EDX(regs) = 0; \
-	PT_REGS_ESI(regs) = 0; \
-	PT_REGS_EDI(regs) = 0; \
-	PT_REGS_EBP(regs) = 0; \
-	PT_REGS_EAX(regs) = 0; \
+	PT_REGS_BX(regs) = 0; \
+	PT_REGS_CX(regs) = 0; \
+	PT_REGS_DX(regs) = 0; \
+	PT_REGS_SI(regs) = 0; \
+	PT_REGS_DI(regs) = 0; \
+	PT_REGS_BP(regs) = 0; \
+	PT_REGS_AX(regs) = 0; \
 } while (0)
  
 /* Shamelessly stolen from include/asm-i386/elf.h */
  
 #define ELF_CORE_COPY_REGS(pr_reg, regs) do {	\
-	pr_reg[0] = PT_REGS_EBX(regs);		\
-	pr_reg[1] = PT_REGS_ECX(regs);		\
-	pr_reg[2] = PT_REGS_EDX(regs);		\
-	pr_reg[3] = PT_REGS_ESI(regs);		\
-	pr_reg[4] = PT_REGS_EDI(regs);		\
-	pr_reg[5] = PT_REGS_EBP(regs);		\
-	pr_reg[6] = PT_REGS_EAX(regs);		\
+	pr_reg[0] = PT_REGS_BX(regs);		\
+	pr_reg[1] = PT_REGS_CX(regs);		\
+	pr_reg[2] = PT_REGS_DX(regs);		\
+	pr_reg[3] = PT_REGS_SI(regs);		\
+	pr_reg[4] = PT_REGS_DI(regs);		\
+	pr_reg[5] = PT_REGS_BP(regs);		\
+	pr_reg[6] = PT_REGS_AX(regs);		\
 	pr_reg[7] = PT_REGS_DS(regs);		\
 	pr_reg[8] = PT_REGS_ES(regs);		\
 	/* fake once used fs and gs selectors? */	\
@@ -130,13 +130,13 @@
 #define ELF_ARCH        EM_X86_64
  
 #define ELF_PLAT_INIT(regs, load_addr)    do { \
-	PT_REGS_RBX(regs) = 0; \
-	PT_REGS_RCX(regs) = 0; \
-	PT_REGS_RDX(regs) = 0; \
-	PT_REGS_RSI(regs) = 0; \
-	PT_REGS_RDI(regs) = 0; \
-	PT_REGS_RBP(regs) = 0; \
-	PT_REGS_RAX(regs) = 0; \
+	PT_REGS_BX(regs) = 0; \
+	PT_REGS_CX(regs) = 0; \
+	PT_REGS_DX(regs) = 0; \
+	PT_REGS_SI(regs) = 0; \
+	PT_REGS_DI(regs) = 0; \
+	PT_REGS_BP(regs) = 0; \
+	PT_REGS_AX(regs) = 0; \
 	PT_REGS_R8(regs) = 0; \
 	PT_REGS_R9(regs) = 0; \
 	PT_REGS_R10(regs) = 0; \
+#ifndef __UM_X86_PTRACE_H
+#define __UM_X86_PTRACE_H
+
 #ifdef CONFIG_X86_32
 # include "ptrace_32.h"
 #else
 # include "ptrace_64.h"
 #endif
+
+#define PT_REGS_AX(r) UPT_AX(&(r)->regs)
+#define PT_REGS_BX(r) UPT_BX(&(r)->regs)
+#define PT_REGS_CX(r) UPT_CX(&(r)->regs)
+#define PT_REGS_DX(r) UPT_DX(&(r)->regs)
+
+#define PT_REGS_SI(r) UPT_SI(&(r)->regs)
+#define PT_REGS_DI(r) UPT_DI(&(r)->regs)
+#define PT_REGS_BP(r) UPT_BP(&(r)->regs)
+#define PT_REGS_EFLAGS(r) UPT_EFLAGS(&(r)->regs)
+
+#define PT_REGS_CS(r) UPT_CS(&(r)->regs)
+#define PT_REGS_SS(r) UPT_SS(&(r)->regs)
+#define PT_REGS_DS(r) UPT_DS(&(r)->regs)
+#define PT_REGS_ES(r) UPT_ES(&(r)->regs)
+
+#define PT_REGS_ORIG_SYSCALL(r) PT_REGS_AX(r)
+#define PT_REGS_SYSCALL_RET(r) PT_REGS_AX(r)
+
+#define PT_FIX_EXEC_STACK(sp) do ; while(0)
+
+#define profile_pc(regs) PT_REGS_IP(regs)
+
+#define UPT_RESTART_SYSCALL(r) (UPT_IP(r) -= 2)
+#define UPT_SET_SYSCALL_RETURN(r, res) (UPT_AX(r) = (res))
+
+static inline long regs_return_value(struct uml_pt_regs *regs)
+{
+	return UPT_AX(regs);
+}
+#endif /* __UM_X86_PTRACE_H */
@@ -11,29 +11,6 @@
 #include "linux/compiler.h"
 #include "asm/ptrace-generic.h"
  
-#define PT_REGS_EAX(r) UPT_EAX(&(r)->regs)
-#define PT_REGS_EBX(r) UPT_EBX(&(r)->regs)
-#define PT_REGS_ECX(r) UPT_ECX(&(r)->regs)
-#define PT_REGS_EDX(r) UPT_EDX(&(r)->regs)
-#define PT_REGS_ESI(r) UPT_ESI(&(r)->regs)
-#define PT_REGS_EDI(r) UPT_EDI(&(r)->regs)
-#define PT_REGS_EBP(r) UPT_EBP(&(r)->regs)
-
-#define PT_REGS_CS(r) UPT_CS(&(r)->regs)
-#define PT_REGS_SS(r) UPT_SS(&(r)->regs)
-#define PT_REGS_DS(r) UPT_DS(&(r)->regs)
-#define PT_REGS_ES(r) UPT_ES(&(r)->regs)
-#define PT_REGS_FS(r) UPT_FS(&(r)->regs)
-#define PT_REGS_GS(r) UPT_GS(&(r)->regs)
-
-#define PT_REGS_EFLAGS(r) UPT_EFLAGS(&(r)->regs)
-
-#define PT_REGS_ORIG_SYSCALL(r) PT_REGS_EAX(r)
-#define PT_REGS_SYSCALL_RET(r) PT_REGS_EAX(r)
-#define PT_FIX_EXEC_STACK(sp) do ; while(0)
-
-#define profile_pc(regs) PT_REGS_IP(regs)
-
 #define user_mode(r) UPT_IS_USER(&(r)->regs)
  
 /*
@@ -15,13 +15,6 @@
  
 #define HOST_AUDIT_ARCH AUDIT_ARCH_X86_64
  
-#define PT_REGS_RBX(r) UPT_RBX(&(r)->regs)
-#define PT_REGS_RCX(r) UPT_RCX(&(r)->regs)
-#define PT_REGS_RDX(r) UPT_RDX(&(r)->regs)
-#define PT_REGS_RSI(r) UPT_RSI(&(r)->regs)
-#define PT_REGS_RDI(r) UPT_RDI(&(r)->regs)
-#define PT_REGS_RBP(r) UPT_RBP(&(r)->regs)
-#define PT_REGS_RAX(r) UPT_RAX(&(r)->regs)
 #define PT_REGS_R8(r) UPT_R8(&(r)->regs)
 #define PT_REGS_R9(r) UPT_R9(&(r)->regs)
 #define PT_REGS_R10(r) UPT_R10(&(r)->regs)
  
@@ -31,27 +24,8 @@
 #define PT_REGS_R14(r) UPT_R14(&(r)->regs)
 #define PT_REGS_R15(r) UPT_R15(&(r)->regs)
  
-#define PT_REGS_FS(r) UPT_FS(&(r)->regs)
-#define PT_REGS_GS(r) UPT_GS(&(r)->regs)
-#define PT_REGS_DS(r) UPT_DS(&(r)->regs)
-#define PT_REGS_ES(r) UPT_ES(&(r)->regs)
-#define PT_REGS_SS(r) UPT_SS(&(r)->regs)
-#define PT_REGS_CS(r) UPT_CS(&(r)->regs)
-
-#define PT_REGS_ORIG_RAX(r) UPT_ORIG_RAX(&(r)->regs)
-#define PT_REGS_RIP(r) UPT_IP(&(r)->regs)
-#define PT_REGS_SP(r) UPT_SP(&(r)->regs)
-
-#define PT_REGS_EFLAGS(r) UPT_EFLAGS(&(r)->regs)
-
 /* XXX */
 #define user_mode(r) UPT_IS_USER(&(r)->regs)
-#define PT_REGS_ORIG_SYSCALL(r) PT_REGS_RAX(r)
-#define PT_REGS_SYSCALL_RET(r) PT_REGS_RAX(r)
-
-#define PT_FIX_EXEC_STACK(sp) do ; while(0)
-
-#define profile_pc(regs) PT_REGS_IP(regs)
  
 struct user_desc;
  
 #ifndef __SYSDEP_X86_PTRACE_H
 #define __SYSDEP_X86_PTRACE_H
  
+#include <generated/user_constants.h>
+#include "sysdep/faultinfo.h"
+
+#define MAX_REG_OFFSET (UM_FRAME_SIZE)
+#define MAX_REG_NR ((MAX_REG_OFFSET) / sizeof(unsigned long))
+
+#define REGS_IP(r) ((r)[HOST_IP])
+#define REGS_SP(r) ((r)[HOST_SP])
+#define REGS_EFLAGS(r) ((r)[HOST_EFLAGS])
+#define REGS_AX(r) ((r)[HOST_AX])
+#define REGS_BX(r) ((r)[HOST_BX])
+#define REGS_CX(r) ((r)[HOST_CX])
+#define REGS_DX(r) ((r)[HOST_DX])
+#define REGS_SI(r) ((r)[HOST_SI])
+#define REGS_DI(r) ((r)[HOST_DI])
+#define REGS_BP(r) ((r)[HOST_BP])
+#define REGS_CS(r) ((r)[HOST_CS])
+#define REGS_SS(r) ((r)[HOST_SS])
+#define REGS_DS(r) ((r)[HOST_DS])
+#define REGS_ES(r) ((r)[HOST_ES])
+
+#define UPT_IP(r) REGS_IP((r)->gp)
+#define UPT_SP(r) REGS_SP((r)->gp)
+#define UPT_EFLAGS(r) REGS_EFLAGS((r)->gp)
+#define UPT_AX(r) REGS_AX((r)->gp)
+#define UPT_BX(r) REGS_BX((r)->gp)
+#define UPT_CX(r) REGS_CX((r)->gp)
+#define UPT_DX(r) REGS_DX((r)->gp)
+#define UPT_SI(r) REGS_SI((r)->gp)
+#define UPT_DI(r) REGS_DI((r)->gp)
+#define UPT_BP(r) REGS_BP((r)->gp)
+#define UPT_CS(r) REGS_CS((r)->gp)
+#define UPT_SS(r) REGS_SS((r)->gp)
+#define UPT_DS(r) REGS_DS((r)->gp)
+#define UPT_ES(r) REGS_ES((r)->gp)
+
 #ifdef __i386__
 #include "ptrace_32.h"
 #else
 #include "ptrace_64.h"
 #endif
  
-static inline long regs_return_value(struct uml_pt_regs *regs)
-{
-	return UPT_SYSCALL_RET(regs);
-}
+struct syscall_args {
+	unsigned long args[6];
+};
+
+#define SYSCALL_ARGS(r) ((struct syscall_args) \
+			 { .args = { UPT_SYSCALL_ARG1(r),	 \
+				     UPT_SYSCALL_ARG2(r),	 \
+				     UPT_SYSCALL_ARG3(r),	 \
+				     UPT_SYSCALL_ARG4(r),	 \
+				     UPT_SYSCALL_ARG5(r),	 \
+				     UPT_SYSCALL_ARG6(r) } } )
+
+struct uml_pt_regs {
+	unsigned long gp[MAX_REG_NR];
+	unsigned long fp[MAX_FP_NR];
+	struct faultinfo faultinfo;
+	long syscall;
+	int is_user;
+};
+
+#define EMPTY_UML_PT_REGS { }
+
+#define UPT_SYSCALL_NR(r) ((r)->syscall)
+#define UPT_FAULTINFO(r) (&(r)->faultinfo)
+#define UPT_IS_USER(r) ((r)->is_user)
+
+extern int user_context(unsigned long sp);
  
 #endif /* __SYSDEP_X86_PTRACE_H */
@@ -6,12 +6,8 @@
 #ifndef __SYSDEP_I386_PTRACE_H
 #define __SYSDEP_I386_PTRACE_H
  
-#include <generated/user_constants.h>
-#include "sysdep/faultinfo.h"
+#define MAX_FP_NR HOST_FPX_SIZE
  
-#define MAX_REG_NR (UM_FRAME_SIZE / sizeof(unsigned long))
-#define MAX_REG_OFFSET (UM_FRAME_SIZE)
-
 static inline void update_debugregs(int seq) {}
  
 /* syscall emulation path in ptrace */
  
@@ -24,90 +20,16 @@
 int get_using_sysemu(void);
 extern int sysemu_supported;
  
-#define REGS_IP(r) ((r)[HOST_IP])
-#define REGS_SP(r) ((r)[HOST_SP])
-#define REGS_EFLAGS(r) ((r)[HOST_EFLAGS])
-#define REGS_EAX(r) ((r)[HOST_AX])
-#define REGS_EBX(r) ((r)[HOST_BX])
-#define REGS_ECX(r) ((r)[HOST_CX])
-#define REGS_EDX(r) ((r)[HOST_DX])
-#define REGS_ESI(r) ((r)[HOST_SI])
-#define REGS_EDI(r) ((r)[HOST_DI])
-#define REGS_EBP(r) ((r)[HOST_BP])
-#define REGS_CS(r) ((r)[HOST_CS])
-#define REGS_SS(r) ((r)[HOST_SS])
-#define REGS_DS(r) ((r)[HOST_DS])
-#define REGS_ES(r) ((r)[HOST_ES])
-#define REGS_FS(r) ((r)[HOST_FS])
-#define REGS_GS(r) ((r)[HOST_GS])
-
-#define REGS_SET_SYSCALL_RETURN(r, res) REGS_EAX(r) = (res)
-
-#define IP_RESTART_SYSCALL(ip) ((ip) -= 2)
-#define REGS_RESTART_SYSCALL(r) IP_RESTART_SYSCALL(REGS_IP(r))
-
 #ifndef PTRACE_SYSEMU_SINGLESTEP
 #define PTRACE_SYSEMU_SINGLESTEP 32
 #endif
  
-struct uml_pt_regs {
-	unsigned long gp[MAX_REG_NR];
-	unsigned long fp[HOST_FPX_SIZE];
-	struct faultinfo faultinfo;
-	long syscall;
-	int is_user;
-};
-
-#define EMPTY_UML_PT_REGS { }
-
-#define UPT_IP(r) REGS_IP((r)->gp)
-#define UPT_SP(r) REGS_SP((r)->gp)
-#define UPT_EFLAGS(r) REGS_EFLAGS((r)->gp)
-#define UPT_EAX(r) REGS_EAX((r)->gp)
-#define UPT_EBX(r) REGS_EBX((r)->gp)
-#define UPT_ECX(r) REGS_ECX((r)->gp)
-#define UPT_EDX(r) REGS_EDX((r)->gp)
-#define UPT_ESI(r) REGS_ESI((r)->gp)
-#define UPT_EDI(r) REGS_EDI((r)->gp)
-#define UPT_EBP(r) REGS_EBP((r)->gp)
-#define UPT_ORIG_EAX(r) ((r)->syscall)
-#define UPT_CS(r) REGS_CS((r)->gp)
-#define UPT_SS(r) REGS_SS((r)->gp)
-#define UPT_DS(r) REGS_DS((r)->gp)
-#define UPT_ES(r) REGS_ES((r)->gp)
-#define UPT_FS(r) REGS_FS((r)->gp)
-#define UPT_GS(r) REGS_GS((r)->gp)
-
-#define UPT_SYSCALL_ARG1(r) UPT_EBX(r)
-#define UPT_SYSCALL_ARG2(r) UPT_ECX(r)
-#define UPT_SYSCALL_ARG3(r) UPT_EDX(r)
-#define UPT_SYSCALL_ARG4(r) UPT_ESI(r)
-#define UPT_SYSCALL_ARG5(r) UPT_EDI(r)
-#define UPT_SYSCALL_ARG6(r) UPT_EBP(r)
-
-extern int user_context(unsigned long sp);
-
-#define UPT_IS_USER(r) ((r)->is_user)
-
-struct syscall_args {
-	unsigned long args[6];
-};
-
-#define SYSCALL_ARGS(r) ((struct syscall_args) \
-			 { .args = { UPT_SYSCALL_ARG1(r),	\
-				     UPT_SYSCALL_ARG2(r),	\
-				     UPT_SYSCALL_ARG3(r),	\
-				     UPT_SYSCALL_ARG4(r),	\
-				     UPT_SYSCALL_ARG5(r),	\
-				     UPT_SYSCALL_ARG6(r) } } )
-
-#define UPT_RESTART_SYSCALL(r) REGS_RESTART_SYSCALL((r)->gp)
-
-#define UPT_ORIG_SYSCALL(r) UPT_EAX(r)
-#define UPT_SYSCALL_NR(r) UPT_ORIG_EAX(r)
-#define UPT_SYSCALL_RET(r) UPT_EAX(r)
-
-#define UPT_FAULTINFO(r) (&(r)->faultinfo)
+#define UPT_SYSCALL_ARG1(r) UPT_BX(r)
+#define UPT_SYSCALL_ARG2(r) UPT_CX(r)
+#define UPT_SYSCALL_ARG3(r) UPT_DX(r)
+#define UPT_SYSCALL_ARG4(r) UPT_SI(r)
+#define UPT_SYSCALL_ARG5(r) UPT_DI(r)
+#define UPT_SYSCALL_ARG6(r) UPT_BP(r)
  
 extern void arch_init_registers(int pid);
  
@@ -8,22 +8,8 @@
 #ifndef __SYSDEP_X86_64_PTRACE_H
 #define __SYSDEP_X86_64_PTRACE_H
  
-#include <generated/user_constants.h>
-#include "sysdep/faultinfo.h"
+#define MAX_FP_NR HOST_FP_SIZE
  
-#define MAX_REG_OFFSET (UM_FRAME_SIZE)
-#define MAX_REG_NR ((MAX_REG_OFFSET) / sizeof(unsigned long))
-
-#define REGS_IP(r) ((r)[HOST_IP])
-#define REGS_SP(r) ((r)[HOST_SP])
-
-#define REGS_RBX(r) ((r)[HOST_BX])
-#define REGS_RCX(r) ((r)[HOST_CX])
-#define REGS_RDX(r) ((r)[HOST_DX])
-#define REGS_RSI(r) ((r)[HOST_SI])
-#define REGS_RDI(r) ((r)[HOST_DI])
-#define REGS_RBP(r) ((r)[HOST_BP])
-#define REGS_RAX(r) ((r)[HOST_AX])
 #define REGS_R8(r) ((r)[HOST_R8])
 #define REGS_R9(r) ((r)[HOST_R9])
 #define REGS_R10(r) ((r)[HOST_R10])
@@ -32,9 +18,6 @@
 #define REGS_R13(r) ((r)[HOST_R13])
 #define REGS_R14(r) ((r)[HOST_R14])
 #define REGS_R15(r) ((r)[HOST_R15])
-#define REGS_CS(r) ((r)[HOST_CS])
-#define REGS_EFLAGS(r) ((r)[HOST_EFLAGS])
-#define REGS_SS(r) ((r)[HOST_SS])
  
 #define HOST_FS_BASE 21
 #define HOST_GS_BASE 22
@@ -58,45 +41,6 @@
 #define GS (HOST_GS * sizeof(long))
 #endif
  
-#define REGS_FS_BASE(r) ((r)[HOST_FS_BASE])
-#define REGS_GS_BASE(r) ((r)[HOST_GS_BASE])
-#define REGS_DS(r) ((r)[HOST_DS])
-#define REGS_ES(r) ((r)[HOST_ES])
-#define REGS_FS(r) ((r)[HOST_FS])
-#define REGS_GS(r) ((r)[HOST_GS])
-
-#define REGS_ORIG_RAX(r) ((r)[HOST_ORIG_AX])
-
-#define REGS_SET_SYSCALL_RETURN(r, res) REGS_RAX(r) = (res)
-
-#define IP_RESTART_SYSCALL(ip) ((ip) -= 2)
-#define REGS_RESTART_SYSCALL(r) IP_RESTART_SYSCALL(REGS_IP(r))
-
-#define REGS_FAULT_ADDR(r) ((r)->fault_addr)
-
-#define REGS_FAULT_WRITE(r) FAULT_WRITE((r)->fault_type)
-
-#define REGS_TRAP(r) ((r)->trap_type)
-
-#define REGS_ERR(r) ((r)->fault_type)
-
-struct uml_pt_regs {
-	unsigned long gp[MAX_REG_NR];
-	unsigned long fp[HOST_FP_SIZE];
-	struct faultinfo faultinfo;
-	long syscall;
-	int is_user;
-};
-
-#define EMPTY_UML_PT_REGS { }
-
-#define UPT_RBX(r) REGS_RBX((r)->gp)
-#define UPT_RCX(r) REGS_RCX((r)->gp)
-#define UPT_RDX(r) REGS_RDX((r)->gp)
-#define UPT_RSI(r) REGS_RSI((r)->gp)
-#define UPT_RDI(r) REGS_RDI((r)->gp)
-#define UPT_RBP(r) REGS_RBP((r)->gp)
-#define UPT_RAX(r) REGS_RAX((r)->gp)
 #define UPT_R8(r) REGS_R8((r)->gp)
 #define UPT_R9(r) REGS_R9((r)->gp)
 #define UPT_R10(r) REGS_R10((r)->gp)
  
  
@@ -105,50 +49,13 @@
 #define UPT_R13(r) REGS_R13((r)->gp)
 #define UPT_R14(r) REGS_R14((r)->gp)
 #define UPT_R15(r) REGS_R15((r)->gp)
-#define UPT_CS(r) REGS_CS((r)->gp)
-#define UPT_FS_BASE(r) REGS_FS_BASE((r)->gp)
-#define UPT_FS(r) REGS_FS((r)->gp)
-#define UPT_GS_BASE(r) REGS_GS_BASE((r)->gp)
-#define UPT_GS(r) REGS_GS((r)->gp)
-#define UPT_DS(r) REGS_DS((r)->gp)
-#define UPT_ES(r) REGS_ES((r)->gp)
-#define UPT_CS(r) REGS_CS((r)->gp)
-#define UPT_SS(r) REGS_SS((r)->gp)
-#define UPT_ORIG_RAX(r) REGS_ORIG_RAX((r)->gp)
  
-#define UPT_IP(r) REGS_IP((r)->gp)
-#define UPT_SP(r) REGS_SP((r)->gp)
-
-#define UPT_EFLAGS(r) REGS_EFLAGS((r)->gp)
-#define UPT_SYSCALL_NR(r) ((r)->syscall)
-#define UPT_SYSCALL_RET(r) UPT_RAX(r)
-
-extern int user_context(unsigned long sp);
-
-#define UPT_IS_USER(r) ((r)->is_user)
-
-#define UPT_SYSCALL_ARG1(r) UPT_RDI(r)
-#define UPT_SYSCALL_ARG2(r) UPT_RSI(r)
-#define UPT_SYSCALL_ARG3(r) UPT_RDX(r)
+#define UPT_SYSCALL_ARG1(r) UPT_DI(r)
+#define UPT_SYSCALL_ARG2(r) UPT_SI(r)
+#define UPT_SYSCALL_ARG3(r) UPT_DX(r)
 #define UPT_SYSCALL_ARG4(r) UPT_R10(r)
 #define UPT_SYSCALL_ARG5(r) UPT_R8(r)
 #define UPT_SYSCALL_ARG6(r) UPT_R9(r)
-
-struct syscall_args {
-	unsigned long args[6];
-};
-
-#define SYSCALL_ARGS(r) ((struct syscall_args) \
-			 { .args = { UPT_SYSCALL_ARG1(r),	 \
-				     UPT_SYSCALL_ARG2(r),	 \
-				     UPT_SYSCALL_ARG3(r),	 \
-				     UPT_SYSCALL_ARG4(r),	 \
-				     UPT_SYSCALL_ARG5(r),	 \
-				     UPT_SYSCALL_ARG6(r) } } )
-
-#define UPT_RESTART_SYSCALL(r) REGS_RESTART_SYSCALL((r)->gp)
-
-#define UPT_FAULTINFO(r) (&(r)->faultinfo)
  
 static inline void arch_init_registers(int pid)
 {
@@ -413,9 +413,9 @@
  
 	PT_REGS_SP(regs) = (unsigned long) frame;
 	PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
-	PT_REGS_EAX(regs) = (unsigned long) sig;
-	PT_REGS_EDX(regs) = (unsigned long) 0;
-	PT_REGS_ECX(regs) = (unsigned long) 0;
+	PT_REGS_AX(regs) = (unsigned long) sig;
+	PT_REGS_DX(regs) = (unsigned long) 0;
+	PT_REGS_CX(regs) = (unsigned long) 0;
  
 	if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
 		ptrace_notify(SIGTRAP);
@@ -463,9 +463,9 @@
  
 	PT_REGS_SP(regs) = (unsigned long) frame;
 	PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
-	PT_REGS_EAX(regs) = (unsigned long) sig;
-	PT_REGS_EDX(regs) = (unsigned long) &frame->info;
-	PT_REGS_ECX(regs) = (unsigned long) &frame->uc;
+	PT_REGS_AX(regs) = (unsigned long) sig;
+	PT_REGS_DX(regs) = (unsigned long) &frame->info;
+	PT_REGS_CX(regs) = (unsigned long) &frame->uc;
  
 	if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
 		ptrace_notify(SIGTRAP);
  
  
@@ -573,17 +573,17 @@
 	}
  
 	PT_REGS_SP(regs) = (unsigned long) frame;
-	PT_REGS_RDI(regs) = sig;
+	PT_REGS_DI(regs) = sig;
 	/* In case the signal handler was declared without prototypes */
-	PT_REGS_RAX(regs) = 0;
+	PT_REGS_AX(regs) = 0;
  
 	/*
 	 * This also works for non SA_SIGINFO handlers because they expect the
 	 * next argument after the signal number on the stack.
 	 */
-	PT_REGS_RSI(regs) = (unsigned long) &frame->info;
-	PT_REGS_RDX(regs) = (unsigned long) &frame->uc;
-	PT_REGS_RIP(regs) = (unsigned long) ka->sa.sa_handler;
+	PT_REGS_SI(regs) = (unsigned long) &frame->info;
+	PT_REGS_DX(regs) = (unsigned long) &frame->uc;
+	PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
  out:
 	return err;
 }
@@ -23,12 +23,10 @@
         printk(" EFLAGS: %08lx\n    %s\n", PT_REGS_EFLAGS(regs),
 	       print_tainted());
         printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n",
-                PT_REGS_EAX(regs), PT_REGS_EBX(regs), 
-	       PT_REGS_ECX(regs), 
-	       PT_REGS_EDX(regs));
+               PT_REGS_AX(regs), PT_REGS_BX(regs), 
+	       PT_REGS_CX(regs), PT_REGS_DX(regs));
         printk("ESI: %08lx EDI: %08lx EBP: %08lx",
-	       PT_REGS_ESI(regs), PT_REGS_EDI(regs), 
-	       PT_REGS_EBP(regs));
+	       PT_REGS_SI(regs), PT_REGS_DI(regs), PT_REGS_BP(regs));
         printk(" DS: %04lx ES: %04lx\n",
 	       0xffff & PT_REGS_DS(regs), 
 	       0xffff & PT_REGS_ES(regs));
@@ -19,15 +19,15 @@
 	printk(KERN_INFO "Pid: %d, comm: %.20s %s %s\n", task_pid_nr(current),
 		current->comm, print_tainted(), init_utsname()->release);
 	printk(KERN_INFO "RIP: %04lx:[<%016lx>]\n", PT_REGS_CS(regs) & 0xffff,
-	       PT_REGS_RIP(regs));
+	       PT_REGS_IP(regs));
 	printk(KERN_INFO "RSP: %016lx  EFLAGS: %08lx\n", PT_REGS_SP(regs),
 	       PT_REGS_EFLAGS(regs));
 	printk(KERN_INFO "RAX: %016lx RBX: %016lx RCX: %016lx\n",
-	       PT_REGS_RAX(regs), PT_REGS_RBX(regs), PT_REGS_RCX(regs));
+	       PT_REGS_AX(regs), PT_REGS_BX(regs), PT_REGS_CX(regs));
 	printk(KERN_INFO "RDX: %016lx RSI: %016lx RDI: %016lx\n",
-	       PT_REGS_RDX(regs), PT_REGS_RSI(regs), PT_REGS_RDI(regs));
+	       PT_REGS_DX(regs), PT_REGS_SI(regs), PT_REGS_DI(regs));
 	printk(KERN_INFO "RBP: %016lx R08: %016lx R09: %016lx\n",
-	       PT_REGS_RBP(regs), PT_REGS_R8(regs), PT_REGS_R9(regs));
+	       PT_REGS_BP(regs), PT_REGS_R8(regs), PT_REGS_R9(regs));
 	printk(KERN_INFO "R10: %016lx R11: %016lx R12: %016lx\n",
 	       PT_REGS_R10(regs), PT_REGS_R11(regs), PT_REGS_R12(regs));
 	printk(KERN_INFO "R13: %016lx R14: %016lx R15: %016lx\n",
@@ -219,7 +219,7 @@
 	int idx, ret = -EFAULT;
  
 	if (copy_from_user(&info,
-			   (void __user *) UPT_ESI(&new->thread.regs.regs),
+			   (void __user *) UPT_SI(&new->thread.regs.regs),
 			   sizeof(info)))
 		goto out;
...	...	@@ -196,7 +196,7 @@
196	196	if (current->thread.forking) {
197	197	memcpy(&p->thread.regs.regs, &regs->regs,
198	198	sizeof(p->thread.regs.regs));
199		- REGS_SET_SYSCALL_RETURN(p->thread.regs.regs.gp, 0);
	199	+ UPT_SET_SYSCALL_RETURN(&p->thread.regs.regs, 0);
200	200	if (sp != 0)
201	201	REGS_SP(p->thread.regs.regs.gp) = sp;
202	202
...	...	@@ -34,7 +34,7 @@
34	34	result = -ENOSYS;
35	35	else result = EXECUTE_SYSCALL(syscall, regs);
36	36
37		- REGS_SET_SYSCALL_RETURN(r->gp, result);
	37	+ UPT_SET_SYSCALL_RETURN(r, result);
38	38
39	39	syscall_trace(r, 1);
40	40	}
...	...	@@ -34,25 +34,25 @@
34	34	#define ELF_ARCH EM_386
35	35
36	36	#define ELF_PLAT_INIT(regs, load_addr) do { \
37		- PT_REGS_EBX(regs) = 0; \
38		- PT_REGS_ECX(regs) = 0; \
39		- PT_REGS_EDX(regs) = 0; \
40		- PT_REGS_ESI(regs) = 0; \
41		- PT_REGS_EDI(regs) = 0; \
42		- PT_REGS_EBP(regs) = 0; \
43		- PT_REGS_EAX(regs) = 0; \
	37	+ PT_REGS_BX(regs) = 0; \
	38	+ PT_REGS_CX(regs) = 0; \
	39	+ PT_REGS_DX(regs) = 0; \
	40	+ PT_REGS_SI(regs) = 0; \
	41	+ PT_REGS_DI(regs) = 0; \
	42	+ PT_REGS_BP(regs) = 0; \
	43	+ PT_REGS_AX(regs) = 0; \
44	44	} while (0)
45	45
46	46	/* Shamelessly stolen from include/asm-i386/elf.h */
47	47
48	48	#define ELF_CORE_COPY_REGS(pr_reg, regs) do { \
49		- pr_reg[0] = PT_REGS_EBX(regs); \
50		- pr_reg[1] = PT_REGS_ECX(regs); \
51		- pr_reg[2] = PT_REGS_EDX(regs); \
52		- pr_reg[3] = PT_REGS_ESI(regs); \
53		- pr_reg[4] = PT_REGS_EDI(regs); \
54		- pr_reg[5] = PT_REGS_EBP(regs); \
55		- pr_reg[6] = PT_REGS_EAX(regs); \
	49	+ pr_reg[0] = PT_REGS_BX(regs); \
	50	+ pr_reg[1] = PT_REGS_CX(regs); \
	51	+ pr_reg[2] = PT_REGS_DX(regs); \
	52	+ pr_reg[3] = PT_REGS_SI(regs); \
	53	+ pr_reg[4] = PT_REGS_DI(regs); \
	54	+ pr_reg[5] = PT_REGS_BP(regs); \
	55	+ pr_reg[6] = PT_REGS_AX(regs); \
56	56	pr_reg[7] = PT_REGS_DS(regs); \
57	57	pr_reg[8] = PT_REGS_ES(regs); \
58	58	/* fake once used fs and gs selectors? */ \
...	...	@@ -130,13 +130,13 @@
130	130	#define ELF_ARCH EM_X86_64
131	131
132	132	#define ELF_PLAT_INIT(regs, load_addr) do { \
133		- PT_REGS_RBX(regs) = 0; \
134		- PT_REGS_RCX(regs) = 0; \
135		- PT_REGS_RDX(regs) = 0; \
136		- PT_REGS_RSI(regs) = 0; \
137		- PT_REGS_RDI(regs) = 0; \
138		- PT_REGS_RBP(regs) = 0; \
139		- PT_REGS_RAX(regs) = 0; \
	133	+ PT_REGS_BX(regs) = 0; \
	134	+ PT_REGS_CX(regs) = 0; \
	135	+ PT_REGS_DX(regs) = 0; \
	136	+ PT_REGS_SI(regs) = 0; \
	137	+ PT_REGS_DI(regs) = 0; \
	138	+ PT_REGS_BP(regs) = 0; \
	139	+ PT_REGS_AX(regs) = 0; \
140	140	PT_REGS_R8(regs) = 0; \
141	141	PT_REGS_R9(regs) = 0; \
142	142	PT_REGS_R10(regs) = 0; \
	1	+#ifndef __UM_X86_PTRACE_H
	2	+#define __UM_X86_PTRACE_H
	3	+
1	4	#ifdef CONFIG_X86_32
2	5	# include "ptrace_32.h"
3	6	#else
4	7	# include "ptrace_64.h"
5	8	#endif
	9	+
	10	+#define PT_REGS_AX(r) UPT_AX(&(r)->regs)
	11	+#define PT_REGS_BX(r) UPT_BX(&(r)->regs)
	12	+#define PT_REGS_CX(r) UPT_CX(&(r)->regs)
	13	+#define PT_REGS_DX(r) UPT_DX(&(r)->regs)
	14	+
	15	+#define PT_REGS_SI(r) UPT_SI(&(r)->regs)
	16	+#define PT_REGS_DI(r) UPT_DI(&(r)->regs)
	17	+#define PT_REGS_BP(r) UPT_BP(&(r)->regs)
	18	+#define PT_REGS_EFLAGS(r) UPT_EFLAGS(&(r)->regs)
	19	+
	20	+#define PT_REGS_CS(r) UPT_CS(&(r)->regs)
	21	+#define PT_REGS_SS(r) UPT_SS(&(r)->regs)
	22	+#define PT_REGS_DS(r) UPT_DS(&(r)->regs)
	23	+#define PT_REGS_ES(r) UPT_ES(&(r)->regs)
	24	+
	25	+#define PT_REGS_ORIG_SYSCALL(r) PT_REGS_AX(r)
	26	+#define PT_REGS_SYSCALL_RET(r) PT_REGS_AX(r)
	27	+
	28	+#define PT_FIX_EXEC_STACK(sp) do ; while(0)
	29	+
	30	+#define profile_pc(regs) PT_REGS_IP(regs)
	31	+
	32	+#define UPT_RESTART_SYSCALL(r) (UPT_IP(r) -= 2)
	33	+#define UPT_SET_SYSCALL_RETURN(r, res) (UPT_AX(r) = (res))
	34	+
	35	+static inline long regs_return_value(struct uml_pt_regs *regs)
	36	+{
	37	+ return UPT_AX(regs);
	38	+}
	39	+#endif /* __UM_X86_PTRACE_H */
...	...	@@ -11,29 +11,6 @@
11	11	#include "linux/compiler.h"
12	12	#include "asm/ptrace-generic.h"
13	13
14		-#define PT_REGS_EAX(r) UPT_EAX(&(r)->regs)
15		-#define PT_REGS_EBX(r) UPT_EBX(&(r)->regs)
16		-#define PT_REGS_ECX(r) UPT_ECX(&(r)->regs)
17		-#define PT_REGS_EDX(r) UPT_EDX(&(r)->regs)
18		-#define PT_REGS_ESI(r) UPT_ESI(&(r)->regs)
19		-#define PT_REGS_EDI(r) UPT_EDI(&(r)->regs)
20		-#define PT_REGS_EBP(r) UPT_EBP(&(r)->regs)
21		-
22		-#define PT_REGS_CS(r) UPT_CS(&(r)->regs)
23		-#define PT_REGS_SS(r) UPT_SS(&(r)->regs)
24		-#define PT_REGS_DS(r) UPT_DS(&(r)->regs)
25		-#define PT_REGS_ES(r) UPT_ES(&(r)->regs)
26		-#define PT_REGS_FS(r) UPT_FS(&(r)->regs)
27		-#define PT_REGS_GS(r) UPT_GS(&(r)->regs)
28		-
29		-#define PT_REGS_EFLAGS(r) UPT_EFLAGS(&(r)->regs)
30		-
31		-#define PT_REGS_ORIG_SYSCALL(r) PT_REGS_EAX(r)
32		-#define PT_REGS_SYSCALL_RET(r) PT_REGS_EAX(r)
33		-#define PT_FIX_EXEC_STACK(sp) do ; while(0)
34		-
35		-#define profile_pc(regs) PT_REGS_IP(regs)
36		-
37	14	#define user_mode(r) UPT_IS_USER(&(r)->regs)
38	15
39	16	/*
...	...	@@ -15,13 +15,6 @@
15	15
16	16	#define HOST_AUDIT_ARCH AUDIT_ARCH_X86_64
17	17
18		-#define PT_REGS_RBX(r) UPT_RBX(&(r)->regs)
19		-#define PT_REGS_RCX(r) UPT_RCX(&(r)->regs)
20		-#define PT_REGS_RDX(r) UPT_RDX(&(r)->regs)
21		-#define PT_REGS_RSI(r) UPT_RSI(&(r)->regs)
22		-#define PT_REGS_RDI(r) UPT_RDI(&(r)->regs)
23		-#define PT_REGS_RBP(r) UPT_RBP(&(r)->regs)
24		-#define PT_REGS_RAX(r) UPT_RAX(&(r)->regs)
25	18	#define PT_REGS_R8(r) UPT_R8(&(r)->regs)
26	19	#define PT_REGS_R9(r) UPT_R9(&(r)->regs)
27	20	#define PT_REGS_R10(r) UPT_R10(&(r)->regs)
28	21
...	...	@@ -31,27 +24,8 @@
31	24	#define PT_REGS_R14(r) UPT_R14(&(r)->regs)
32	25	#define PT_REGS_R15(r) UPT_R15(&(r)->regs)
33	26
34		-#define PT_REGS_FS(r) UPT_FS(&(r)->regs)
35		-#define PT_REGS_GS(r) UPT_GS(&(r)->regs)
36		-#define PT_REGS_DS(r) UPT_DS(&(r)->regs)
37		-#define PT_REGS_ES(r) UPT_ES(&(r)->regs)
38		-#define PT_REGS_SS(r) UPT_SS(&(r)->regs)
39		-#define PT_REGS_CS(r) UPT_CS(&(r)->regs)
40		-
41		-#define PT_REGS_ORIG_RAX(r) UPT_ORIG_RAX(&(r)->regs)
42		-#define PT_REGS_RIP(r) UPT_IP(&(r)->regs)
43		-#define PT_REGS_SP(r) UPT_SP(&(r)->regs)
44		-
45		-#define PT_REGS_EFLAGS(r) UPT_EFLAGS(&(r)->regs)
46		-
47	27	/* XXX */
48	28	#define user_mode(r) UPT_IS_USER(&(r)->regs)
49		-#define PT_REGS_ORIG_SYSCALL(r) PT_REGS_RAX(r)
50		-#define PT_REGS_SYSCALL_RET(r) PT_REGS_RAX(r)
51		-
52		-#define PT_FIX_EXEC_STACK(sp) do ; while(0)
53		-
54		-#define profile_pc(regs) PT_REGS_IP(regs)
55	29
56	30	struct user_desc;
57	31
1	1	#ifndef __SYSDEP_X86_PTRACE_H
2	2	#define __SYSDEP_X86_PTRACE_H
3	3
	4	+#include <generated/user_constants.h>
	5	+#include "sysdep/faultinfo.h"
	6	+
	7	+#define MAX_REG_OFFSET (UM_FRAME_SIZE)
	8	+#define MAX_REG_NR ((MAX_REG_OFFSET) / sizeof(unsigned long))
	9	+
	10	+#define REGS_IP(r) ((r)[HOST_IP])
	11	+#define REGS_SP(r) ((r)[HOST_SP])
	12	+#define REGS_EFLAGS(r) ((r)[HOST_EFLAGS])
	13	+#define REGS_AX(r) ((r)[HOST_AX])
	14	+#define REGS_BX(r) ((r)[HOST_BX])
	15	+#define REGS_CX(r) ((r)[HOST_CX])
	16	+#define REGS_DX(r) ((r)[HOST_DX])
	17	+#define REGS_SI(r) ((r)[HOST_SI])
	18	+#define REGS_DI(r) ((r)[HOST_DI])
	19	+#define REGS_BP(r) ((r)[HOST_BP])
	20	+#define REGS_CS(r) ((r)[HOST_CS])
	21	+#define REGS_SS(r) ((r)[HOST_SS])
	22	+#define REGS_DS(r) ((r)[HOST_DS])
	23	+#define REGS_ES(r) ((r)[HOST_ES])
	24	+
	25	+#define UPT_IP(r) REGS_IP((r)->gp)
	26	+#define UPT_SP(r) REGS_SP((r)->gp)
	27	+#define UPT_EFLAGS(r) REGS_EFLAGS((r)->gp)
	28	+#define UPT_AX(r) REGS_AX((r)->gp)
	29	+#define UPT_BX(r) REGS_BX((r)->gp)
	30	+#define UPT_CX(r) REGS_CX((r)->gp)
	31	+#define UPT_DX(r) REGS_DX((r)->gp)
	32	+#define UPT_SI(r) REGS_SI((r)->gp)
	33	+#define UPT_DI(r) REGS_DI((r)->gp)
	34	+#define UPT_BP(r) REGS_BP((r)->gp)
	35	+#define UPT_CS(r) REGS_CS((r)->gp)
	36	+#define UPT_SS(r) REGS_SS((r)->gp)
	37	+#define UPT_DS(r) REGS_DS((r)->gp)
	38	+#define UPT_ES(r) REGS_ES((r)->gp)
	39	+
4	40	#ifdef __i386__
5	41	#include "ptrace_32.h"
6	42	#else
7	43	#include "ptrace_64.h"
8	44	#endif
9	45
10		-static inline long regs_return_value(struct uml_pt_regs *regs)
11		-{
12		- return UPT_SYSCALL_RET(regs);
13		-}
	46	+struct syscall_args {
	47	+ unsigned long args[6];
	48	+};
	49	+
	50	+#define SYSCALL_ARGS(r) ((struct syscall_args) \
	51	+ { .args = { UPT_SYSCALL_ARG1(r), \
	52	+ UPT_SYSCALL_ARG2(r), \
	53	+ UPT_SYSCALL_ARG3(r), \
	54	+ UPT_SYSCALL_ARG4(r), \
	55	+ UPT_SYSCALL_ARG5(r), \
	56	+ UPT_SYSCALL_ARG6(r) } } )
	57	+
	58	+struct uml_pt_regs {
	59	+ unsigned long gp[MAX_REG_NR];
	60	+ unsigned long fp[MAX_FP_NR];
	61	+ struct faultinfo faultinfo;
	62	+ long syscall;
	63	+ int is_user;
	64	+};
	65	+
	66	+#define EMPTY_UML_PT_REGS { }
	67	+
	68	+#define UPT_SYSCALL_NR(r) ((r)->syscall)
	69	+#define UPT_FAULTINFO(r) (&(r)->faultinfo)
	70	+#define UPT_IS_USER(r) ((r)->is_user)
	71	+
	72	+extern int user_context(unsigned long sp);
14	73
15	74	#endif /* __SYSDEP_X86_PTRACE_H */
...	...	@@ -6,12 +6,8 @@
6	6	#ifndef __SYSDEP_I386_PTRACE_H
7	7	#define __SYSDEP_I386_PTRACE_H
8	8
9		-#include <generated/user_constants.h>
10		-#include "sysdep/faultinfo.h"
	9	+#define MAX_FP_NR HOST_FPX_SIZE
11	10
12		-#define MAX_REG_NR (UM_FRAME_SIZE / sizeof(unsigned long))
13		-#define MAX_REG_OFFSET (UM_FRAME_SIZE)
14		-
15	11	static inline void update_debugregs(int seq) {}
16	12
17	13	/* syscall emulation path in ptrace */
18	14
...	...	@@ -24,90 +20,16 @@
24	20	int get_using_sysemu(void);
25	21	extern int sysemu_supported;
26	22
27		-#define REGS_IP(r) ((r)[HOST_IP])
28		-#define REGS_SP(r) ((r)[HOST_SP])
29		-#define REGS_EFLAGS(r) ((r)[HOST_EFLAGS])
30		-#define REGS_EAX(r) ((r)[HOST_AX])
31		-#define REGS_EBX(r) ((r)[HOST_BX])
32		-#define REGS_ECX(r) ((r)[HOST_CX])
33		-#define REGS_EDX(r) ((r)[HOST_DX])
34		-#define REGS_ESI(r) ((r)[HOST_SI])
35		-#define REGS_EDI(r) ((r)[HOST_DI])
36		-#define REGS_EBP(r) ((r)[HOST_BP])
37		-#define REGS_CS(r) ((r)[HOST_CS])
38		-#define REGS_SS(r) ((r)[HOST_SS])
39		-#define REGS_DS(r) ((r)[HOST_DS])
40		-#define REGS_ES(r) ((r)[HOST_ES])
41		-#define REGS_FS(r) ((r)[HOST_FS])
42		-#define REGS_GS(r) ((r)[HOST_GS])
43		-
44		-#define REGS_SET_SYSCALL_RETURN(r, res) REGS_EAX(r) = (res)
45		-
46		-#define IP_RESTART_SYSCALL(ip) ((ip) -= 2)
47		-#define REGS_RESTART_SYSCALL(r) IP_RESTART_SYSCALL(REGS_IP(r))
48		-
49	23	#ifndef PTRACE_SYSEMU_SINGLESTEP
50	24	#define PTRACE_SYSEMU_SINGLESTEP 32
51	25	#endif
52	26
53		-struct uml_pt_regs {
54		- unsigned long gp[MAX_REG_NR];
55		- unsigned long fp[HOST_FPX_SIZE];
56		- struct faultinfo faultinfo;
57		- long syscall;
58		- int is_user;
59		-};
60		-
61		-#define EMPTY_UML_PT_REGS { }
62		-
63		-#define UPT_IP(r) REGS_IP((r)->gp)
64		-#define UPT_SP(r) REGS_SP((r)->gp)
65		-#define UPT_EFLAGS(r) REGS_EFLAGS((r)->gp)
66		-#define UPT_EAX(r) REGS_EAX((r)->gp)
67		-#define UPT_EBX(r) REGS_EBX((r)->gp)
68		-#define UPT_ECX(r) REGS_ECX((r)->gp)
69		-#define UPT_EDX(r) REGS_EDX((r)->gp)
70		-#define UPT_ESI(r) REGS_ESI((r)->gp)
71		-#define UPT_EDI(r) REGS_EDI((r)->gp)
72		-#define UPT_EBP(r) REGS_EBP((r)->gp)
73		-#define UPT_ORIG_EAX(r) ((r)->syscall)
74		-#define UPT_CS(r) REGS_CS((r)->gp)
75		-#define UPT_SS(r) REGS_SS((r)->gp)
76		-#define UPT_DS(r) REGS_DS((r)->gp)
77		-#define UPT_ES(r) REGS_ES((r)->gp)
78		-#define UPT_FS(r) REGS_FS((r)->gp)
79		-#define UPT_GS(r) REGS_GS((r)->gp)
80		-
81		-#define UPT_SYSCALL_ARG1(r) UPT_EBX(r)
82		-#define UPT_SYSCALL_ARG2(r) UPT_ECX(r)
83		-#define UPT_SYSCALL_ARG3(r) UPT_EDX(r)
84		-#define UPT_SYSCALL_ARG4(r) UPT_ESI(r)
85		-#define UPT_SYSCALL_ARG5(r) UPT_EDI(r)
86		-#define UPT_SYSCALL_ARG6(r) UPT_EBP(r)
87		-
88		-extern int user_context(unsigned long sp);
89		-
90		-#define UPT_IS_USER(r) ((r)->is_user)
91		-
92		-struct syscall_args {
93		- unsigned long args[6];
94		-};
95		-
96		-#define SYSCALL_ARGS(r) ((struct syscall_args) \
97		- { .args = { UPT_SYSCALL_ARG1(r), \
98		- UPT_SYSCALL_ARG2(r), \
99		- UPT_SYSCALL_ARG3(r), \
100		- UPT_SYSCALL_ARG4(r), \
101		- UPT_SYSCALL_ARG5(r), \
102		- UPT_SYSCALL_ARG6(r) } } )
103		-
104		-#define UPT_RESTART_SYSCALL(r) REGS_RESTART_SYSCALL((r)->gp)
105		-
106		-#define UPT_ORIG_SYSCALL(r) UPT_EAX(r)
107		-#define UPT_SYSCALL_NR(r) UPT_ORIG_EAX(r)
108		-#define UPT_SYSCALL_RET(r) UPT_EAX(r)
109		-
110		-#define UPT_FAULTINFO(r) (&(r)->faultinfo)
	27	+#define UPT_SYSCALL_ARG1(r) UPT_BX(r)
	28	+#define UPT_SYSCALL_ARG2(r) UPT_CX(r)
	29	+#define UPT_SYSCALL_ARG3(r) UPT_DX(r)
	30	+#define UPT_SYSCALL_ARG4(r) UPT_SI(r)
	31	+#define UPT_SYSCALL_ARG5(r) UPT_DI(r)
	32	+#define UPT_SYSCALL_ARG6(r) UPT_BP(r)
111	33
112	34	extern void arch_init_registers(int pid);
113	35
...	...	@@ -8,22 +8,8 @@
8	8	#ifndef __SYSDEP_X86_64_PTRACE_H
9	9	#define __SYSDEP_X86_64_PTRACE_H
10	10
11		-#include <generated/user_constants.h>
12		-#include "sysdep/faultinfo.h"
	11	+#define MAX_FP_NR HOST_FP_SIZE
13	12
14		-#define MAX_REG_OFFSET (UM_FRAME_SIZE)
15		-#define MAX_REG_NR ((MAX_REG_OFFSET) / sizeof(unsigned long))
16		-
17		-#define REGS_IP(r) ((r)[HOST_IP])
18		-#define REGS_SP(r) ((r)[HOST_SP])
19		-
20		-#define REGS_RBX(r) ((r)[HOST_BX])
21		-#define REGS_RCX(r) ((r)[HOST_CX])
22		-#define REGS_RDX(r) ((r)[HOST_DX])
23		-#define REGS_RSI(r) ((r)[HOST_SI])
24		-#define REGS_RDI(r) ((r)[HOST_DI])
25		-#define REGS_RBP(r) ((r)[HOST_BP])
26		-#define REGS_RAX(r) ((r)[HOST_AX])
27	13	#define REGS_R8(r) ((r)[HOST_R8])
28	14	#define REGS_R9(r) ((r)[HOST_R9])
29	15	#define REGS_R10(r) ((r)[HOST_R10])
...	...	@@ -32,9 +18,6 @@
32	18	#define REGS_R13(r) ((r)[HOST_R13])
33	19	#define REGS_R14(r) ((r)[HOST_R14])
34	20	#define REGS_R15(r) ((r)[HOST_R15])
35		-#define REGS_CS(r) ((r)[HOST_CS])
36		-#define REGS_EFLAGS(r) ((r)[HOST_EFLAGS])
37		-#define REGS_SS(r) ((r)[HOST_SS])
38	21
39	22	#define HOST_FS_BASE 21
40	23	#define HOST_GS_BASE 22
...	...	@@ -58,45 +41,6 @@
58	41	#define GS (HOST_GS * sizeof(long))
59	42	#endif
60	43
61		-#define REGS_FS_BASE(r) ((r)[HOST_FS_BASE])
62		-#define REGS_GS_BASE(r) ((r)[HOST_GS_BASE])
63		-#define REGS_DS(r) ((r)[HOST_DS])
64		-#define REGS_ES(r) ((r)[HOST_ES])
65		-#define REGS_FS(r) ((r)[HOST_FS])
66		-#define REGS_GS(r) ((r)[HOST_GS])
67		-
68		-#define REGS_ORIG_RAX(r) ((r)[HOST_ORIG_AX])
69		-
70		-#define REGS_SET_SYSCALL_RETURN(r, res) REGS_RAX(r) = (res)
71		-
72		-#define IP_RESTART_SYSCALL(ip) ((ip) -= 2)
73		-#define REGS_RESTART_SYSCALL(r) IP_RESTART_SYSCALL(REGS_IP(r))
74		-
75		-#define REGS_FAULT_ADDR(r) ((r)->fault_addr)
76		-
77		-#define REGS_FAULT_WRITE(r) FAULT_WRITE((r)->fault_type)
78		-
79		-#define REGS_TRAP(r) ((r)->trap_type)
80		-
81		-#define REGS_ERR(r) ((r)->fault_type)
82		-
83		-struct uml_pt_regs {
84		- unsigned long gp[MAX_REG_NR];
85		- unsigned long fp[HOST_FP_SIZE];
86		- struct faultinfo faultinfo;
87		- long syscall;
88		- int is_user;
89		-};
90		-
91		-#define EMPTY_UML_PT_REGS { }
92		-
93		-#define UPT_RBX(r) REGS_RBX((r)->gp)
94		-#define UPT_RCX(r) REGS_RCX((r)->gp)
95		-#define UPT_RDX(r) REGS_RDX((r)->gp)
96		-#define UPT_RSI(r) REGS_RSI((r)->gp)
97		-#define UPT_RDI(r) REGS_RDI((r)->gp)
98		-#define UPT_RBP(r) REGS_RBP((r)->gp)
99		-#define UPT_RAX(r) REGS_RAX((r)->gp)
100	44	#define UPT_R8(r) REGS_R8((r)->gp)
101	45	#define UPT_R9(r) REGS_R9((r)->gp)
102	46	#define UPT_R10(r) REGS_R10((r)->gp)
103	47
104	48
...	...	@@ -105,50 +49,13 @@
105	49	#define UPT_R13(r) REGS_R13((r)->gp)
106	50	#define UPT_R14(r) REGS_R14((r)->gp)
107	51	#define UPT_R15(r) REGS_R15((r)->gp)
108		-#define UPT_CS(r) REGS_CS((r)->gp)
109		-#define UPT_FS_BASE(r) REGS_FS_BASE((r)->gp)
110		-#define UPT_FS(r) REGS_FS((r)->gp)
111		-#define UPT_GS_BASE(r) REGS_GS_BASE((r)->gp)
112		-#define UPT_GS(r) REGS_GS((r)->gp)
113		-#define UPT_DS(r) REGS_DS((r)->gp)
114		-#define UPT_ES(r) REGS_ES((r)->gp)
115		-#define UPT_CS(r) REGS_CS((r)->gp)
116		-#define UPT_SS(r) REGS_SS((r)->gp)
117		-#define UPT_ORIG_RAX(r) REGS_ORIG_RAX((r)->gp)
118	52
119		-#define UPT_IP(r) REGS_IP((r)->gp)
120		-#define UPT_SP(r) REGS_SP((r)->gp)
121		-
122		-#define UPT_EFLAGS(r) REGS_EFLAGS((r)->gp)
123		-#define UPT_SYSCALL_NR(r) ((r)->syscall)
124		-#define UPT_SYSCALL_RET(r) UPT_RAX(r)
125		-
126		-extern int user_context(unsigned long sp);
127		-
128		-#define UPT_IS_USER(r) ((r)->is_user)
129		-
130		-#define UPT_SYSCALL_ARG1(r) UPT_RDI(r)
131		-#define UPT_SYSCALL_ARG2(r) UPT_RSI(r)
132		-#define UPT_SYSCALL_ARG3(r) UPT_RDX(r)
	53	+#define UPT_SYSCALL_ARG1(r) UPT_DI(r)
	54	+#define UPT_SYSCALL_ARG2(r) UPT_SI(r)
	55	+#define UPT_SYSCALL_ARG3(r) UPT_DX(r)
133	56	#define UPT_SYSCALL_ARG4(r) UPT_R10(r)
134	57	#define UPT_SYSCALL_ARG5(r) UPT_R8(r)
135	58	#define UPT_SYSCALL_ARG6(r) UPT_R9(r)
136		-
137		-struct syscall_args {
138		- unsigned long args[6];
139		-};
140		-
141		-#define SYSCALL_ARGS(r) ((struct syscall_args) \
142		- { .args = { UPT_SYSCALL_ARG1(r), \
143		- UPT_SYSCALL_ARG2(r), \
144		- UPT_SYSCALL_ARG3(r), \
145		- UPT_SYSCALL_ARG4(r), \
146		- UPT_SYSCALL_ARG5(r), \
147		- UPT_SYSCALL_ARG6(r) } } )
148		-
149		-#define UPT_RESTART_SYSCALL(r) REGS_RESTART_SYSCALL((r)->gp)
150		-
151		-#define UPT_FAULTINFO(r) (&(r)->faultinfo)
152	59
153	60	static inline void arch_init_registers(int pid)
154	61	{
...	...	@@ -413,9 +413,9 @@
413	413
414	414	PT_REGS_SP(regs) = (unsigned long) frame;
415	415	PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
416		- PT_REGS_EAX(regs) = (unsigned long) sig;
417		- PT_REGS_EDX(regs) = (unsigned long) 0;
418		- PT_REGS_ECX(regs) = (unsigned long) 0;
	416	+ PT_REGS_AX(regs) = (unsigned long) sig;
	417	+ PT_REGS_DX(regs) = (unsigned long) 0;
	418	+ PT_REGS_CX(regs) = (unsigned long) 0;
419	419
420	420	if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
421	421	ptrace_notify(SIGTRAP);
...	...	@@ -463,9 +463,9 @@
463	463
464	464	PT_REGS_SP(regs) = (unsigned long) frame;
465	465	PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
466		- PT_REGS_EAX(regs) = (unsigned long) sig;
467		- PT_REGS_EDX(regs) = (unsigned long) &frame->info;
468		- PT_REGS_ECX(regs) = (unsigned long) &frame->uc;
	466	+ PT_REGS_AX(regs) = (unsigned long) sig;
	467	+ PT_REGS_DX(regs) = (unsigned long) &frame->info;
	468	+ PT_REGS_CX(regs) = (unsigned long) &frame->uc;
469	469
470	470	if ((current->ptrace & PT_DTRACE) && (current->ptrace & PT_PTRACED))
471	471	ptrace_notify(SIGTRAP);
472	472
473	473
...	...	@@ -573,17 +573,17 @@
573	573	}
574	574
575	575	PT_REGS_SP(regs) = (unsigned long) frame;
576		- PT_REGS_RDI(regs) = sig;
	576	+ PT_REGS_DI(regs) = sig;
577	577	/* In case the signal handler was declared without prototypes */
578		- PT_REGS_RAX(regs) = 0;
	578	+ PT_REGS_AX(regs) = 0;
579	579
580	580	/*
581	581	* This also works for non SA_SIGINFO handlers because they expect the
582	582	* next argument after the signal number on the stack.
583	583	*/
584		- PT_REGS_RSI(regs) = (unsigned long) &frame->info;
585		- PT_REGS_RDX(regs) = (unsigned long) &frame->uc;
586		- PT_REGS_RIP(regs) = (unsigned long) ka->sa.sa_handler;
	584	+ PT_REGS_SI(regs) = (unsigned long) &frame->info;
	585	+ PT_REGS_DX(regs) = (unsigned long) &frame->uc;
	586	+ PT_REGS_IP(regs) = (unsigned long) ka->sa.sa_handler;
587	587	out:
588	588	return err;
589	589	}