Subversion Repositories or1k_old

/*
 *  linux/arch/i960/kernel/signal.c
 *
 *  Copyright (C) 1999  Keith Adams	<kma@cse.ogi.edu>
 * 			Oregon Graduate Institute
 *
 *  Based on:
 *
 *  linux/arch/m68k/kernel/signal.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file COPYING in the main directory of this archive
 * for more details.
 */
 
#include <linux/config.h>
 
#include <linux/sched.h>
#include <linux/mm.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 <asm/setup.h>
#include <asm/segment.h>
#include <asm/pgtable.h>
#include <asm/traps.h>
 
 
#define _S(nr) (1<<((nr)-1))
 
#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
 
int do_signal(struct pt_regs *regs);
 
/*
 * atomically swap in the new signal mask, and wait for a signal.
 */
asmlinkage int do_sigsuspend(struct pt_regs* regs)
{
	int err;
	sigset_t* set = (sigset_t*) regs->gregs[0];
	unsigned long mask;
 
	if ((err=verify_area(VERIFY_READ, set, 4)))
		return -EINTR;
 
	mask = current->blocked;
	current->blocked = *set & _BLOCKABLE;
	regs->gregs[0] = -EINTR;
	for (;;) {
		current->state = TASK_INTERRUPTIBLE;
		schedule();
		if (do_signal(regs))
			return -EINTR;
	}
}
 
/*
 * We don't ever need this on i960; the function return path lets setup_frame
 * return straight to the faulting instruction.
 */
asmlinkage int do_sigreturn(unsigned long __unused)
{
	printk("killing %d for trying to sigreturn\n");
	do_exit(SIGSEGV);
	return -1;
}
 
#define STACK_ALIGN 16
static inline unsigned long stack_align(unsigned long sp)
{
	int lobits  = sp & (STACK_ALIGN -1);
 
	if (sp & lobits)
		sp += STACK_ALIGN - lobits;
	return sp;
}
 
/*
 * Note that 'init' is a special process: it doesn't get signals it doesn't
 * want to handle. Thus you cannot kill init even with a SIGKILL even by
 * mistake.
 *
 * Note that we go through the signals twice: once to check the signals
 * that the kernel can handle, and then we build all the user-level signal
 * handling stack-frames in one go after that.
 * 
 * XXX: todo: sigcontext stuff.
 */
 
asmlinkage int do_signal(struct pt_regs *regs)
{
	unsigned long mask = ~current->blocked;
	unsigned long handler_signal = 0;
	unsigned long signr;
	struct sigaction * sa;
 
	while ((signr = current->signal & mask)) {
		signr = ffz(~signr);
		clear_bit(signr, &current->signal);
		sa = current->sig->action + signr;
		signr++;
 
		if ((current->flags & PF_PTRACED) && signr != SIGKILL) {
			current->exit_code = signr;
			current->state = TASK_STOPPED;
			notify_parent(current, signr);
			schedule();
 
			if (!(signr = current->exit_code))
				continue;
			current->exit_code = 0;
			if (signr == SIGSTOP)
				continue;
			if (_S(signr) & current->blocked) {
				current->signal |= _S(signr);
				continue;
			}
			sa = current->sig->action + signr - 1;
		}
 
		if (sa->sa_handler == SIG_IGN) {
			if (signr != SIGCHLD)
				continue;
			/* SIGCHLD is special */
			while (sys_waitpid(-1,0,WNOHANG) > 0)
				;
			continue;
		}
		if (sa->sa_handler == SIG_DFL) {
			if (current->pid == 1)
				continue;
			switch(signr) {
			case SIGCONT: case SIGCHLD: case SIGWINCH:
				      continue;
			case SIGSTOP: case SIGTSTP: case SIGTTIN: case SIGTTOU:
				if (current->flags & PF_PTRACED)
					continue;
				current->state = TASK_STOPPED;
				current->exit_code = signr;
				if (!(current->p_pptr->sig->action[SIGCHLD-1].sa_flags & 
						SA_NOCLDSTOP))
					notify_parent(current, signr);
				schedule();
				continue;
 
			case SIGQUIT: case SIGILL: case SIGTRAP:
			case SIGIOT: case SIGFPE: case SIGSEGV: case SIGBUS:
				if (current->binfmt && current->binfmt->core_dump) {
					if (current->binfmt->core_dump(signr, regs))
						signr |= 0x80;
				}
				/* fall through */
			default:
				current->signal |= _S(signr & 0x7f);
				current->flags |= PF_SIGNALED;
				do_exit(signr);
			}
		}
 
		/*
		 * OK, we're invoking a handler
		 */
#ifdef DEBUG
		printk("user-specified handler for signal: %d\n", signr);
#endif
		handler_signal |= 1 << (signr-1);
		mask &= ~sa->sa_mask;
	}
 
	if (! handler_signal)
		return 0;
 
	/*
	 * We chain user frames for the various handlers together. Since we use
	 * local regs to pass parameters, all RIPs go to the asm routine
	 * signal_head found in entry.S; if we were an MMU-full system, we would
	 * have to copy signal_head out to the user process's stack.
	 */
	{
		extern void signal_head(void);
		struct frame {
			unsigned long pfp;
			unsigned long sp;
			unsigned long rip;
			unsigned long* args[13];
		} *userframe, *newframe;
		unsigned long type;
 
#ifdef DEBUG
		stack_trace();
#endif
		asm("flushreg");
		type = regs->lregs[PT_PFP] & 0x7;
#ifdef DEBUG
		printk("pfp, type: 0x%8x, 0x%8x\n", regs->lregs[PT_PFP], type);
#endif
		userframe = (struct frame*)
			(((unsigned long) regs->lregs[PT_PFP]) & ~0x7);
#ifdef DEBUG
		printk("userframe: 0x%8x\n", userframe);
		stack_trace_from((unsigned long) userframe);
#endif
 
		for (sa=current->sig->action, signr=1, mask=1; 
		     mask; 
		     sa++, signr++, mask<<=1) {
			if (mask > handler_signal)
				break;
			if ((!(mask & handler_signal)) || (!sa->sa_handler))
				continue;
#ifdef DEBUG
			printk("userframe->rip: 0x%8x\n", userframe->rip);
#endif
			newframe = stack_align(userframe->sp);
			newframe->rip = (unsigned long) signal_head;
			newframe->args[0] = (unsigned long) sa->sa_handler;
			newframe->args[1] = signr;
#ifdef DEBUG
			printk("r3,r4: 0x%8x, %d\n", sa->sa_handler, signr);
#endif
			newframe->pfp = (unsigned long) userframe;
			newframe->sp = (unsigned long)(newframe) + 64;
			userframe = newframe;
		}
 
#ifdef DEBUG
		printk("done; look:\n");
		stack_trace();
#endif
		regs->lregs[PT_PFP] = (unsigned long)userframe | type;
		asm("flushreg");
 
		/* 
		 * appropriate syscalls should return EINTR
		 */
		if ((type & 6) == 2 &&
		    (regs->gregs[0] == -ERESTARTNOHAND ||
		     regs->gregs[0] == -ERESTARTSYS ||
		     regs->gregs[0] == -ERESTARTNOINTR))
			regs->gregs[0] = -EINTR;
	}
 
	return 1;
}