Commit 3b4b7570 authored by Hiroshi Shimamoto's avatar Hiroshi Shimamoto Committed by H. Peter Anvin
Browse files

x86: ia32_signal: use {get|put}_user_try and catch 



Impact: use new framework

Use {get|put}_user_try, catch, and _ex in arch/x86/ia32/ia32_signal.c.

Note: this patch contains "WARNING: line over 80 characters", because when
introducing new block I insert an indent to avoid mistakes by edit.

Signed-off-by: default avatarHiroshi Shimamoto <h-shimamoto@ct.jp.nec.com>
Signed-off-by: default avatarH. Peter Anvin <hpa@linux.intel.com>
parent 98e3d45e

arch/x86/ia32/ia32_signal.c

+195 −170
Original line number Diff line number Diff line
@@ -46,78 +46,83 @@ void signal_fault(struct pt_regs *regs, void __user *frame, char *where); 


int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)

{

	int err;

	int err = 0;



	if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))

		return -EFAULT;



	put_user_try {

		/* If you change siginfo_t structure, please make sure that

		   this code is fixed accordingly.

		   It should never copy any pad contained in the structure

		   to avoid security leaks, but must copy the generic

		   3 ints plus the relevant union member.  */

	err = __put_user(from->si_signo, &to->si_signo);

	err |= __put_user(from->si_errno, &to->si_errno);

	err |= __put_user((short)from->si_code, &to->si_code);

		put_user_ex(from->si_signo, &to->si_signo);

		put_user_ex(from->si_errno, &to->si_errno);

		put_user_ex((short)from->si_code, &to->si_code);



		if (from->si_code < 0) {

		err |= __put_user(from->si_pid, &to->si_pid);

		err |= __put_user(from->si_uid, &to->si_uid);

		err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);

			put_user_ex(from->si_pid, &to->si_pid);

			put_user_ex(from->si_uid, &to->si_uid);

			put_user_ex(ptr_to_compat(from->si_ptr), &to->si_ptr);

		} else {

			/*

			 * First 32bits of unions are always present:

			 * si_pid === si_band === si_tid === si_addr(LS half)

			 */

		err |= __put_user(from->_sifields._pad[0],

			put_user_ex(from->_sifields._pad[0],

					  &to->_sifields._pad[0]);

			switch (from->si_code >> 16) {

			case __SI_FAULT >> 16:

				break;

			case __SI_CHLD >> 16:

			err |= __put_user(from->si_utime, &to->si_utime);

			err |= __put_user(from->si_stime, &to->si_stime);

			err |= __put_user(from->si_status, &to->si_status);

				put_user_ex(from->si_utime, &to->si_utime);

				put_user_ex(from->si_stime, &to->si_stime);

				put_user_ex(from->si_status, &to->si_status);

				/* FALL THROUGH */

			default:

			case __SI_KILL >> 16:

			err |= __put_user(from->si_uid, &to->si_uid);

				put_user_ex(from->si_uid, &to->si_uid);

				break;

			case __SI_POLL >> 16:

			err |= __put_user(from->si_fd, &to->si_fd);

				put_user_ex(from->si_fd, &to->si_fd);

				break;

			case __SI_TIMER >> 16:

			err |= __put_user(from->si_overrun, &to->si_overrun);

			err |= __put_user(ptr_to_compat(from->si_ptr),

				put_user_ex(from->si_overrun, &to->si_overrun);

				put_user_ex(ptr_to_compat(from->si_ptr),

					    &to->si_ptr);

				break;

				 /* This is not generated by the kernel as of now.  */

			case __SI_RT >> 16:

			case __SI_MESGQ >> 16:

			err |= __put_user(from->si_uid, &to->si_uid);

			err |= __put_user(from->si_int, &to->si_int);

				put_user_ex(from->si_uid, &to->si_uid);

				put_user_ex(from->si_int, &to->si_int);

				break;

			}

		}

	} put_user_catch(err);



	return err;

}



int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)

{

	int err;

	int err = 0;

	u32 ptr32;



	if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))

		return -EFAULT;



	err = __get_user(to->si_signo, &from->si_signo);

	err |= __get_user(to->si_errno, &from->si_errno);

	err |= __get_user(to->si_code, &from->si_code);

	get_user_try {

		get_user_ex(to->si_signo, &from->si_signo);

		get_user_ex(to->si_errno, &from->si_errno);

		get_user_ex(to->si_code, &from->si_code);



	err |= __get_user(to->si_pid, &from->si_pid);

	err |= __get_user(to->si_uid, &from->si_uid);

	err |= __get_user(ptr32, &from->si_ptr);

		get_user_ex(to->si_pid, &from->si_pid);

		get_user_ex(to->si_uid, &from->si_uid);

		get_user_ex(ptr32, &from->si_ptr);

		to->si_ptr = compat_ptr(ptr32);

	} get_user_catch(err);



	return err;

}
@@ -142,17 +147,23 @@ asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr, 
				  struct pt_regs *regs)

{

	stack_t uss, uoss;

	int ret;

	int ret, err = 0;

	mm_segment_t seg;



	if (uss_ptr) {

		u32 ptr;



		memset(&uss, 0, sizeof(stack_t));

		if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)) ||

			    __get_user(ptr, &uss_ptr->ss_sp) ||

			    __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||

			    __get_user(uss.ss_size, &uss_ptr->ss_size))

		if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)))

			return -EFAULT;



		get_user_try {

			get_user_ex(ptr, &uss_ptr->ss_sp);

			get_user_ex(uss.ss_flags, &uss_ptr->ss_flags);

			get_user_ex(uss.ss_size, &uss_ptr->ss_size);

		} get_user_catch(err);



		if (err)

			return -EFAULT;

		uss.ss_sp = compat_ptr(ptr);

	}
@@ -161,10 +172,16 @@ asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr, 
	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)) ||

		    __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||

		    __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||

		    __put_user(uoss.ss_size, &uoss_ptr->ss_size))

		if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)))

			return -EFAULT;



		put_user_try {

			put_user_ex(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp);

			put_user_ex(uoss.ss_flags, &uoss_ptr->ss_flags);

			put_user_ex(uoss.ss_size, &uoss_ptr->ss_size);

		} put_user_catch(err);



		if (err)

			ret = -EFAULT;

	}

	return ret;
@@ -174,18 +191,18 @@ asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr, 
 * Do a signal return; undo the signal stack.

 */

#define COPY(x)			{		\

	err |= __get_user(regs->x, &sc->x);	\

	get_user_ex(regs->x, &sc->x);		\

}



#define COPY_SEG_CPL3(seg)	{			\

		unsigned short tmp;			\

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

		get_user_ex(tmp, &sc->seg);		\

		regs->seg = tmp | 3;			\

}



#define RELOAD_SEG(seg)		{		\

	unsigned int cur, pre;			\

	err |= __get_user(pre, &sc->seg);	\

	get_user_ex(pre, &sc->seg);		\

	savesegment(seg, cur);			\

	pre |= 3;				\

	if (pre != cur)				\
@@ -209,13 +226,14 @@ static int ia32_restore_sigcontext(struct pt_regs *regs, 
	       sc, sc->err, sc->ip, sc->cs, sc->flags);

#endif



	get_user_try {

		/*

		 * Reload fs and gs if they have changed in the signal

		 * handler.  This does not handle long fs/gs base changes in

		 * the handler, but does not clobber them at least in the

		 * normal case.

		 */

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

		get_user_ex(gs, &sc->gs);

		gs |= 3;

		savesegment(gs, oldgs);

		if (gs != oldgs)
@@ -232,16 +250,18 @@ static int ia32_restore_sigcontext(struct pt_regs *regs, 
		COPY_SEG_CPL3(cs);

		COPY_SEG_CPL3(ss);



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

		get_user_ex(tmpflags, &sc->flags);

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

		/* disable syscall checks */

		regs->orig_ax = -1;



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

		get_user_ex(tmp, &sc->fpstate);

		buf = compat_ptr(tmp);

		err |= restore_i387_xstate_ia32(buf);



	err |= __get_user(*pax, &sc->ax);

		get_user_ex(*pax, &sc->ax);

	} get_user_catch(err);



	return err;

}
@@ -319,36 +339,38 @@ static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc, 
{

	int tmp, err = 0;



	put_user_try {

		savesegment(gs, tmp);

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

		put_user_ex(tmp, (unsigned int __user *)&sc->gs);

		savesegment(fs, tmp);

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

		put_user_ex(tmp, (unsigned int __user *)&sc->fs);

		savesegment(ds, tmp);

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

		put_user_ex(tmp, (unsigned int __user *)&sc->ds);

		savesegment(es, tmp);

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



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



	err |= __put_user(ptr_to_compat(fpstate), &sc->fpstate);

		put_user_ex(tmp, (unsigned int __user *)&sc->es);



		put_user_ex(regs->di, &sc->di);

		put_user_ex(regs->si, &sc->si);

		put_user_ex(regs->bp, &sc->bp);

		put_user_ex(regs->sp, &sc->sp);

		put_user_ex(regs->bx, &sc->bx);

		put_user_ex(regs->dx, &sc->dx);

		put_user_ex(regs->cx, &sc->cx);

		put_user_ex(regs->ax, &sc->ax);

		put_user_ex(current->thread.trap_no, &sc->trapno);

		put_user_ex(current->thread.error_code, &sc->err);

		put_user_ex(regs->ip, &sc->ip);

		put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);

		put_user_ex(regs->flags, &sc->flags);

		put_user_ex(regs->sp, &sc->sp_at_signal);

		put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);



		put_user_ex(ptr_to_compat(fpstate), &sc->fpstate);



		/* non-iBCS2 extensions.. */

	err |= __put_user(mask, &sc->oldmask);

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

		put_user_ex(mask, &sc->oldmask);

		put_user_ex(current->thread.cr2, &sc->cr2);

	} put_user_catch(err);



	return err;

}
@@ -437,13 +459,17 @@ int ia32_setup_frame(int sig, struct k_sigaction *ka, 
		else

			restorer = &frame->retcode;

	}

	err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);



	put_user_try {

		put_user_ex(ptr_to_compat(restorer), &frame->pretcode);



		/*

		 * These are actually not used anymore, but left because some

		 * gdb versions depend on them as a marker.

		 */

	err |= __put_user(*((u64 *)&code), (u64 *)frame->retcode);

		put_user_ex(*((u64 *)&code), (u64 *)frame->retcode);

	} put_user_catch(err);



	if (err)

		return -EFAULT;
@@ -496,41 +522,40 @@ int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 
	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))

		return -EFAULT;



	err |= __put_user(sig, &frame->sig);

	err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);

	err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);

	put_user_try {

		put_user_ex(sig, &frame->sig);

		put_user_ex(ptr_to_compat(&frame->info), &frame->pinfo);

		put_user_ex(ptr_to_compat(&frame->uc), &frame->puc);

		err |= copy_siginfo_to_user32(&frame->info, info);

	if (err)

		return -EFAULT;



		/* Create the ucontext.  */

		if (cpu_has_xsave)

		err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags);

			put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);

		else

		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->sp),

			put_user_ex(0, &frame->uc.uc_flags);

		put_user_ex(0, &frame->uc.uc_link);

		put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);

		put_user_ex(sas_ss_flags(regs->sp),

			    &frame->uc.uc_stack.ss_flags);

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

		put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);

		err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,

					     regs, set->sig[0]);

		err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));

	if (err)

		return -EFAULT;



		if (ka->sa.sa_flags & SA_RESTORER)

			restorer = ka->sa.sa_restorer;

		else

			restorer = VDSO32_SYMBOL(current->mm->context.vdso,

						 rt_sigreturn);

	err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);

		put_user_ex(ptr_to_compat(restorer), &frame->pretcode);



		/*

		 * Not actually used anymore, but left because some gdb

		 * versions need it.

		 */

	err |= __put_user(*((u64 *)&code), (u64 *)frame->retcode);

		put_user_ex(*((u64 *)&code), (u64 *)frame->retcode);

	} put_user_catch(err);



	if (err)

		return -EFAULT;

CRA Git | Maintained and supported by SUSTech CRA and CCSE