/* * BK Id: SCCS/s.signal.c 1.10 11/23/01 16:38:30 paulus *//* *  linux/arch/ppc/kernel/signal.c * *  PowerPC version  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) * *  Derived from "arch/i386/kernel/signal.c" *    Copyright (C) 1991, 1992 Linus Torvalds *    1997-11-28  Modified for POSIX.1b signals by Richard Henderson * *  This program is free software; you can redistribute it and/or *  modify it under the terms of the GNU General Public License *  as published by the Free Software Foundation; either version *  2 of the License, or (at your option) any later version. */#include <linux/sched.h>#include <linux/mm.h>#include <linux/smp.h>#include <linux/smp_lock.h>#include <linux/kernel.h>#include <linux/signal.h>#include <linux/errno.h>#include <linux/wait.h>#include <linux/ptrace.h>#include <linux/unistd.h>#include <linux/stddef.h>#include <linux/elf.h>#include <asm/ucontext.h>#include <asm/uaccess.h>#include <asm/pgtable.h>#define DEBUG_SIG 0#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))#ifndef MIN#define MIN(a,b) (((a) < (b)) ? (a) : (b))#endif#define GP_REGS_SIZE	MIN(sizeof(elf_gregset_t), sizeof(struct pt_regs))/*  * These are the flags in the MSR that the user is allowed to change * by modifying the saved value of the MSR on the stack.  SE and BE * should not be in this list since gdb may want to change these.  I.e, * you should be able to step out of a signal handler to see what * instruction executes next after the signal handler completes. * Alternately, if you stepped into a signal handler, you should be * able to continue 'til the next breakpoint from within the signal * handler, even if the handler returns. */#define MSR_USERCHANGE	(MSR_FE0 | MSR_FE1)int do_signal(sigset_t *oldset, struct pt_regs *regs);int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from){	if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))		return -EFAULT;	if (from->si_code < 0)		return __copy_to_user(to, from, sizeof(siginfo_t));	else {		int err;		/* If you change siginfo_t structure, please be sure		   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);		/* First 32bits of unions are always present.  */		err |= __put_user(from->si_pid, &to->si_pid);		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);		default:			err |= __put_user(from->si_uid, &to->si_uid);			break;		/* case __SI_RT: This is not generated by the kernel as of now.  */		}		return err;	}}/* * Atomically swap in the new signal mask, and wait for a signal. */intsys_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7,	       struct pt_regs *regs){	sigset_t saveset;	mask &= _BLOCKABLE;	spin_lock_irq(&current->sigmask_lock);	saveset = current->blocked;	siginitset(&current->blocked, mask);	recalc_sigpending(current);	spin_unlock_irq(&current->sigmask_lock);	regs->gpr[3] = -EINTR;	while (1) {		current->state = TASK_INTERRUPTIBLE;		schedule();		if (do_signal(&saveset, regs))			/*			 * If a signal handler needs to be called,			 * do_signal() has set R3 to the signal number (the			 * first argument of the signal handler), so don't			 * overwrite that with EINTR !			 * In the other cases, do_signal() doesn't touch 			 * R3, so it's still set to -EINTR (see above).			 */			return regs->gpr[3];	}}intsys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, int p3, int p4, int p6,		  int p7, struct pt_regs *regs){	sigset_t saveset, newset;	/* XXX: Don't preclude handling different sized sigset_t's.  */	if (sigsetsize != sizeof(sigset_t))		return -EINVAL;	if (copy_from_user(&newset, unewset, sizeof(newset)))		return -EFAULT;	sigdelsetmask(&newset, ~_BLOCKABLE);	spin_lock_irq(&current->sigmask_lock);	saveset = current->blocked;	current->blocked = newset;	recalc_sigpending(current);	spin_unlock_irq(&current->sigmask_lock);	regs->gpr[3] = -EINTR;	while (1) {		current->state = TASK_INTERRUPTIBLE;		schedule();		if (do_signal(&saveset, regs))			return regs->gpr[3];	}}intsys_sigaltstack(const stack_t *uss, stack_t *uoss){	struct pt_regs *regs = (struct pt_regs *) &uss;	return do_sigaltstack(uss, uoss, regs->gpr[1]);}int sys_sigaction(int sig, const struct old_sigaction *act,	      struct old_sigaction *oact){	struct k_sigaction new_ka, old_ka;	int ret;	if (act) {		old_sigset_t mask;		if (verify_area(VERIFY_READ, act, sizeof(*act)) ||		    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||		    __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))			return -EFAULT;		__get_user(new_ka.sa.sa_flags, &act->sa_flags);		__get_user(mask, &act->sa_mask);		siginitset(&new_ka.sa.sa_mask, mask);	}	ret = do_sigaction(sig, (act? &new_ka: NULL), (oact? &old_ka: NULL));	if (!ret && oact) {		if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||		    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||		    __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))			return -EFAULT;		__put_user(old_ka.sa.sa_flags, &oact->sa_flags);		__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);	}	return ret;}/* * When we have signals to deliver, we set up on the * user stack, going down from the original stack pointer: *	a sigregs struct *	one or more sigcontext structs with *	a gap of __SIGNAL_FRAMESIZE bytes * * Each of these things must be a multiple of 16 bytes in size. * */struct sigregs {	elf_gregset_t	gp_regs;	double		fp_regs[ELF_NFPREG];	unsigned long	tramp[2];	/* Programs using the rs6000/xcoff abi can save up to 19 gp regs	   and 18 fp regs below sp before decrementing it. */	int		abigap[56];};struct rt_sigframe{	unsigned long	_unused[2];	struct siginfo *pinfo;	void *puc;	struct siginfo info;	struct ucontext uc;};/* *  When we have rt signals to deliver, we set up on the *  user stack, going down from the original stack pointer: *	   a sigregs struct *	   one rt_sigframe struct (siginfo + ucontext) *	   a gap of __SIGNAL_FRAMESIZE bytes * *  Each of these things must be a multiple of 16 bytes in size. * */int sys_rt_sigreturn(struct pt_regs *regs){	struct rt_sigframe *rt_sf;	struct sigcontext_struct sigctx;	struct sigregs *sr;	int ret;	elf_gregset_t saved_regs;  /* an array of ELF_NGREG unsigned longs */	sigset_t set;	stack_t st;	unsigned long prevsp;	rt_sf = (struct rt_sigframe *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);	if (copy_from_user(&sigctx, &rt_sf->uc.uc_mcontext, sizeof(sigctx))	    || copy_from_user(&set, &rt_sf->uc.uc_sigmask, sizeof(set))	    || copy_from_user(&st, &rt_sf->uc.uc_stack, sizeof(st)))		goto badframe;	sigdelsetmask(&set, ~_BLOCKABLE);	spin_lock_irq(&current->sigmask_lock);	current->blocked = set;	recalc_sigpending(current);	spin_unlock_irq(&current->sigmask_lock);	if (regs->msr & MSR_FP)		giveup_fpu(current);	rt_sf++;			/* Look at next rt_sigframe */	if (rt_sf == (struct rt_sigframe *)(sigctx.regs)) {		/* Last stacked signal - restore registers -		 * sigctx is initialized to point to the 		 * preamble frame (where registers are stored) 		 * see handle_signal()		 */		sr = (struct sigregs *) sigctx.regs;		if (copy_from_user(saved_regs, &sr->gp_regs,				   sizeof(sr->gp_regs)))			goto badframe;		saved_regs[PT_MSR] = (regs->msr & ~MSR_USERCHANGE)			| (saved_regs[PT_MSR] & MSR_USERCHANGE);		memcpy(regs, saved_regs, GP_REGS_SIZE);		if (copy_from_user(current->thread.fpr, &sr->fp_regs,				   sizeof(sr->fp_regs)))			goto badframe;		/* This function sets back the stack flags into		   the current task structure.  */		sys_sigaltstack(&st, NULL);		ret = regs->result;	} else {		/* More signals to go */		/* Set up registers for next signal handler */		regs->gpr[1] = (unsigned long)rt_sf - __SIGNAL_FRAMESIZE;		if (copy_from_user(&sigctx, &rt_sf->uc.uc_mcontext, sizeof(sigctx)))			goto badframe;		sr = (struct sigregs *) sigctx.regs;		regs->gpr[3] = ret = sigctx.signal;		/* Get the siginfo   */		get_user(regs->gpr[4], (unsigned long *)&rt_sf->pinfo);		/* Get the ucontext */		get_user(regs->gpr[5], (unsigned long *)&rt_sf->puc);		regs->gpr[6] = (unsigned long) rt_sf;		regs->link = (unsigned long) &sr->tramp;		regs->nip = sigctx.handler;		if (get_user(prevsp, &sr->gp_regs[PT_R1])		    || put_user(prevsp, (unsigned long *) regs->gpr[1]))			goto badframe;		current->thread.fpscr = 0;	}	return ret;badframe:	do_exit(SIGSEGV);}static voidsetup_rt_frame(struct pt_regs *regs, struct sigregs *frame,	       signed long newsp){	struct rt_sigframe *rt_sf = (struct rt_sigframe *) newsp;	/* Set up preamble frame */	if (verify_area(VERIFY_WRITE, frame, sizeof(*frame)))		goto badframe;	if (regs->msr & MSR_FP)		giveup_fpu(current);	if (__copy_to_user(&frame->gp_regs, regs, GP_REGS_SIZE)	    || __copy_to_user(&frame->fp_regs, current->thread.fpr,			      ELF_NFPREG * sizeof(double))	/* Set up to return from user space.	   It calls the sc exception at offset 0x9999 	   for sys_rt_sigreturn().	*/	    || __put_user(0x38006666UL, &frame->tramp[0])	/* li r0,0x6666 */	    || __put_user(0x44000002UL, &frame->tramp[1]))	/* sc */		goto badframe;	flush_icache_range((unsigned long) &frame->tramp[0],			   (unsigned long) &frame->tramp[2]);	current->thread.fpscr = 0;	/* turn off all fp exceptions */	/* Retrieve rt_sigframe from stack and	   set up registers for signal handler	*/	newsp -= __SIGNAL_FRAMESIZE;	if (put_user(regs->gpr[1], (unsigned long *)newsp)	    || get_user(regs->nip, &rt_sf->uc.uc_mcontext.handler)	    || get_user(regs->gpr[3], &rt_sf->uc.uc_mcontext.signal)	    || get_user(regs->gpr[4], (unsigned long *)&rt_sf->pinfo)	    || get_user(regs->gpr[5], (unsigned long *)&rt_sf->puc))