自学教程：C++ synchronize_user_stack函数代码示例

void do_rt_sigreturn(struct pt_regs *regs){	struct rt_signal_frame *sf;	unsigned long tpc, tnpc, tstate;	__siginfo_fpu_t *fpu_save;	sigset_t set;	stack_t st;	int err;	synchronize_user_stack ();	sf = (struct rt_signal_frame *)		(regs->u_regs [UREG_FP] + STACK_BIAS);	/* 1. Make sure we are not getting garbage from the user */	if (((unsigned long) sf) & 3)		goto segv;	err = get_user(tpc, &sf->regs.tpc);	err |= __get_user(tnpc, &sf->regs.tnpc);	if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {		tpc &= 0xffffffff;		tnpc &= 0xffffffff;	}	err |= ((tpc | tnpc) & 3);	/* 2. Restore the state */	err |= __get_user(regs->y, &sf->regs.y);	err |= __get_user(tstate, &sf->regs.tstate);	err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));	/* User can only change condition codes in %tstate. */	regs->tstate &= ~(TSTATE_ICC);	regs->tstate |= (tstate & TSTATE_ICC);	err |= __get_user(fpu_save, &sf->fpu_save);	if (fpu_save)		err |= restore_fpu_state(regs, &sf->fpu_state);	err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));	err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t));		if (err)		goto segv;			regs->tpc = tpc;	regs->tnpc = tnpc;		/* It is more difficult to avoid calling this function than to	   call it and ignore errors.  */	do_sigaltstack(&st, NULL, (unsigned long)sf);	sigdelsetmask(&set, ~_BLOCKABLE);	spin_lock_irq(&current->sigmask_lock);	current->blocked = set;	recalc_sigpending(current);	spin_unlock_irq(&current->sigmask_lock);	return;segv:	send_sig(SIGSEGV, current, 1);}

int restore_rwin_state(__siginfo_rwin_t __user *rp){	struct thread_info *t = current_thread_info();	int i, wsaved, err;	__get_user(wsaved, &rp->wsaved);	if (wsaved > NSWINS)		return -EFAULT;	err = 0;	for (i = 0; i < wsaved; i++) {		err |= copy_from_user(&t->reg_window[i],				      &rp->reg_window[i],				      sizeof(struct reg_window));		err |= __get_user(t->rwbuf_stkptrs[i],				  &rp->rwbuf_stkptrs[i]);	}	if (err)		return err;	set_thread_wsaved(wsaved);	synchronize_user_stack();	if (get_thread_wsaved())		return -EFAULT;	return 0;}

asmlinkage void do_rt_sigreturn(struct pt_regs *regs){	struct rt_signal_frame __user *sf;	unsigned int psr, pc, npc;	__siginfo_fpu_t __user *fpu_save;	__siginfo_rwin_t __user *rwin_save;	sigset_t set;	int err;	synchronize_user_stack();	sf = (struct rt_signal_frame __user *) regs->u_regs[UREG_FP];	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||	    (((unsigned long) sf) & 0x03))		goto segv;	err = __get_user(pc, &sf->regs.pc);	err |= __get_user(npc, &sf->regs.npc);	err |= ((pc | npc) & 0x03);	err |= __get_user(regs->y, &sf->regs.y);	err |= __get_user(psr, &sf->regs.psr);	err |= __copy_from_user(&regs->u_regs[UREG_G1],				&sf->regs.u_regs[UREG_G1], 15 * sizeof(u32));	regs->psr = (regs->psr & ~PSR_ICC) | (psr & PSR_ICC);	/* Prevent syscall restart.  */	pt_regs_clear_syscall(regs);	err |= __get_user(fpu_save, &sf->fpu_save);	if (!err && fpu_save)		err |= restore_fpu_state(regs, fpu_save);	err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));	err |= restore_altstack(&sf->stack);		if (err)		goto segv;			regs->pc = pc;	regs->npc = npc;		err |= __get_user(rwin_save, &sf->rwin_save);	if (!err && rwin_save) {		if (restore_rwin_state(rwin_save))			goto segv;	}	set_current_blocked(&set);	return;segv:	force_sig(SIGSEGV, current);}

static inline intsetup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,	       int signo, sigset_t *oldset, siginfo_t *info){	struct rt_signal_frame __user *sf;	int wsaved, err, sf_size;	void __user *tail;	/* 1. Make sure everything is clean */	synchronize_user_stack();	save_and_clear_fpu();		wsaved = get_thread_wsaved();	sf_size = sizeof(struct rt_signal_frame);	if (current_thread_info()->fpsaved[0] & FPRS_FEF)		sf_size += sizeof(__siginfo_fpu_t);	if (wsaved)		sf_size += sizeof(__siginfo_rwin_t);	sf = (struct rt_signal_frame __user *)		get_sigframe(ka, regs, sf_size);	if (invalid_frame_pointer (sf))		goto sigill;	tail = (sf + 1);	/* 2. Save the current process state */	err = copy_to_user(&sf->regs, regs, sizeof (*regs));	if (current_thread_info()->fpsaved[0] & FPRS_FEF) {		__siginfo_fpu_t __user *fpu_save = tail;		tail += sizeof(__siginfo_fpu_t);		err |= save_fpu_state(regs, fpu_save);		err |= __put_user((u64)fpu_save, &sf->fpu_save);	} else {		err |= __put_user(0, &sf->fpu_save);	}	if (wsaved) {		__siginfo_rwin_t __user *rwin_save = tail;		tail += sizeof(__siginfo_rwin_t);		err |= save_rwin_state(wsaved, rwin_save);		err |= __put_user((u64)rwin_save, &sf->rwin_save);		set_thread_wsaved(0);	} else {		err |= __put_user(0, &sf->rwin_save);	}		/* Setup sigaltstack */	err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);	err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);	err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);	err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));	if (!wsaved) {		err |= copy_in_user((u64 __user *)sf,				    (u64 __user *)(regs->u_regs[UREG_FP] +						   STACK_BIAS),				    sizeof(struct reg_window));	} else {		struct reg_window *rp;		rp = &current_thread_info()->reg_window[wsaved - 1];		err |= copy_to_user(sf, rp, sizeof(struct reg_window));	}	if (info)		err |= copy_siginfo_to_user(&sf->info, info);	else {		err |= __put_user(signo, &sf->info.si_signo);		err |= __put_user(SI_NOINFO, &sf->info.si_code);	}	if (err)		goto sigsegv;		/* 3. signal handler back-trampoline and parameters */	regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;	regs->u_regs[UREG_I0] = signo;	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;	/* The sigcontext is passed in this way because of how it	 * is defined in GLIBC's /usr/include/bits/sigcontext.h	 * for sparc64.  It includes the 128 bytes of siginfo_t.	 */	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;	/* 5. signal handler */	regs->tpc = (unsigned long) ka->sa.sa_handler;	regs->tnpc = (regs->tpc + 4);	if (test_thread_flag(TIF_32BIT)) {		regs->tpc &= 0xffffffff;		regs->tnpc &= 0xffffffff;	}	/* 4. return to kernel instructions */	regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;	return 0;sigill:	do_exit(SIGILL);	return -EINVAL;//.........这里部分代码省略.........

asmlinkage void sparc64_get_context(struct pt_regs *regs){	struct ucontext __user *ucp = (struct ucontext __user *)		regs->u_regs[UREG_I0];	mc_gregset_t __user *grp;	mcontext_t __user *mcp;	unsigned long fp, i7;	unsigned char fenab;	int err;	synchronize_user_stack();	if (get_thread_wsaved() || clear_user(ucp, sizeof(*ucp)))		goto do_sigsegv;#if 1	fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */#else	fenab = (current_thread_info()->fpsaved[0] & FPRS_FEF);#endif			mcp = &ucp->uc_mcontext;	grp = &mcp->mc_gregs;	/* Skip over the trap instruction, first. */	if (test_thread_flag(TIF_32BIT)) {		regs->tpc   = (regs->tnpc & 0xffffffff);		regs->tnpc  = (regs->tnpc + 4) & 0xffffffff;	} else {		regs->tpc   = regs->tnpc;		regs->tnpc += 4;	}	err = 0;	if (_NSIG_WORDS == 1)		err |= __put_user(current->blocked.sig[0],				  (unsigned long __user *)&ucp->uc_sigmask);	else		err |= __copy_to_user(&ucp->uc_sigmask, &current->blocked,				      sizeof(sigset_t));	err |= __put_user(regs->tstate, &((*grp)[MC_TSTATE]));	err |= __put_user(regs->tpc, &((*grp)[MC_PC]));	err |= __put_user(regs->tnpc, &((*grp)[MC_NPC]));	err |= __put_user(regs->y, &((*grp)[MC_Y]));	err |= __put_user(regs->u_regs[UREG_G1], &((*grp)[MC_G1]));	err |= __put_user(regs->u_regs[UREG_G2], &((*grp)[MC_G2]));	err |= __put_user(regs->u_regs[UREG_G3], &((*grp)[MC_G3]));	err |= __put_user(regs->u_regs[UREG_G4], &((*grp)[MC_G4]));	err |= __put_user(regs->u_regs[UREG_G5], &((*grp)[MC_G5]));	err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G6]));	err |= __put_user(regs->u_regs[UREG_G7], &((*grp)[MC_G7]));	err |= __put_user(regs->u_regs[UREG_I0], &((*grp)[MC_O0]));	err |= __put_user(regs->u_regs[UREG_I1], &((*grp)[MC_O1]));	err |= __put_user(regs->u_regs[UREG_I2], &((*grp)[MC_O2]));	err |= __put_user(regs->u_regs[UREG_I3], &((*grp)[MC_O3]));	err |= __put_user(regs->u_regs[UREG_I4], &((*grp)[MC_O4]));	err |= __put_user(regs->u_regs[UREG_I5], &((*grp)[MC_O5]));	err |= __put_user(regs->u_regs[UREG_I6], &((*grp)[MC_O6]));	err |= __put_user(regs->u_regs[UREG_I7], &((*grp)[MC_O7]));	err |= __get_user(fp,		 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));	err |= __get_user(i7,		 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));	err |= __put_user(fp, &(mcp->mc_fp));	err |= __put_user(i7, &(mcp->mc_i7));	err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab));	if (fenab) {		unsigned long *fpregs = current_thread_info()->fpregs;		unsigned long fprs;				fprs = current_thread_info()->fpsaved[0];		if (fprs & FPRS_DL)			err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs,					    (sizeof(unsigned int) * 32));		if (fprs & FPRS_DU)			err |= copy_to_user(                          ((unsigned long __user *)&(mcp->mc_fpregs.mcfpu_fregs))+16, fpregs+16,			  (sizeof(unsigned int) * 32));		err |= __put_user(current_thread_info()->xfsr[0], &(mcp->mc_fpregs.mcfpu_fsr));		err |= __put_user(current_thread_info()->gsr[0], &(mcp->mc_fpregs.mcfpu_gsr));		err |= __put_user(fprs, &(mcp->mc_fpregs.mcfpu_fprs));	}	if (err)		goto do_sigsegv;	return;do_sigsegv:	force_sig(SIGSEGV, current);}

asmlinkage void do_sigreturn(struct pt_regs *regs){	struct signal_frame __user *sf;	unsigned long up_psr, pc, npc;	sigset_t set;	__siginfo_fpu_t __user *fpu_save;	__siginfo_rwin_t __user *rwin_save;	int err;	/* Always make any pending restarted system calls return -EINTR */	current_thread_info()->restart_block.fn = do_no_restart_syscall;	synchronize_user_stack();	sf = (struct signal_frame __user *) regs->u_regs[UREG_FP];	/* 1. Make sure we are not getting garbage from the user */	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))		goto segv_and_exit;	if (((unsigned long) sf) & 3)		goto segv_and_exit;	err = __get_user(pc,  &sf->info.si_regs.pc);	err |= __get_user(npc, &sf->info.si_regs.npc);	if ((pc | npc) & 3)		goto segv_and_exit;	/* 2. Restore the state */	up_psr = regs->psr;	err |= __copy_from_user(regs, &sf->info.si_regs, sizeof(struct pt_regs));	/* User can only change condition codes and FPU enabling in %psr. */	regs->psr = (up_psr & ~(PSR_ICC | PSR_EF))		  | (regs->psr & (PSR_ICC | PSR_EF));	/* Prevent syscall restart.  */	pt_regs_clear_syscall(regs);	err |= __get_user(fpu_save, &sf->fpu_save);	if (fpu_save)		err |= restore_fpu_state(regs, fpu_save);	err |= __get_user(rwin_save, &sf->rwin_save);	if (rwin_save)		err |= restore_rwin_state(rwin_save);	/* This is pretty much atomic, no amount locking would prevent	 * the races which exist anyways.	 */	err |= __get_user(set.sig[0], &sf->info.si_mask);	err |= __copy_from_user(&set.sig[1], &sf->extramask,			        (_NSIG_WORDS-1) * sizeof(unsigned int));			   	if (err)		goto segv_and_exit;	sigdelsetmask(&set, ~_BLOCKABLE);	spin_lock_irq(&current->sighand->siglock);	current->blocked = set;	recalc_sigpending();	spin_unlock_irq(&current->sighand->siglock);	return;segv_and_exit:	force_sig(SIGSEGV, current);}

static int setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,			  int signo, sigset_t *oldset, siginfo_t *info){	struct rt_signal_frame __user *sf;	int sigframe_size, wsaved;	void __user *tail;	unsigned int psr;	int err;	synchronize_user_stack();	wsaved = current_thread_info()->w_saved;	sigframe_size = sizeof(*sf);	if (used_math())		sigframe_size += sizeof(__siginfo_fpu_t);	if (wsaved)		sigframe_size += sizeof(__siginfo_rwin_t);	sf = (struct rt_signal_frame __user *)		get_sigframe(&ka->sa, regs, sigframe_size);	if (invalid_frame_pointer(sf, sigframe_size))		goto sigill;	tail = sf + 1;	err  = __put_user(regs->pc, &sf->regs.pc);	err |= __put_user(regs->npc, &sf->regs.npc);	err |= __put_user(regs->y, &sf->regs.y);	psr = regs->psr;	if (used_math())		psr |= PSR_EF;	err |= __put_user(psr, &sf->regs.psr);	err |= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs));	err |= __put_user(0, &sf->extra_size);	if (psr & PSR_EF) {		__siginfo_fpu_t *fp = tail;		tail += sizeof(*fp);		err |= save_fpu_state(regs, fp);		err |= __put_user(fp, &sf->fpu_save);	} else {		err |= __put_user(0, &sf->fpu_save);	}	if (wsaved) {		__siginfo_rwin_t *rwp = tail;		tail += sizeof(*rwp);		err |= save_rwin_state(wsaved, rwp);		err |= __put_user(rwp, &sf->rwin_save);	} else {		err |= __put_user(0, &sf->rwin_save);	}	err |= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t));		/* Setup sigaltstack */	err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);	err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);	err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);		if (!wsaved) {		err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],				      sizeof(struct reg_window32));	} else {		struct reg_window32 *rp;		rp = &current_thread_info()->reg_window[wsaved - 1];		err |= __copy_to_user(sf, rp, sizeof(struct reg_window32));	}	err |= copy_siginfo_to_user(&sf->info, info);	if (err)		goto sigsegv;	regs->u_regs[UREG_FP] = (unsigned long) sf;	regs->u_regs[UREG_I0] = signo;	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;	regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;	regs->pc = (unsigned long) ka->sa.sa_handler;	regs->npc = (regs->pc + 4);	if (ka->ka_restorer)		regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;	else {		regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);		/* mov __NR_sigreturn, %g1 */		err |= __put_user(0x821020d8, &sf->insns[0]);		/* t 0x10 */		err |= __put_user(0x91d02010, &sf->insns[1]);		if (err)			goto sigsegv;		/* Flush instruction space. */		flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));	}	return 0;sigill:	do_exit(SIGILL);	return -EINVAL;//.........这里部分代码省略.........

static int setup_frame(struct k_sigaction *ka, struct pt_regs *regs,		       int signo, sigset_t *oldset){	struct signal_frame __user *sf;	int sigframe_size, err, wsaved;	void __user *tail;	/* 1. Make sure everything is clean */	synchronize_user_stack();	wsaved = current_thread_info()->w_saved;	sigframe_size = sizeof(*sf);	if (used_math())		sigframe_size += sizeof(__siginfo_fpu_t);	if (wsaved)		sigframe_size += sizeof(__siginfo_rwin_t);	sf = (struct signal_frame __user *)		get_sigframe(&ka->sa, regs, sigframe_size);	if (invalid_frame_pointer(sf, sigframe_size))		goto sigill_and_return;	tail = sf + 1;	/* 2. Save the current process state */	err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs));		err |= __put_user(0, &sf->extra_size);	if (used_math()) {		__siginfo_fpu_t __user *fp = tail;		tail += sizeof(*fp);		err |= save_fpu_state(regs, fp);		err |= __put_user(fp, &sf->fpu_save);	} else {		err |= __put_user(0, &sf->fpu_save);	}	if (wsaved) {		__siginfo_rwin_t __user *rwp = tail;		tail += sizeof(*rwp);		err |= save_rwin_state(wsaved, rwp);		err |= __put_user(rwp, &sf->rwin_save);	} else {		err |= __put_user(0, &sf->rwin_save);	}	err |= __put_user(oldset->sig[0], &sf->info.si_mask);	err |= __copy_to_user(sf->extramask, &oldset->sig[1],			      (_NSIG_WORDS - 1) * sizeof(unsigned int));	if (!wsaved) {		err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],				      sizeof(struct reg_window32));	} else {		struct reg_window32 *rp;		rp = &current_thread_info()->reg_window[wsaved - 1];		err |= __copy_to_user(sf, rp, sizeof(struct reg_window32));	}	if (err)		goto sigsegv;		/* 3. signal handler back-trampoline and parameters */	regs->u_regs[UREG_FP] = (unsigned long) sf;	regs->u_regs[UREG_I0] = signo;	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;	/* 4. signal handler */	regs->pc = (unsigned long) ka->sa.sa_handler;	regs->npc = (regs->pc + 4);	/* 5. return to kernel instructions */	if (ka->ka_restorer)		regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;	else {		regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);		/* mov __NR_sigreturn, %g1 */		err |= __put_user(0x821020d8, &sf->insns[0]);		/* t 0x10 */		err |= __put_user(0x91d02010, &sf->insns[1]);		if (err)			goto sigsegv;		/* Flush instruction space. */		flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));	}	return 0;sigill_and_return:	do_exit(SIGILL);	return -EINVAL;sigsegv:	force_sigsegv(signo, current);	return -EFAULT;}

asmlinkage void do_rt_sigreturn(struct pt_regs *regs){	struct rt_signal_frame __user *sf;	unsigned int psr, pc, npc;	__siginfo_fpu_t __user *fpu_save;	__siginfo_rwin_t __user *rwin_save;	mm_segment_t old_fs;	sigset_t set;	stack_t st;	int err;	synchronize_user_stack();	sf = (struct rt_signal_frame __user *) regs->u_regs[UREG_FP];	if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||	    (((unsigned long) sf) & 0x03))		goto segv;	err = __get_user(pc, &sf->regs.pc);	err |= __get_user(npc, &sf->regs.npc);	err |= ((pc | npc) & 0x03);	err |= __get_user(regs->y, &sf->regs.y);	err |= __get_user(psr, &sf->regs.psr);	err |= __copy_from_user(&regs->u_regs[UREG_G1],				&sf->regs.u_regs[UREG_G1], 15 * sizeof(u32));	regs->psr = (regs->psr & ~PSR_ICC) | (psr & PSR_ICC);	/* Prevent syscall restart.  */	pt_regs_clear_syscall(regs);	err |= __get_user(fpu_save, &sf->fpu_save);	if (!err && fpu_save)		err |= restore_fpu_state(regs, fpu_save);	err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));		err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t));		if (err)		goto segv;			regs->pc = pc;	regs->npc = npc;		/* It is more difficult to avoid calling this function than to	 * call it and ignore errors.	 */	old_fs = get_fs();	set_fs(KERNEL_DS);	do_sigaltstack((const stack_t __user *) &st, NULL, (unsigned long)sf);	set_fs(old_fs);	err |= __get_user(rwin_save, &sf->rwin_save);	if (!err && rwin_save) {		if (restore_rwin_state(rwin_save))			goto segv;	}	sigdelsetmask(&set, ~_BLOCKABLE);	spin_lock_irq(&current->sighand->siglock);	current->blocked = set;	recalc_sigpending();	spin_unlock_irq(&current->sighand->siglock);	return;segv:	force_sig(SIGSEGV, current);}

static inline voidsetup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,	       int signo, sigset_t *oldset, siginfo_t *info){	struct rt_signal_frame *sf;	int sigframe_size, err;	/* 1. Make sure everything is clean */	synchronize_user_stack();	save_and_clear_fpu();		sigframe_size = RT_ALIGNEDSZ;	if (!(current->thread.fpsaved[0] & FPRS_FEF))		sigframe_size -= sizeof(__siginfo_fpu_t);	sf = (struct rt_signal_frame *)get_sigframe(ka, regs, sigframe_size);		if (invalid_frame_pointer (sf, sigframe_size))		goto sigill;	if (current->thread.w_saved != 0) {#ifdef DEBUG_SIGNALS		printk ("%s[%d]: Invalid user stack frame for "			"signal delivery./n", current->comm, current->pid);#endif		goto sigill;	}	/* 2. Save the current process state */	err = copy_to_user(&sf->regs, regs, sizeof (*regs));	if (current->thread.fpsaved[0] & FPRS_FEF) {		err |= save_fpu_state(regs, &sf->fpu_state);		err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);	} else {		err |= __put_user(0, &sf->fpu_save);	}		/* Setup sigaltstack */	err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);	err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);	err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);	err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));	err |= copy_in_user((u64 *)sf,			    (u64 *)(regs->u_regs[UREG_FP]+STACK_BIAS),			    sizeof(struct reg_window));	if (info)		err |= copy_siginfo_to_user(&sf->info, info);	else {		err |= __put_user(signo, &sf->info.si_signo);		err |= __put_user(SI_NOINFO, &sf->info.si_code);	}	if (err)		goto sigsegv;		/* 3. signal handler back-trampoline and parameters */	regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;	regs->u_regs[UREG_I0] = signo;	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;	/* The sigcontext is passed in this way because of how it	 * is defined in GLIBC's /usr/include/bits/sigcontext.h	 * for sparc64.  It includes the 128 bytes of siginfo_t.	 */	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;	/* 5. signal handler */	regs->tpc = (unsigned long) ka->sa.sa_handler;	regs->tnpc = (regs->tpc + 4);	if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {		regs->tpc &= 0xffffffff;		regs->tnpc &= 0xffffffff;	}	/* 4. return to kernel instructions */	regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;	return;sigill:	do_exit(SIGILL);sigsegv:	do_exit(SIGSEGV);}

static void setup_frame(struct k_sigaction *ka, struct pt_regs *regs,            int signo, sigset_t *oldset){    struct signal_frame __user *sf;    int sigframe_size, err;    /* 1. Make sure everything is clean */    synchronize_user_stack();    sigframe_size = SF_ALIGNEDSZ;    if (!used_math())        sigframe_size -= sizeof(__siginfo_fpu_t);    sf = (struct signal_frame __user *)        get_sigframe(&ka->sa, regs, sigframe_size);    if (invalid_frame_pointer(sf, sigframe_size))        goto sigill_and_return;    if (current_thread_info()->w_saved != 0)        goto sigill_and_return;    /* 2. Save the current process state */    err = __copy_to_user(&sf->info.si_regs, regs, sizeof(struct pt_regs));        err |= __put_user(0, &sf->extra_size);    if (used_math()) {        err |= save_fpu_state(regs, &sf->fpu_state);        err |= __put_user(&sf->fpu_state, &sf->fpu_save);    } else {        err |= __put_user(0, &sf->fpu_save);    }    err |= __put_user(oldset->sig[0], &sf->info.si_mask);    err |= __copy_to_user(sf->extramask, &oldset->sig[1],                  (_NSIG_WORDS - 1) * sizeof(unsigned int));    err |= __copy_to_user(sf, (char *) regs->u_regs[UREG_FP],                  sizeof(struct reg_window));    if (err)        goto sigsegv;        /* 3. signal handler back-trampoline and parameters */    regs->u_regs[UREG_FP] = (unsigned long) sf;    regs->u_regs[UREG_I0] = signo;    regs->u_regs[UREG_I1] = (unsigned long) &sf->info;    regs->u_regs[UREG_I2] = (unsigned long) &sf->info;    /* 4. signal handler */    regs->pc = (unsigned long) ka->sa.sa_handler;    regs->npc = (regs->pc + 4);    /* 5. return to kernel instructions */    if (ka->ka_restorer)        regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;    else {        regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);        /* mov __NR_sigreturn, %g1 */        err |= __put_user(0x821020d8, &sf->insns[0]);        /* t 0x10 */        err |= __put_user(0x91d02010, &sf->insns[1]);        if (err)            goto sigsegv;        /* Flush instruction space. */        flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));    }    return;sigill_and_return:    do_exit(SIGILL);sigsegv:    force_sigsegv(signo, current);}

/* {set, get}context() needed for 64-bit SparcLinux userland. */asmlinkage void sparc64_set_context(struct pt_regs *regs){	struct ucontext __user *ucp = (struct ucontext __user *)		regs->u_regs[UREG_I0];	enum ctx_state prev_state = exception_enter();	mc_gregset_t __user *grp;	unsigned long pc, npc, tstate;	unsigned long fp, i7;	unsigned char fenab;	int err;	synchronize_user_stack();	if (get_thread_wsaved()					||	    (((unsigned long)ucp) & (sizeof(unsigned long)-1))	||	    (!__access_ok(ucp, sizeof(*ucp))))		goto do_sigsegv;	grp  = &ucp->uc_mcontext.mc_gregs;	err  = __get_user(pc, &((*grp)[MC_PC]));	err |= __get_user(npc, &((*grp)[MC_NPC]));	if (err || ((pc | npc) & 3))		goto do_sigsegv;	if (regs->u_regs[UREG_I1]) {		sigset_t set;		if (_NSIG_WORDS == 1) {			if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0]))				goto do_sigsegv;		} else {			if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t)))				goto do_sigsegv;		}		set_current_blocked(&set);	}	if (test_thread_flag(TIF_32BIT)) {		pc &= 0xffffffff;		npc &= 0xffffffff;	}	regs->tpc = pc;	regs->tnpc = npc;	err |= __get_user(regs->y, &((*grp)[MC_Y]));	err |= __get_user(tstate, &((*grp)[MC_TSTATE]));	regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);	regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));	err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1]));	err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2]));	err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3]));	err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4]));	err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5]));	err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6]));	/* Skip %g7 as that's the thread register in userspace.  */	err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0]));	err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1]));	err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2]));	err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3]));	err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4]));	err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5]));	err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6]));	err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7]));	err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));	err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));	err |= __put_user(fp,	      (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));	err |= __put_user(i7,	      (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));	err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));	if (fenab) {		unsigned long *fpregs = current_thread_info()->fpregs;		unsigned long fprs;				fprs_write(0);		err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));		if (fprs & FPRS_DL)			err |= copy_from_user(fpregs,					      &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs),					      (sizeof(unsigned int) * 32));		if (fprs & FPRS_DU)			err |= copy_from_user(fpregs+16,			 ((unsigned long __user *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16,			 (sizeof(unsigned int) * 32));		err |= __get_user(current_thread_info()->xfsr[0],				  &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));		err |= __get_user(current_thread_info()->gsr[0],				  &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));		regs->tstate &= ~TSTATE_PEF;	}	if (err)		goto do_sigsegv;out:	exception_exit(prev_state);	return;do_sigsegv:	force_sig(SIGSEGV, current);	goto out;}

void do_rt_sigreturn(struct pt_regs *regs){	unsigned long tpc, tnpc, tstate, ufp;	struct rt_signal_frame __user *sf;	__siginfo_fpu_t __user *fpu_save;	__siginfo_rwin_t __user *rwin_save;	sigset_t set;	int err;	/* Always make any pending restarted system calls return -EINTR */	current->restart_block.fn = do_no_restart_syscall;	synchronize_user_stack ();	sf = (struct rt_signal_frame __user *)		(regs->u_regs [UREG_FP] + STACK_BIAS);	/* 1. Make sure we are not getting garbage from the user */	if (invalid_frame_pointer(sf))		goto segv;	if (get_user(ufp, &sf->regs.u_regs[UREG_FP]))		goto segv;	if ((ufp + STACK_BIAS) & 0x7)		goto segv;	err = __get_user(tpc, &sf->regs.tpc);	err |= __get_user(tnpc, &sf->regs.tnpc);	if (test_thread_flag(TIF_32BIT)) {		tpc &= 0xffffffff;		tnpc &= 0xffffffff;	}	err |= ((tpc | tnpc) & 3);	/* 2. Restore the state */	err |= __get_user(regs->y, &sf->regs.y);	err |= __get_user(tstate, &sf->regs.tstate);	err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));	/* User can only change condition codes and %asi in %tstate. */	regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);	regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));	err |= __get_user(fpu_save, &sf->fpu_save);	if (!err && fpu_save)		err |= restore_fpu_state(regs, fpu_save);	err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));	err |= restore_altstack(&sf->stack);	if (err)		goto segv;	err |= __get_user(rwin_save, &sf->rwin_save);	if (!err && rwin_save) {		if (restore_rwin_state(rwin_save))			goto segv;	}	regs->tpc = tpc;	regs->tnpc = tnpc;	/* Prevent syscall restart.  */	pt_regs_clear_syscall(regs);	set_current_blocked(&set);	return;segv:	force_sig(SIGSEGV, current);}

static inline intsetup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,	       int signo, sigset_t *oldset, siginfo_t *info){	struct rt_signal_frame __user *sf;	int wsaved, err, sf_size;	void __user *tail;		synchronize_user_stack();	save_and_clear_fpu();		wsaved = get_thread_wsaved();	sf_size = sizeof(struct rt_signal_frame);	if (current_thread_info()->fpsaved[0] & FPRS_FEF)		sf_size += sizeof(__siginfo_fpu_t);	if (wsaved)		sf_size += sizeof(__siginfo_rwin_t);	sf = (struct rt_signal_frame __user *)		get_sigframe(ka, regs, sf_size);	if (invalid_frame_pointer (sf))		goto sigill;	tail = (sf + 1);		err = copy_to_user(&sf->regs, regs, sizeof (*regs));	if (current_thread_info()->fpsaved[0] & FPRS_FEF) {		__siginfo_fpu_t __user *fpu_save = tail;		tail += sizeof(__siginfo_fpu_t);		err |= save_fpu_state(regs, fpu_save);		err |= __put_user((u64)fpu_save, &sf->fpu_save);	} else {		err |= __put_user(0, &sf->fpu_save);	}	if (wsaved) {		__siginfo_rwin_t __user *rwin_save = tail;		tail += sizeof(__siginfo_rwin_t);		err |= save_rwin_state(wsaved, rwin_save);		err |= __put_user((u64)rwin_save, &sf->rwin_save);		set_thread_wsaved(0);	} else {		err |= __put_user(0, &sf->rwin_save);	}			err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);	err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);	err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);	err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));	if (!wsaved) {		err |= copy_in_user((u64 __user *)sf,				    (u64 __user *)(regs->u_regs[UREG_FP] +						   STACK_BIAS),				    sizeof(struct reg_window));	} else {		struct reg_window *rp;		rp = &current_thread_info()->reg_window[wsaved - 1];		err |= copy_to_user(sf, rp, sizeof(struct reg_window));	}	if (info)		err |= copy_siginfo_to_user(&sf->info, info);	else {		err |= __put_user(signo, &sf->info.si_signo);		err |= __put_user(SI_NOINFO, &sf->info.si_code);	}	if (err)		goto sigsegv;			regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;	regs->u_regs[UREG_I0] = signo;	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;		regs->tpc = (unsigned long) ka->sa.sa_handler;	regs->tnpc = (regs->tpc + 4);	if (test_thread_flag(TIF_32BIT)) {		regs->tpc &= 0xffffffff;		regs->tnpc &= 0xffffffff;	}		regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;	return 0;sigill:	do_exit(SIGILL);	return -EINVAL;sigsegv:	force_sigsegv(signo, current);	return -EFAULT;//.........这里部分代码省略.........

void do_rt_sigreturn(struct pt_regs *regs){	struct rt_signal_frame __user *sf;	unsigned long tpc, tnpc, tstate;	__siginfo_fpu_t __user *fpu_save;	__siginfo_rwin_t __user *rwin_save;	sigset_t set;	int err;		current_thread_info()->restart_block.fn = do_no_restart_syscall;	synchronize_user_stack ();	sf = (struct rt_signal_frame __user *)		(regs->u_regs [UREG_FP] + STACK_BIAS);		if (((unsigned long) sf) & 3)		goto segv;	err = get_user(tpc, &sf->regs.tpc);	err |= __get_user(tnpc, &sf->regs.tnpc);	if (test_thread_flag(TIF_32BIT)) {		tpc &= 0xffffffff;		tnpc &= 0xffffffff;	}	err |= ((tpc | tnpc) & 3);		err |= __get_user(regs->y, &sf->regs.y);	err |= __get_user(tstate, &sf->regs.tstate);	err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));		regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);	regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));	err |= __get_user(fpu_save, &sf->fpu_save);	if (!err && fpu_save)		err |= restore_fpu_state(regs, fpu_save);	err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));	err |= do_sigaltstack(&sf->stack, NULL, (unsigned long)sf);	if (err)		goto segv;	err |= __get_user(rwin_save, &sf->rwin_save);	if (!err && rwin_save) {		if (restore_rwin_state(rwin_save))			goto segv;	}	regs->tpc = tpc;	regs->tnpc = tnpc;		pt_regs_clear_syscall(regs);	sigdelsetmask(&set, ~_BLOCKABLE);	set_current_blocked(&set);	return;segv:	force_sig(SIGSEGV, current);}