/*
 *  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 README.legal in the main directory of this archive
 * for more details.
 */

/*
 * 680x0 support by Hamish Macdonald
 */

#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/segment.h>
#include <asm/pgtable.h>
#include <asm/traps.h>
#include <asm/bootinfo.h>

#define offsetof(type, member)  ((size_t)(&((type *)0)->member))

#define _S(nr) (1<<((nr)-1))

#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))

asmlinkage int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options);

/*
 * atomically swap in the new signal mask, and wait for a signal.
 */
asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, unsigned long set)
{
	unsigned long mask;
	struct pt_regs * regs = (struct pt_regs *) &restart;

	mask = current->blocked;
	current->blocked = set & _BLOCKABLE;
	regs->d0 = -EINTR;
	while (1) {
		current->state = TASK_INTERRUPTIBLE;
		schedule();
		if (do_signal(mask,regs))
			return -EINTR;
	}
}

static unsigned char fpu_version = 0;	/* version number of fpu, set by setup_frame */

/*
 * This sets regs->usp even though we don't actually use sigstacks yet..
 */
asmlinkage int sys_sigreturn(unsigned long __unused)
{
	struct sigcontext_struct context;
	struct frame * regs;
	int fsize = 0;
	int formatvec = 0;
	unsigned long fp;

	/* get stack frame pointer */
	regs = (struct frame *) &__unused;

	/* get previous context (including pointer to possible extra junk) */
        if (verify_area(VERIFY_READ, (void *)regs->usp, sizeof(context)))
                goto badframe;
	memcpy_fromfs(&context,(void *) regs->usp, sizeof(context));
	fp = regs->usp + sizeof (context);

	/* restore signal mask */
	current->blocked = context.sc_mask & _BLOCKABLE;

	/* restore passed registers */
	regs->d0 = context.sc_d0;
	regs->regs[0] = context.sc_d1;
	regs->regs[7] = context.sc_a0;
	regs->regs[8] = context.sc_a1;
	regs->sr = (regs->sr & 0xff00) | (context.sc_sr & 0xff);
	regs->pc = context.sc_pc;
	regs->usp = context.sc_usp;
	formatvec = context.sc_formatvec;
	regs->format = formatvec >> 12;
	regs->vector = formatvec & 0xfff;
	if (context.sc_fpstate[0])
	  {
	    /* Verify the frame format.  */
	    if (context.sc_fpstate[0] != fpu_version)
	      goto badframe;

	    if (boot_info.cputype & FPU_68881)
	      {
		if (context.sc_fpstate[1] != 0x18
		    && context.sc_fpstate[1] != 0xb4)
		  goto badframe;
	      }
	    else if (boot_info.cputype & FPU_68882)
	      {
		if (context.sc_fpstate[1] != 0x38
		    && context.sc_fpstate[1] != 0xd4)
		  goto badframe;
	      }
	    else if (boot_info.cputype & FPU_68040)
	      {
		if (!((context.sc_fpstate[1] == 0x00)|| \
                      (context.sc_fpstate[1] == 0x28)|| \
                      (context.sc_fpstate[1] == 0x60))){
#if 0
		  printk("Playing like a 68040 and fpstate[1] != 0\n");
		  printk("fpstate[0] = %x, fpstate[1] = %x\n", \
			 context.sc_fpstate[0], context.sc_fpstate[1]);
#endif
		  goto badframe;
		}
	      }
	    else if (boot_info.cputype & FPU_68060)
	      {
		if (!((context.sc_fpstate[1] == 0x00)|| \
                      (context.sc_fpstate[1] == 0x60)|| \
                      (context.sc_fpstate[1] == 0xe0))){
		  goto badframe;
		}
	      }

	    __asm__ volatile ("fmovemx %0,%/fp0-%/fp1\n\t"
			      "fmoveml %1,%/fpcr/%/fpsr/%/fpiar"
			      : /* no outputs */
			      : "m" (*context.sc_fpregs),
				"m" (*context.sc_fpcntl));
	  }
	__asm__ volatile ("frestore %0" : : "m" (*context.sc_fpstate));

	switch (regs->format) {
	    case 0x0:
		fsize = 0;
		break;
	    case 0x2:
		fsize = sizeof(regs->un.fmt2);
		break;
	    case 0x3:
		fsize = sizeof(regs->un.fmt3);
		break;
	    case 0x4:
		fsize = sizeof(regs->un.fmt4);
		break;
	    case 0x7:
		fsize = sizeof(regs->un.fmt7);
		break;
	    case 0x9:
		fsize = sizeof (regs->un.fmt9);
		break;
	    case 0xA:
		fsize = sizeof (regs->un.fmta);
		break;
	    case 0xB:
		fsize = sizeof (regs->un.fmtb);
		break;
	    default:
		/*
		 * user process trying to return with weird frame format
		 */
		goto badframe;
	}

	/* OK.	Make room on the supervisor stack for the extra junk,
	 * if necessary.
	 */

	if (fsize) {
                if (verify_area(VERIFY_READ, (void *)fp, fsize))
                        goto badframe;
		__asm__ __volatile__
			("movel %0,%/a0\n\t"
			 "subl %2,%/a0\n\t"     /* make room on stack */
			 "movel %/a0,%/sp\n\t"    /* set stack pointer */
			 "1: movew %0@+,%/a0@+\n\t"
			 "   dbra %3,1b\n\t"
			 "movel %/sp,%/a0\n\t"
			 "addl  %4,%/a0\n\t"    /* add offset of fmt stuff */
			 "lsrl  #1,%2\n\t"
			 "subql #1,%2\n\t"
			 "2: movesw %5@+,%/d0\n\t"
			 "   movew %/d0,%/a0@+\n\t"
			 "   dbra %2,2b\n\t"
			 "bral " SYMBOL_NAME_STR(ret_from_exception)
			 : "=a" (regs)
			 : "0" (regs), "d" (fsize),
			   "d" (offsetof(struct frame,un)/2-1),
			   "g" (offsetof(struct frame,un)), "a" (fp)
			 : "a0", "a1", "d0");
                goto badframe;
		/* NOTREACHED */
	}

	return regs->d0;
badframe:
        do_exit(SIGSEGV);
}

/*
 * Set up a signal frame...
 *
 * This routine is somewhat complicated by the fact that if the
 * kernel may be entered by an exception other than a system call;
 * e.g. a bus error or other "bad" exception.  If this is the case,
 * then *all* the context on the kernel stack frame must be saved.
 *
 * For a large number of exceptions, the stack frame format is the same
 * as that which will be created when the process traps back to the kernel
 * when finished executing the signal handler.	In this case, nothing
 * must be done.  This is exception frame format "0".  For exception frame
 * formats "2", "9", "A" and "B", the extra information on the frame must
 * be saved.  This information is saved on the user stack and restored
 * when the signal handler is returned.
 *
 * The format of the user stack when executing the signal handler is:
 *
 *     usp ->  RETADDR (points to code below)
 *	       signum  (parm #1)
 *	       sigcode (parm #2 ; vector number)
 *	       scp     (parm #3 ; sigcontext pointer, pointer to #1 below)
 *	       code1   (addaw #20,sp) ; pop parms and code off stack
 *	       code2   (moveq #119,d0; trap #0) ; sigreturn syscall
 *     #1|     oldmask
 *	 |     old usp
 *	 |     d0      (first saved reg)
 *	 |     d1
 *	 |     a0
 *	 |     a1
 *	 |     sr      (saved status register)
 *	 |     pc      (old pc; one to return to)
 *	 |     forvec  (format and vector word of old supervisor stack frame)
 *	 |     floating point context
 *
 * These are optionally followed by some extra stuff, depending on the
 * stack frame interrupted. This is 1 longword for format "2", 3
 * longwords for format "9", 6 longwords for format "A", and 21
 * longwords for format "B".
 */

#define UFRAME_SIZE(fs) (sizeof(struct sigcontext_struct)/4 + 6 + fs/4)

static void setup_frame (struct sigaction * sa, unsigned long **fp, unsigned long pc,
			 struct frame *regs, int signr, unsigned long oldmask)
{
	struct sigcontext_struct context;
	unsigned long *frame, *tframe;

	switch (regs->format) {
	    case 0x0:
		frame = *fp - UFRAME_SIZE(0);
		if (verify_area(VERIFY_WRITE,frame,UFRAME_SIZE(0)*4))
                        do_exit(SIGSEGV);
		break;

#define SAVE_FRAME(fmtx) \
		frame = *fp - UFRAME_SIZE(sizeof(regs->un.fmtx)); \
		if (verify_area(VERIFY_WRITE,frame,UFRAME_SIZE(sizeof(regs->un.fmtx))*4)) \
                        do_exit(SIGSEGV); \
		memcpy_tofs (frame+UFRAME_SIZE(0), &regs->un.fmtx, \
			     sizeof(regs->un.fmtx)); \
		regs->stkadj = sizeof(regs->un.fmtx)

	    case 0x2:
		SAVE_FRAME (fmt2);
		break;
	    case 0x3:
		SAVE_FRAME (fmt3);
		break;
	    case 0x4:
		SAVE_FRAME (fmt4);
		break;
	    case 0x7:
		SAVE_FRAME (fmt7);
		break;
	    case 0x9:
		SAVE_FRAME (fmt9);
		break;
	    case 0xA:
		SAVE_FRAME (fmta);
		break;
	    case 0xB:
		SAVE_FRAME (fmtb);
		break;
	    default:
		printk ("setup_frame: Unknown frame format %#x\n",
			regs->format);
		do_exit(SIGSEGV);
	}

/* set up the "normal" stack seen by the signal handler */
	tframe = frame;

	/* return address points to code on stack */
	put_fs_long((ulong)(frame+4), tframe); tframe++;
	if (current->exec_domain && current->exec_domain->signal_invmap)
	    put_fs_long(current->exec_domain->signal_invmap[signr], tframe);
	else
	    put_fs_long(signr, tframe);
	tframe++;
	put_fs_long(regs->vector, tframe); tframe++;
	/* "scp" parameter.  points to sigcontext */
	put_fs_long((ulong)(frame+6), tframe); tframe++;

/* set up the return code... */
	put_fs_long(0xdefc0014,tframe); tframe++; /* addaw #20,sp */
	put_fs_long(0x70774e40,tframe); tframe++; /* moveq #119,d0; trap #0 */

/* Flush caches so the instructions will be correctly executed. (MA) */
	cache_push_v ((unsigned long)frame, (int)tframe - (int)frame);

/* setup and copy the sigcontext structure */
	context.sc_mask       = oldmask;
	context.sc_usp	      = (unsigned long)*fp;
	context.sc_d0	      = regs->d0;
	context.sc_d1	      = regs->regs[0];
	context.sc_a0	      = regs->regs[7];
	context.sc_a1	      = regs->regs[8];
	context.sc_sr	      = regs->sr;
	context.sc_pc	      = pc;
	context.sc_formatvec  = regs->format << 12 | regs->vector;
	__asm__ volatile ("fsave %0" : : "m" (*context.sc_fpstate) : "memory");
	if (context.sc_fpstate[0])
	  {
	    fpu_version = context.sc_fpstate[0];
	    __asm__ volatile ("fmovemx %/fp0-%/fp1,%0\n\t"
			      "fmoveml %/fpcr/%/fpsr/%/fpiar,%1"
			      : /* no outputs */
			      : "m" (*context.sc_fpregs),
				"m" (*context.sc_fpcntl)
			      : "memory");
	  }
	memcpy_tofs (tframe, &context, sizeof(context));

	/*
	 * no matter what frame format we were using before, we
	 * will do the "RTE" using a normal 4 word frame.
	 */
	regs->format = 0;

	/* "return" new usp to caller */
	*fp = frame;
}

/*
 * 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.
 */
asmlinkage int do_signal(unsigned long oldmask, struct pt_regs *regs_in)
{
	unsigned long mask = ~current->blocked;
	unsigned long handler_signal = 0;
	unsigned long *frame = NULL;
	unsigned long pc = 0;
	unsigned long signr;
	struct frame *regs = (struct frame *)regs_in;
	struct sigaction * sa;

	while ((signr = current->signal & mask)) {
		__asm__("bfffo  %2,#0,#0,%1\n\t"
			"bfclr  %0,%1,#1\n\t"
			"eorw   #31,%1"
			:"=m" (current->signal),"=r" (signr)
			:"1" (signr));
		sa = current->sigaction + signr;
		signr++;

		if ((current->flags & PF_PTRACED) && signr != SIGKILL) {
			current->exit_code = signr;
			current->state = TASK_STOPPED;
			notify_parent(current);
			schedule();
			if (!(signr = current->exit_code)) {
			discard_frame:
				/* Make sure that a faulted bus cycle
				   isn't restarted.  */
				switch (regs->format) {
				case 7:
				  regs->stkadj = sizeof (regs->un.fmt7);
				  regs->format = 0;
				  break;
				case 9:
				  regs->stkadj = sizeof (regs->un.fmt9);
				  regs->format = 0;
				  break;
				case 10:
				  regs->stkadj = sizeof (regs->un.fmta);
				  regs->format = 0;
				  break;
				case 11:
				  regs->stkadj = sizeof (regs->un.fmtb);
				  regs->format = 0;
				  break;
				}
				continue;
			}
			current->exit_code = 0;
			if (signr == SIGSTOP)
				goto discard_frame;
			if (_S(signr) & current->blocked) {
				current->signal |= _S(signr);
				continue;
			}
			sa = current->sigaction + signr - 1;
		}
		if (sa->sa_handler == SIG_IGN) {
			if (signr != SIGCHLD)
				continue;
			/* check for SIGCHLD: it's special */
			while (sys_waitpid(-1,NULL,WNOHANG) > 0)
				/* nothing */;
			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->sigaction[SIGCHLD-1].sa_flags &
				      SA_NOCLDSTOP))
					notify_parent(current);
				schedule();
				continue;

			    case SIGQUIT: case SIGILL: case SIGTRAP:
			    case SIGIOT: case SIGFPE: case SIGSEGV:
				if (current->binfmt && current->binfmt->core_dump) {
				    if (current->binfmt->core_dump(signr, (struct pt_regs *)regs))
					signr |= 0x80;
				}
				/* fall through */
			    default:
				current->signal |= _S(signr & 0x7f);
				do_exit(signr);
			}
		}
		/*
		 * OK, we're invoking a handler
		 */
		if (regs->orig_d0 >= 0) {
			if (regs->d0 == -ERESTARTNOHAND ||
			    (regs->d0 == -ERESTARTSYS && !(sa->sa_flags & SA_RESTART)))
				regs->d0 = -EINTR;
		}
		handler_signal |= 1 << (signr-1);
		mask &= ~sa->sa_mask;
	}
	if (regs->orig_d0 >= 0 &&
	    (regs->d0 == -ERESTARTNOHAND ||
	     regs->d0 == -ERESTARTSYS ||
	     regs->d0 == -ERESTARTNOINTR)) {
		regs->d0 = regs->orig_d0;
		regs->pc -= 2;
	}
	if (!handler_signal)    /* no handler will be called - return 0 */
	  {
	    /* If we are about to discard some frame stuff we must
	       copy over the remaining frame. */
	    if (regs->stkadj)
	      {
		struct frame *tregs =
		  (struct frame *) ((ulong) regs + regs->stkadj);

		/* This must be copied with decreasing addresses to
		   handle overlaps.  */
		tregs->format = regs->format;
		tregs->vector = regs->vector;
		tregs->pc = regs->pc;
		tregs->sr = regs->sr;
	      }
	    return 0;
	  }
	pc = regs->pc;
	frame = (unsigned long *)regs->usp;
	signr = 1;
	sa = current->sigaction;
	for (mask = 1 ; mask ; sa++,signr++,mask += mask) {
		if (mask > handler_signal)
			break;
		if (!(mask & handler_signal))
			continue;
		setup_frame(sa,&frame,pc,regs,signr,oldmask);
		pc = (unsigned long) sa->sa_handler;
		if (sa->sa_flags & SA_ONESHOT)
			sa->sa_handler = NULL;
/* force a supervisor-mode page-in of the signal handler to reduce races */
		__asm__ __volatile__("movesb %0,%/d0": :"m" (*(char *)pc):"d0");
		current->blocked |= sa->sa_mask;
		oldmask |= sa->sa_mask;
	}
	regs->usp = (unsigned long) frame;
	regs->pc = pc;

	/*
	 * if setup_frame saved some extra frame junk, we need to
	 * skip over that stuff when doing the RTE.  This means we have
	 * to move the machine portion of the stack frame to where the
	 * "RTE" instruction expects it. The signal that we need to
	 * do this is that regs->stkadj is nonzero.
	 */
	if (regs->stkadj) {
		struct frame *tregs =
			(struct frame *)((ulong)regs + regs->stkadj);

		/* This must be copied with decreasing addresses to
                   handle overlaps.  */
		tregs->format = regs->format;
		tregs->vector = regs->vector;
		tregs->pc = regs->pc;
		tregs->sr = regs->sr;
	}

	return 1;
}
