Commit 65ea5b03 authored by H. Peter Anvin's avatar H. Peter Anvin Committed by Ingo Molnar
Browse files

x86: rename the struct pt_regs members for 32/64-bit consistency 



We have a lot of code which differs only by the naming of specific
members of structures that contain registers.  In order to enable
additional unifications, this patch drops the e- or r- size prefix
from the register names in struct pt_regs, and drops the x- prefixes
for segment registers on the 32-bit side.

This patch also performs the equivalent renames in some additional
places that might be candidates for unification in the future.

Signed-off-by: default avatarH. Peter Anvin <hpa@zytor.com>
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
parent 53756d37

arch/x86/ia32/ia32_aout.c

+15 −15
Original line number Diff line number Diff line
@@ -53,7 +53,7 @@ static void dump_thread32(struct pt_regs *regs, struct user32 *dump) 
/* changed the size calculations - should hopefully work better. lbt */

	dump->magic = CMAGIC;

	dump->start_code = 0;

	dump->start_stack = regs->rsp & ~(PAGE_SIZE - 1);

	dump->start_stack = regs->sp & ~(PAGE_SIZE - 1);

	dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;

	dump->u_dsize = ((unsigned long)

			 (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
@@ -75,22 +75,22 @@ static void dump_thread32(struct pt_regs *regs, struct user32 *dump) 
		dump->u_ssize = tmp >> PAGE_SHIFT;

	}



	dump->regs.ebx = regs->rbx;

	dump->regs.ecx = regs->rcx;

	dump->regs.edx = regs->rdx;

	dump->regs.esi = regs->rsi;

	dump->regs.edi = regs->rdi;

	dump->regs.ebp = regs->rbp;

	dump->regs.eax = regs->rax;

	dump->regs.bx = regs->bx;

	dump->regs.cx = regs->cx;

	dump->regs.dx = regs->dx;

	dump->regs.si = regs->si;

	dump->regs.di = regs->di;

	dump->regs.bp = regs->bp;

	dump->regs.ax = regs->ax;

	dump->regs.ds = current->thread.ds;

	dump->regs.es = current->thread.es;

	asm("movl %%fs,%0" : "=r" (fs)); dump->regs.fs = fs;

	asm("movl %%gs,%0" : "=r" (gs)); dump->regs.gs = gs;

	dump->regs.orig_eax = regs->orig_rax;

	dump->regs.eip = regs->rip;

	dump->regs.orig_ax = regs->orig_ax;

	dump->regs.ip = regs->ip;

	dump->regs.cs = regs->cs;

	dump->regs.eflags = regs->eflags;

	dump->regs.esp = regs->rsp;

	dump->regs.flags = regs->flags;

	dump->regs.sp = regs->sp;

	dump->regs.ss = regs->ss;



#if 1 /* FIXME */
@@ -432,9 +432,9 @@ beyond_if: 
	asm volatile("movl %0,%%fs" :: "r" (0)); \

	asm volatile("movl %0,%%es; movl %0,%%ds": :"r" (__USER32_DS));

	load_gs_index(0);

	(regs)->rip = ex.a_entry;

	(regs)->rsp = current->mm->start_stack;

	(regs)->eflags = 0x200;

	(regs)->ip = ex.a_entry;

	(regs)->sp = current->mm->start_stack;

	(regs)->flags = 0x200;

	(regs)->cs = __USER32_CS;

	(regs)->ss = __USER32_DS;

	regs->r8 = regs->r9 = regs->r10 = regs->r11 =

arch/x86/ia32/ia32_binfmt.c

+21 −21
Original line number Diff line number Diff line
@@ -73,22 +73,22 @@ struct file; 
/* Assumes current==process to be dumped */

#undef	ELF_CORE_COPY_REGS

#define ELF_CORE_COPY_REGS(pr_reg, regs)       		\

	pr_reg[0] = regs->rbx;				\

	pr_reg[1] = regs->rcx;				\

	pr_reg[2] = regs->rdx;				\

	pr_reg[3] = regs->rsi;				\

	pr_reg[4] = regs->rdi;				\

	pr_reg[5] = regs->rbp;				\

	pr_reg[6] = regs->rax;				\

	pr_reg[0] = regs->bx;				\

	pr_reg[1] = regs->cx;				\

	pr_reg[2] = regs->dx;				\

	pr_reg[3] = regs->si;				\

	pr_reg[4] = regs->di;				\

	pr_reg[5] = regs->bp;				\

	pr_reg[6] = regs->ax;				\

	pr_reg[7] = _GET_SEG(ds);   			\

	pr_reg[8] = _GET_SEG(es);			\

	pr_reg[9] = _GET_SEG(fs);			\

	pr_reg[10] = _GET_SEG(gs);			\

	pr_reg[11] = regs->orig_rax;			\

	pr_reg[12] = regs->rip;				\

	pr_reg[11] = regs->orig_ax;			\

	pr_reg[12] = regs->ip;				\

	pr_reg[13] = regs->cs;				\

	pr_reg[14] = regs->eflags;			\

	pr_reg[15] = regs->rsp;				\

	pr_reg[14] = regs->flags;			\

	pr_reg[15] = regs->sp;				\

	pr_reg[16] = regs->ss;
@@ -205,9 +205,9 @@ do { \ 
	asm volatile("movl %0,%%fs" :: "r" (0)); \

	asm volatile("movl %0,%%es; movl %0,%%ds": :"r" (__USER32_DS)); \

	load_gs_index(0); \

	(regs)->rip = (new_rip); \

	(regs)->rsp = (new_rsp); \

	(regs)->eflags = 0x200; \

	(regs)->ip = (new_rip); \

	(regs)->sp = (new_rsp); \

	(regs)->flags = X86_EFLAGS_IF; \

	(regs)->cs = __USER32_CS; \

	(regs)->ss = __USER32_DS; \

	set_fs(USER_DS); \
@@ -233,13 +233,13 @@ extern int syscall32_setup_pages(struct linux_binprm *, int exstack); 
static void elf32_init(struct pt_regs *regs)

{

	struct task_struct *me = current; 

	regs->rdi = 0;

	regs->rsi = 0;

	regs->rdx = 0;

	regs->rcx = 0;

	regs->rax = 0;

	regs->rbx = 0; 

	regs->rbp = 0; 

	regs->di = 0;

	regs->si = 0;

	regs->dx = 0;

	regs->cx = 0;

	regs->ax = 0;

	regs->bx = 0;

	regs->bp = 0;

	regs->r8 = regs->r9 = regs->r10 = regs->r11 = regs->r12 =

		regs->r13 = regs->r14 = regs->r15 = 0; 

    me->thread.fs = 0;

arch/x86/ia32/ia32_signal.c

+50 −50
Original line number Diff line number Diff line
@@ -154,7 +154,7 @@ asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr, 
	}

	seg = get_fs();

	set_fs(KERNEL_DS);

	ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->rsp);

	ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->sp);

	set_fs(seg);

	if (ret >= 0 && uoss_ptr)  {

		if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)) ||
@@ -195,7 +195,7 @@ struct rt_sigframe 
#define COPY(x)		{ \

	unsigned int reg;			\

	err |= __get_user(reg, &sc->e ##x);	\

	regs->r ## x = reg;			\

	regs->x = reg;			\

}



#define RELOAD_SEG(seg,mask)						\
@@ -220,7 +220,7 @@ static int ia32_restore_sigcontext(struct pt_regs *regs, 
#if DEBUG_SIG

	printk(KERN_DEBUG "SIG restore_sigcontext: "

	       "sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",

	       sc, sc->err, sc->eip, sc->cs, sc->eflags);

	       sc, sc->err, sc->ip, sc->cs, sc->flags);

#endif



	/*
@@ -249,9 +249,9 @@ static int ia32_restore_sigcontext(struct pt_regs *regs, 
	regs->ss |= 3;



	err |= __get_user(tmpflags, &sc->eflags);

	regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);

	regs->flags = (regs->flags & ~0x40DD5) | (tmpflags & 0x40DD5);

	/* disable syscall checks */

	regs->orig_rax = -1;

	regs->orig_ax = -1;



	err |= __get_user(tmp, &sc->fpstate);

	buf = compat_ptr(tmp);
@@ -279,9 +279,9 @@ badframe: 


asmlinkage long sys32_sigreturn(struct pt_regs *regs)

{

	struct sigframe __user *frame = (struct sigframe __user *)(regs->rsp-8);

	struct sigframe __user *frame = (struct sigframe __user *)(regs->sp-8);

	sigset_t set;

	unsigned int eax;

	unsigned int ax;



	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))

		goto badframe;
@@ -298,9 +298,9 @@ asmlinkage long sys32_sigreturn(struct pt_regs *regs) 
	recalc_sigpending();

	spin_unlock_irq(&current->sighand->siglock);



	if (ia32_restore_sigcontext(regs, &frame->sc, &eax))

	if (ia32_restore_sigcontext(regs, &frame->sc, &ax))

		goto badframe;

	return eax;

	return ax;



badframe:

	signal_fault(regs, frame, "32bit sigreturn");
@@ -311,10 +311,10 @@ asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs) 
{

	struct rt_sigframe __user *frame;

	sigset_t set;

	unsigned int eax;

	unsigned int ax;

	struct pt_regs tregs;



	frame = (struct rt_sigframe __user *)(regs->rsp - 4);

	frame = (struct rt_sigframe __user *)(regs->sp - 4);



	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))

		goto badframe;
@@ -327,14 +327,14 @@ asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs) 
	recalc_sigpending();

	spin_unlock_irq(&current->sighand->siglock);



	if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &eax))

	if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))

		goto badframe;



	tregs = *regs;

	if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)

		goto badframe;



	return eax;

	return ax;



badframe:

	signal_fault(regs, frame, "32bit rt sigreturn");
@@ -361,21 +361,21 @@ static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc, 
	__asm__("movl %%es,%0" : "=r"(tmp): "0"(tmp));

	err |= __put_user(tmp, (unsigned int __user *)&sc->es);



	err |= __put_user((u32)regs->rdi, &sc->edi);

	err |= __put_user((u32)regs->rsi, &sc->esi);

	err |= __put_user((u32)regs->rbp, &sc->ebp);

	err |= __put_user((u32)regs->rsp, &sc->esp);

	err |= __put_user((u32)regs->rbx, &sc->ebx);

	err |= __put_user((u32)regs->rdx, &sc->edx);

	err |= __put_user((u32)regs->rcx, &sc->ecx);

	err |= __put_user((u32)regs->rax, &sc->eax);

	err |= __put_user((u32)regs->di, &sc->edi);

	err |= __put_user((u32)regs->si, &sc->esi);

	err |= __put_user((u32)regs->bp, &sc->ebp);

	err |= __put_user((u32)regs->sp, &sc->esp);

	err |= __put_user((u32)regs->bx, &sc->ebx);

	err |= __put_user((u32)regs->dx, &sc->edx);

	err |= __put_user((u32)regs->cx, &sc->ecx);

	err |= __put_user((u32)regs->ax, &sc->eax);

	err |= __put_user((u32)regs->cs, &sc->cs);

	err |= __put_user((u32)regs->ss, &sc->ss);

	err |= __put_user(current->thread.trap_no, &sc->trapno);

	err |= __put_user(current->thread.error_code, &sc->err);

	err |= __put_user((u32)regs->rip, &sc->eip);

	err |= __put_user((u32)regs->eflags, &sc->eflags);

	err |= __put_user((u32)regs->rsp, &sc->esp_at_signal);

	err |= __put_user((u32)regs->ip, &sc->eip);

	err |= __put_user((u32)regs->flags, &sc->eflags);

	err |= __put_user((u32)regs->sp, &sc->esp_at_signal);



	tmp = save_i387_ia32(current, fpstate, regs, 0);

	if (tmp < 0)
@@ -400,28 +400,28 @@ static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc, 
static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,

				 size_t frame_size)

{

	unsigned long rsp;

	unsigned long sp;



	/* Default to using normal stack */

	rsp = regs->rsp;

	sp = regs->sp;



	/* This is the X/Open sanctioned signal stack switching.  */

	if (ka->sa.sa_flags & SA_ONSTACK) {

		if (sas_ss_flags(rsp) == 0)

			rsp = current->sas_ss_sp + current->sas_ss_size;

		if (sas_ss_flags(sp) == 0)

			sp = current->sas_ss_sp + current->sas_ss_size;

	}



	/* This is the legacy signal stack switching. */

	else if ((regs->ss & 0xffff) != __USER_DS &&

		!(ka->sa.sa_flags & SA_RESTORER) &&

		 ka->sa.sa_restorer)

		rsp = (unsigned long) ka->sa.sa_restorer;

		sp = (unsigned long) ka->sa.sa_restorer;



	rsp -= frame_size;

	sp -= frame_size;

	/* Align the stack pointer according to the i386 ABI,

	 * i.e. so that on function entry ((sp + 4) & 15) == 0. */

	rsp = ((rsp + 4) & -16ul) - 4;

	return (void __user *) rsp;

	sp = ((sp + 4) & -16ul) - 4;

	return (void __user *) sp;

}



int ia32_setup_frame(int sig, struct k_sigaction *ka,
@@ -486,13 +486,13 @@ int ia32_setup_frame(int sig, struct k_sigaction *ka, 
		goto give_sigsegv;



	/* Set up registers for signal handler */

	regs->rsp = (unsigned long) frame;

	regs->rip = (unsigned long) ka->sa.sa_handler;

	regs->sp = (unsigned long) frame;

	regs->ip = (unsigned long) ka->sa.sa_handler;



	/* Make -mregparm=3 work */

	regs->rax = sig;

	regs->rdx = 0;

	regs->rcx = 0;

	regs->ax = sig;

	regs->dx = 0;

	regs->cx = 0;



	asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));

	asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
@@ -501,13 +501,13 @@ int ia32_setup_frame(int sig, struct k_sigaction *ka, 
	regs->ss = __USER32_DS;



	set_fs(USER_DS);

	regs->eflags &= ~TF_MASK;

	regs->flags &= ~TF_MASK;

	if (test_thread_flag(TIF_SINGLESTEP))

		ptrace_notify(SIGTRAP);



#if DEBUG_SIG

	printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",

	       current->comm, current->pid, frame, regs->rip, frame->pretcode);

	       current->comm, current->pid, frame, regs->ip, frame->pretcode);

#endif



	return 0;
@@ -556,7 +556,7 @@ int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 
	err |= __put_user(0, &frame->uc.uc_flags);

	err |= __put_user(0, &frame->uc.uc_link);

	err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);

	err |= __put_user(sas_ss_flags(regs->rsp),

	err |= __put_user(sas_ss_flags(regs->sp),

			  &frame->uc.uc_stack.ss_flags);

	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);

	err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, &frame->fpstate,
@@ -581,18 +581,18 @@ int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 
		goto give_sigsegv;



	/* Set up registers for signal handler */

	regs->rsp = (unsigned long) frame;

	regs->rip = (unsigned long) ka->sa.sa_handler;

	regs->sp = (unsigned long) frame;

	regs->ip = (unsigned long) ka->sa.sa_handler;



	/* Make -mregparm=3 work */

	regs->rax = sig;

	regs->rdx = (unsigned long) &frame->info;

	regs->rcx = (unsigned long) &frame->uc;

	regs->ax = sig;

	regs->dx = (unsigned long) &frame->info;

	regs->cx = (unsigned long) &frame->uc;



	/* Make -mregparm=3 work */

	regs->rax = sig;

	regs->rdx = (unsigned long) &frame->info;

	regs->rcx = (unsigned long) &frame->uc;

	regs->ax = sig;

	regs->dx = (unsigned long) &frame->info;

	regs->cx = (unsigned long) &frame->uc;



	asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));

	asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
@@ -601,13 +601,13 @@ int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 
	regs->ss = __USER32_DS;



	set_fs(USER_DS);

	regs->eflags &= ~TF_MASK;

	regs->flags &= ~TF_MASK;

	if (test_thread_flag(TIF_SINGLESTEP))

		ptrace_notify(SIGTRAP);



#if DEBUG_SIG

	printk(KERN_DEBUG "SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",

	       current->comm, current->pid, frame, regs->rip, frame->pretcode);

	       current->comm, current->pid, frame, regs->ip, frame->pretcode);

#endif



	return 0;

arch/x86/ia32/ptrace32.c

+22 −22
Original line number Diff line number Diff line
@@ -73,19 +73,19 @@ static int putreg32(struct task_struct *child, unsigned regno, u32 val) 
		stack[offsetof(struct pt_regs, cs)/8] = val & 0xffff;

		break;



	R32(ebx, rbx);

	R32(ecx, rcx);

	R32(edx, rdx);

	R32(edi, rdi);

	R32(esi, rsi);

	R32(ebp, rbp);

	R32(eax, rax);

	R32(orig_eax, orig_rax);

	R32(eip, rip);

	R32(esp, rsp);

	R32(ebx, bx);

	R32(ecx, cx);

	R32(edx, dx);

	R32(edi, di);

	R32(esi, si);

	R32(ebp, bp);

	R32(eax, ax);

	R32(orig_eax, orig_ax);

	R32(eip, ip);

	R32(esp, sp);



	case offsetof(struct user32, regs.eflags): {

		__u64 *flags = &stack[offsetof(struct pt_regs, eflags)/8];

		__u64 *flags = &stack[offsetof(struct pt_regs, flags)/8];



		val &= FLAG_MASK;

		/*
@@ -145,22 +145,22 @@ static int getreg32(struct task_struct *child, unsigned regno, u32 *val) 


	R32(cs, cs);

	R32(ss, ss);

	R32(ebx, rbx);

	R32(ecx, rcx);

	R32(edx, rdx);

	R32(edi, rdi);

	R32(esi, rsi);

	R32(ebp, rbp);

	R32(eax, rax);

	R32(orig_eax, orig_rax);

	R32(eip, rip);

	R32(esp, rsp);

	R32(ebx, bx);

	R32(ecx, cx);

	R32(edx, dx);

	R32(edi, di);

	R32(esi, si);

	R32(ebp, bp);

	R32(eax, ax);

	R32(orig_eax, orig_ax);

	R32(eip, ip);

	R32(esp, sp);



	case offsetof(struct user32, regs.eflags):

		/*

		 * If the debugger set TF, hide it from the readout.

		 */

		*val = stack[offsetof(struct pt_regs, eflags)/8];

		*val = stack[offsetof(struct pt_regs, flags)/8];

		if (test_tsk_thread_flag(child, TIF_FORCED_TF))

			*val &= ~X86_EFLAGS_TF;

		break;

arch/x86/ia32/sys_ia32.c

+3 −3
Original line number Diff line number Diff line
@@ -816,11 +816,11 @@ asmlinkage long sys32_execve(char __user *name, compat_uptr_t __user *argv, 
asmlinkage long sys32_clone(unsigned int clone_flags, unsigned int newsp,

			    struct pt_regs *regs)

{

	void __user *parent_tid = (void __user *)regs->rdx;

	void __user *child_tid = (void __user *)regs->rdi;

	void __user *parent_tid = (void __user *)regs->dx;

	void __user *child_tid = (void __user *)regs->di;



	if (!newsp)

		newsp = regs->rsp;

		newsp = regs->sp;

	return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE