panic() cleanup.

[minix.git] / servers / pm / signal.c

/* This file handles signals, which are asynchronous events and are generally
 * a messy and unpleasant business.  Signals can be generated by the KILL
 * system call, or from the keyboard (SIGINT) or from the clock (SIGALRM).
 * In all cases control eventually passes to check_sig() to see which processes
 * can be signaled.  The actual signaling is done by sig_proc().
 *
 * The entry points into this file are:
 *   do_sigaction:      perform the SIGACTION system call
 *   do_sigpending:     perform the SIGPENDING system call
 *   do_sigprocmask:    perform the SIGPROCMASK system call
 *   do_sigreturn:      perform the SIGRETURN system call
 *   do_sigsuspend:     perform the SIGSUSPEND system call
 *   do_kill:           perform the KILL system call
 *   do_pause:          perform the PAUSE system call
 *   ksig_pending:      the kernel notified about pending signals
 *   sig_proc:          interrupt or terminate a signaled process
 *   check_sig:         check which processes to signal with sig_proc()
 *   check_pending:     check if a pending signal can now be delivered
 *   restart_sigs:      restart signal work after finishing a FS call
 */

#include "pm.h"
#include <sys/stat.h>
#include <sys/ptrace.h>
#include <minix/callnr.h>
#include <minix/endpoint.h>
#include <minix/com.h>
#include <minix/vm.h>
#include <signal.h>
#include <sys/resource.h>
#include <sys/sigcontext.h>
#include <string.h>
#include "mproc.h"
#include "param.h"

FORWARD _PROTOTYPE( void unpause, (struct mproc *rmp)                   );
FORWARD _PROTOTYPE( void handle_ksig, (int proc_nr, sigset_t sig_map)   );
FORWARD _PROTOTYPE( int sig_send, (struct mproc *rmp, int signo)        );

/*===========================================================================*
 *                              do_sigaction                                 *
 *===========================================================================*/
PUBLIC int do_sigaction()
{
  int r;
  struct sigaction svec;
  struct sigaction *svp;

  if (m_in.sig_nr == SIGKILL) return(OK);
  if (m_in.sig_nr < 1 || m_in.sig_nr >= _NSIG) return(EINVAL);
  svp = &mp->mp_sigact[m_in.sig_nr];
  if ((struct sigaction *) m_in.sig_osa != (struct sigaction *) NULL) {
        r = sys_datacopy(PM_PROC_NR,(vir_bytes) svp,
                who_e, (vir_bytes) m_in.sig_osa, (phys_bytes) sizeof(svec));
        if (r != OK) return(r);
  }

  if ((struct sigaction *) m_in.sig_nsa == (struct sigaction *) NULL) 
        return(OK);

  /* Read in the sigaction structure. */
  r = sys_datacopy(who_e, (vir_bytes) m_in.sig_nsa,
                PM_PROC_NR, (vir_bytes) &svec, (phys_bytes) sizeof(svec));
  if (r != OK) return(r);

  if (svec.sa_handler == SIG_IGN) {
        sigaddset(&mp->mp_ignore, m_in.sig_nr);
        sigdelset(&mp->mp_sigpending, m_in.sig_nr);
        sigdelset(&mp->mp_catch, m_in.sig_nr);
        sigdelset(&mp->mp_sig2mess, m_in.sig_nr);
  } else if (svec.sa_handler == SIG_DFL) {
        sigdelset(&mp->mp_ignore, m_in.sig_nr);
        sigdelset(&mp->mp_catch, m_in.sig_nr);
        sigdelset(&mp->mp_sig2mess, m_in.sig_nr);
  } else if (svec.sa_handler == SIG_MESS) {
        if (! (mp->mp_flags & PRIV_PROC)) return(EPERM);
        sigdelset(&mp->mp_ignore, m_in.sig_nr);
        sigaddset(&mp->mp_sig2mess, m_in.sig_nr);
        sigdelset(&mp->mp_catch, m_in.sig_nr);
  } else {
        sigdelset(&mp->mp_ignore, m_in.sig_nr);
        sigaddset(&mp->mp_catch, m_in.sig_nr);
        sigdelset(&mp->mp_sig2mess, m_in.sig_nr);
  }
  mp->mp_sigact[m_in.sig_nr].sa_handler = svec.sa_handler;
  sigdelset(&svec.sa_mask, SIGKILL);
  sigdelset(&svec.sa_mask, SIGSTOP);
  mp->mp_sigact[m_in.sig_nr].sa_mask = svec.sa_mask;
  mp->mp_sigact[m_in.sig_nr].sa_flags = svec.sa_flags;
  mp->mp_sigreturn = (vir_bytes) m_in.sig_ret;
  return(OK);
}

/*===========================================================================*
 *                              do_sigpending                                *
 *===========================================================================*/
PUBLIC int do_sigpending()
{
  mp->mp_reply.reply_mask = (long) mp->mp_sigpending;
  return OK;
}

/*===========================================================================*
 *                              do_sigprocmask                               *
 *===========================================================================*/
PUBLIC int do_sigprocmask()
{
/* Note that the library interface passes the actual mask in sigmask_set,
 * not a pointer to the mask, in order to save a copy.  Similarly,
 * the old mask is placed in the return message which the library
 * interface copies (if requested) to the user specified address.
 *
 * The library interface must set SIG_INQUIRE if the 'act' argument
 * is NULL.
 *
 * KILL and STOP can't be masked.
 */

  int i;

  mp->mp_reply.reply_mask = (long) mp->mp_sigmask;

  switch (m_in.sig_how) {
      case SIG_BLOCK:
        sigdelset((sigset_t *)&m_in.sig_set, SIGKILL);
        sigdelset((sigset_t *)&m_in.sig_set, SIGSTOP);
        for (i = 1; i < _NSIG; i++) {
                if (sigismember((sigset_t *)&m_in.sig_set, i))
                        sigaddset(&mp->mp_sigmask, i);
        }
        break;

      case SIG_UNBLOCK:
        for (i = 1; i < _NSIG; i++) {
                if (sigismember((sigset_t *)&m_in.sig_set, i))
                        sigdelset(&mp->mp_sigmask, i);
        }
        check_pending(mp);
        break;

      case SIG_SETMASK:
        sigdelset((sigset_t *) &m_in.sig_set, SIGKILL);
        sigdelset((sigset_t *) &m_in.sig_set, SIGSTOP);
        mp->mp_sigmask = (sigset_t) m_in.sig_set;
        check_pending(mp);
        break;

      case SIG_INQUIRE:
        break;

      default:
        return(EINVAL);
        break;
  }
  return OK;
}

/*===========================================================================*
 *                              do_sigsuspend                                *
 *===========================================================================*/
PUBLIC int do_sigsuspend()
{
  mp->mp_sigmask2 = mp->mp_sigmask;     /* save the old mask */
  mp->mp_sigmask = (sigset_t) m_in.sig_set;
  sigdelset(&mp->mp_sigmask, SIGKILL);
  sigdelset(&mp->mp_sigmask, SIGSTOP);
  mp->mp_flags |= SIGSUSPENDED;
  check_pending(mp);
  return(SUSPEND);
}

/*===========================================================================*
 *                              do_sigreturn                                 *
 *===========================================================================*/
PUBLIC int do_sigreturn()
{
/* A user signal handler is done.  Restore context and check for
 * pending unblocked signals.
 */

  int r;

  mp->mp_sigmask = (sigset_t) m_in.sig_set;
  sigdelset(&mp->mp_sigmask, SIGKILL);
  sigdelset(&mp->mp_sigmask, SIGSTOP);

  r = sys_sigreturn(who_e, (struct sigmsg *) m_in.sig_context);
  check_pending(mp);
  return(r);
}

/*===========================================================================*
 *                              do_kill                                      *
 *===========================================================================*/
PUBLIC int do_kill()
{
/* Perform the kill(pid, signo) system call. */

  return check_sig(m_in.pid, m_in.sig_nr, FALSE /* ksig */);
}

/*===========================================================================*
 *                              ksig_pending                                 *
 *===========================================================================*/
PUBLIC int ksig_pending()
{
/* Certain signals, such as segmentation violations originate in the kernel.
 * When the kernel detects such signals, it notifies the PM to take further 
 * action. The PM requests the kernel to send messages with the process
 * slot and bit map for all signaled processes. The File System, for example,
 * uses this mechanism to signal writing on broken pipes (SIGPIPE). 
 *
 * The kernel has notified the PM about pending signals. Request pending
 * signals until all signals are handled. If there are no more signals,
 * NONE is returned in the process number field.
 */ 
 endpoint_t proc_nr_e;
 sigset_t sig_map;

 while (TRUE) {
   int r;
   /* get an arbitrary pending signal */
   if((r=sys_getksig(&proc_nr_e, &sig_map)) != OK)
        panic("sys_getksig failed: %d", r);
   if (NONE == proc_nr_e) {             /* stop if no more pending signals */
        break;
   } else {
        int proc_nr_p;
        if(pm_isokendpt(proc_nr_e, &proc_nr_p) != OK)
                panic("sys_getksig strange process: %d", proc_nr_e);
        handle_ksig(proc_nr_e, sig_map);        /* handle the received signal */
        /* If the process still exists to the kernel after the signal
         * has been handled ...
         */
        if ((mproc[proc_nr_p].mp_flags & (IN_USE | EXITING)) == IN_USE)
        {
           if((r=sys_endksig(proc_nr_e)) != OK) /* ... tell kernel it's done */
                panic("sys_endksig failed: %d", r);
        }
   }
 } 
 return(SUSPEND);                       /* prevents sending reply */
}

/*===========================================================================*
 *                              handle_ksig                                  *
 *===========================================================================*/
PRIVATE void handle_ksig(proc_nr_e, sig_map)
int proc_nr_e;
sigset_t sig_map;
{
  register struct mproc *rmp;
  int i, proc_nr;
  pid_t proc_id, id;

  if(pm_isokendpt(proc_nr_e, &proc_nr) != OK || proc_nr < 0) {
        printf("PM: handle_ksig: %d?? not ok\n", proc_nr_e);
        return;
  }
  rmp = &mproc[proc_nr];
  if ((rmp->mp_flags & (IN_USE | EXITING)) != IN_USE) {
#if 0
        printf("PM: handle_ksig: %d?? exiting / not in use\n", proc_nr_e);
#endif
        return;
  }
  proc_id = rmp->mp_pid;
  mp = &mproc[0];                       /* pretend signals are from PM */
  mp->mp_procgrp = rmp->mp_procgrp;     /* get process group right */

  /* Check each bit in turn to see if a signal is to be sent.  Unlike
   * kill(), the kernel may collect several unrelated signals for a
   * process and pass them to PM in one blow.  Thus loop on the bit
   * map. For SIGVTALRM and SIGPROF, see if we need to restart a
   * virtual timer. For SIGINT, SIGWINCH and SIGQUIT, use proc_id 0
   * to indicate a broadcast to the recipient's process group.  For
   * SIGKILL, use proc_id -1 to indicate a systemwide broadcast.
   */
  for (i = 1; i < _NSIG; i++) {
        if (!sigismember(&sig_map, i)) continue;
#if 0
        printf("PM: sig %d for %d from kernel\n", 
                i, proc_nr_e);
#endif
        switch (i) {
            case SIGINT:
            case SIGQUIT:
            case SIGWINCH:
                id = 0; break;  /* broadcast to process group */
            case SIGVTALRM:
            case SIGPROF:
                check_vtimer(proc_nr, i);
                /* fall-through */
            default:
                id = proc_id;
                break;
        }
        check_sig(id, i, TRUE /* ksig */);
  }

  /* If SIGNDELAY is set, an earlier sys_stop() failed because the process was
   * still sending, and the kernel hereby tells us that the process is now done
   * with that. We can now try to resume what we planned to do in the first
   * place: set up a signal handler. However, the process's message may have
   * been a call to PM, in which case the process may have changed any of its
   * signal settings. The process may also have forked, exited etcetera.
   */
  if (sigismember(&sig_map, SIGNDELAY) && (rmp->mp_flags & DELAY_CALL)) {
        rmp->mp_flags &= ~DELAY_CALL;

        if (rmp->mp_flags & (FS_CALL | PM_SIG_PENDING))
                panic("handle_ksig: bad process state");

        /* Process as many normal signals as possible. */
        check_pending(rmp);

        if (rmp->mp_flags & DELAY_CALL)
                panic("handle_ksig: multiple delay calls?");
  }
}

/*===========================================================================*
 *                              do_pause                                     *
 *===========================================================================*/
PUBLIC int do_pause()
{
/* Perform the pause() system call. */

  mp->mp_flags |= PAUSED;
  return(SUSPEND);
}

/*===========================================================================*
 *                              sig_proc                                     *
 *===========================================================================*/
PUBLIC void sig_proc(rmp, signo, trace, ksig)
register struct mproc *rmp;     /* pointer to the process to be signaled */
int signo;                      /* signal to send to process (1 to _NSIG-1) */
int trace;                      /* pass signal to tracer first? */
int ksig;                       /* non-zero means signal comes from kernel  */
{
/* Send a signal to a process.  Check to see if the signal is to be caught,
 * ignored, tranformed into a message (for system processes) or blocked.  
 *  - If the signal is to be transformed into a message, request the KERNEL to
 * send the target process a system notification with the pending signal as an 
 * argument. 
 *  - If the signal is to be caught, request the KERNEL to push a sigcontext 
 * structure and a sigframe structure onto the catcher's stack.  Also, KERNEL 
 * will reset the program counter and stack pointer, so that when the process 
 * next runs, it will be executing the signal handler. When the signal handler 
 * returns,  sigreturn(2) will be called.  Then KERNEL will restore the signal 
 * context from the sigcontext structure.
 * If there is insufficient stack space, kill the process.
 */
  int r, slot, badignore;

  slot = (int) (rmp - mproc);
  if ((rmp->mp_flags & (IN_USE | EXITING)) != IN_USE) {
        printf("PM: signal %d sent to exiting process %d\n", signo, slot);
        panic("");
  }

  if (trace == TRUE && rmp->mp_tracer != NO_TRACER && signo != SIGKILL) {
        /* Signal should be passed to the debugger first.
         * This happens before any checks on block/ignore masks; otherwise,
         * the process itself could block/ignore debugger signals.
         */

        sigaddset(&rmp->mp_sigtrace, signo);

        if (!(rmp->mp_flags & STOPPED))
                stop_proc(rmp, signo);  /* a signal causes it to stop */

        return;
  }

  if (rmp->mp_flags & FS_CALL) {
        sigaddset(&rmp->mp_sigpending, signo);

        if (!(rmp->mp_flags & PM_SIG_PENDING)) {
                /* No delay calls: FS_CALL implies the process called us. */
                if ((r = sys_stop(rmp->mp_endpoint)) != OK)
                        panic("sys_stop failed: %d", r);

                rmp->mp_flags |= PM_SIG_PENDING;
        }

        return;
  }

  /* some signals cannot be safely ignored */
  badignore = ksig && sigismember(&noign_sset, signo) && (
          sigismember(&rmp->mp_ignore, signo) ||
          sigismember(&rmp->mp_sigmask, signo) ||
          sigismember(&rmp->mp_sig2mess, signo));

  if (!badignore && sigismember(&rmp->mp_ignore, signo)) { 
        /* Signal should be ignored. */
        return;
  }
  if (!badignore && sigismember(&rmp->mp_sigmask, signo)) {
        /* Signal should be blocked. */
        sigaddset(&rmp->mp_sigpending, signo);
        return;
  }
  if (!badignore && sigismember(&rmp->mp_sig2mess, signo)) {
        /* Mark event pending in process slot and send notification. */
        sigaddset(&rmp->mp_sigpending, signo);
        notify(rmp->mp_endpoint);
        return;
  }

  if ((rmp->mp_flags & STOPPED) && signo != SIGKILL) {
        /* If the process is stopped for a debugger, do not deliver any signals
         * (except SIGKILL) in order not to confuse the debugger. The signals
         * will be delivered using the check_pending() calls in do_trace().
         */
        sigaddset(&rmp->mp_sigpending, signo);
        return;
  }

  if (!badignore && sigismember(&rmp->mp_catch, signo)) {
        /* Signal is caught. First interrupt the process's current call, if
         * applicable. This may involve a roundtrip to FS, in which case we'll
         * have to check back later.
         */
        if (!(rmp->mp_flags & UNPAUSED)) {
                unpause(rmp);

                if (!(rmp->mp_flags & UNPAUSED)) {
                        /* not yet unpaused; continue later */
                        sigaddset(&rmp->mp_sigpending, signo);

                        return;
                }
        }

        /* Then send the actual signal to the process, by setting up a signal
         * handler.
         */
        if (sig_send(rmp, signo))
                return;

        /* We were unable to spawn a signal handler. Kill the process. */
  }
  else if (!badignore && sigismember(&ign_sset, signo)) {
        /* Signal defaults to being ignored. */
        return;
  }

  /* Terminate process */
  rmp->mp_sigstatus = (char) signo;
  if (sigismember(&core_sset, signo)) {
        printf("PM: coredump signal %d for %d / %s\n", signo, rmp->mp_pid,
                rmp->mp_name);
        exit_proc(rmp, 0, TRUE /*dump_core*/);
  }
  else {
        exit_proc(rmp, 0, FALSE /*dump_core*/);
  }
}

/*===========================================================================*
 *                              check_sig                                    *
 *===========================================================================*/
PUBLIC int check_sig(proc_id, signo, ksig)
pid_t proc_id;                  /* pid of proc to sig, or 0 or -1, or -pgrp */
int signo;                      /* signal to send to process (0 to _NSIG-1) */
int ksig;                       /* non-zero means signal comes from kernel  */
{
/* Check to see if it is possible to send a signal.  The signal may have to be
 * sent to a group of processes.  This routine is invoked by the KILL system
 * call, and also when the kernel catches a DEL or other signal.
 */

  register struct mproc *rmp;
  int count;                    /* count # of signals sent */
  int error_code;

  if (signo < 0 || signo >= _NSIG) return(EINVAL);

  /* Return EINVAL for attempts to send SIGKILL to INIT alone. */
  if (proc_id == INIT_PID && signo == SIGKILL) return(EINVAL);

  /* Search the proc table for processes to signal.  
   * (See forkexit.c about pid magic.)
   */
  count = 0;
  error_code = ESRCH;
  for (rmp = &mproc[0]; rmp < &mproc[NR_PROCS]; rmp++) {
        if (!(rmp->mp_flags & IN_USE)) continue;

        /* Check for selection. */
        if (proc_id > 0 && proc_id != rmp->mp_pid) continue;
        if (proc_id == 0 && mp->mp_procgrp != rmp->mp_procgrp) continue;
        if (proc_id == -1 && rmp->mp_pid <= INIT_PID) continue;
        if (proc_id < -1 && rmp->mp_procgrp != -proc_id) continue;

        /* Do not kill servers and drivers when broadcasting SIGKILL. */
        if (proc_id == -1 && signo == SIGKILL &&
                (rmp->mp_flags & PRIV_PROC)) continue;

        /* Check for permission. */
        if (mp->mp_effuid != SUPER_USER
            && mp->mp_realuid != rmp->mp_realuid
            && mp->mp_effuid != rmp->mp_realuid
            && mp->mp_realuid != rmp->mp_effuid
            && mp->mp_effuid != rmp->mp_effuid) {
                error_code = EPERM;
                continue;
        }

        count++;
        if (signo == 0 || (rmp->mp_flags & EXITING)) continue;

        /* 'sig_proc' will handle the disposition of the signal.  The
         * signal may be caught, blocked, ignored, or cause process
         * termination, possibly with core dump.
         */
        sig_proc(rmp, signo, TRUE /*trace*/, ksig);

        if (proc_id > 0) break; /* only one process being signaled */
  }

  /* If the calling process has killed itself, don't reply. */
  if ((mp->mp_flags & (IN_USE | EXITING)) != IN_USE) return(SUSPEND);
  return(count > 0 ? OK : error_code);
}

/*===========================================================================*
 *                              check_pending                                *
 *===========================================================================*/
PUBLIC void check_pending(rmp)
register struct mproc *rmp;
{
  /* Check to see if any pending signals have been unblocked. Deliver as many
   * of them as we can, until we have to wait for a reply from VFS first.
   *
   * There are several places in this file where the signal mask is
   * changed.  At each such place, check_pending() should be called to
   * check for newly unblocked signals.
   */

  int i;

  for (i = 1; i < _NSIG; i++) {
        if (sigismember(&rmp->mp_sigpending, i) &&
                !sigismember(&rmp->mp_sigmask, i)) {
                sigdelset(&rmp->mp_sigpending, i);
                sig_proc(rmp, i, FALSE /*trace*/, FALSE /* ksig */);

                if (rmp->mp_flags & FS_CALL)
                        break;
        }
  }
}

/*===========================================================================*
 *                              restart_sigs                                 *
 *===========================================================================*/
PUBLIC void restart_sigs(rmp)
struct mproc *rmp;
{
/* FS has replied to a request from us; do signal-related work.
 */
  int r;

  if (rmp->mp_flags & (FS_CALL | EXITING)) return;

  if (rmp->mp_flags & TRACE_EXIT) {
        /* Tracer requested exit with specific exit value */
        exit_proc(rmp, rmp->mp_exitstatus, FALSE /*dump_core*/);
  }
  else if (rmp->mp_flags & PM_SIG_PENDING) {
        /* We saved signal(s) for after finishing a FS call. Deal with this.
         * PM_SIG_PENDING remains set to indicate the process is still stopped.
         */
        check_pending(rmp);

        /* The process may now be FS-blocked again, because a signal exited the
         * process or was caught. Restart the process only when this is NOT the
         * case.
         */
        if (!(rmp->mp_flags & FS_CALL)) {
                rmp->mp_flags &= ~(PM_SIG_PENDING | UNPAUSED);

                if ((r = sys_resume(rmp->mp_endpoint)) != OK)
                        panic("sys_resume failed: %d", r);
        }
  }
}

/*===========================================================================*
 *                              unpause                                      *
 *===========================================================================*/
PRIVATE void unpause(rmp)
struct mproc *rmp;              /* which process */
{
/* A signal is to be sent to a process.  If that process is hanging on a
 * system call, the system call must be terminated with EINTR.  Possible
 * calls are PAUSE, WAIT, READ and WRITE, the latter two for pipes and ttys.
 * First check if the process is hanging on an PM call.  If not, tell FS,
 * so it can check for READs and WRITEs from pipes, ttys and the like.
 */
  message m;
  int r, slot;

  /* If we're already waiting for a delayed call, don't do anything now. */
  if (rmp->mp_flags & DELAY_CALL)
        return;

  /* Check to see if process is hanging on a PAUSE, WAIT or SIGSUSPEND call. */
  if (rmp->mp_flags & (PAUSED | WAITING | SIGSUSPENDED)) {
        /* Stop process from running. No delay calls: it called us. */
        if ((r = sys_stop(rmp->mp_endpoint)) != OK)
                panic("sys_stop failed: %d", r);

        rmp->mp_flags |= UNPAUSED;

        /* We interrupt the actual call from sig_send() below. */
        return;
  }

  /* Not paused in PM. Let FS try to unpause the process. */
  if (!(rmp->mp_flags & PM_SIG_PENDING)) {
        /* Stop process from running. */
        r = sys_delay_stop(rmp->mp_endpoint);

        /* If the process is still busy sending a message, the kernel will give
         * us EBUSY now and send a SIGNDELAY to the process as soon as sending
         * is done.
         */
        if (r == EBUSY) {
                rmp->mp_flags |= DELAY_CALL;

                return;
        }
        else if (r != OK) panic("sys_stop failed: %d", r);

        rmp->mp_flags |= PM_SIG_PENDING;
  }

  m.m_type = PM_UNPAUSE;
  m.PM_PROC = rmp->mp_endpoint;

  tell_fs(rmp, &m);

  /* Also tell VM. */
  vm_notify_sig_wrapper(rmp->mp_endpoint);
}

/*===========================================================================*
 *                              sig_send                                     *
 *===========================================================================*/
PRIVATE int sig_send(rmp, signo)
struct mproc *rmp;              /* what process to spawn a signal handler in */
int signo;                      /* signal to send to process (1 to _NSIG-1) */
{
/* The process is supposed to catch this signal. Spawn a signal handler.
 * Return TRUE if this succeeded, FALSE otherwise.
 */
  struct sigmsg sigmsg;
  vir_bytes cur_sp;
  int r, sigflags, slot;

  if (!(rmp->mp_flags & UNPAUSED))
        panic("sig_send: process not unpaused");

  sigflags = rmp->mp_sigact[signo].sa_flags;
  slot = (int) (rmp - mproc);

  if (rmp->mp_flags & SIGSUSPENDED)
        sigmsg.sm_mask = rmp->mp_sigmask2;
  else
        sigmsg.sm_mask = rmp->mp_sigmask;
  sigmsg.sm_signo = signo;
  sigmsg.sm_sighandler =
        (vir_bytes) rmp->mp_sigact[signo].sa_handler;
  sigmsg.sm_sigreturn = rmp->mp_sigreturn;
  rmp->mp_sigmask |= rmp->mp_sigact[signo].sa_mask;

  if (sigflags & SA_NODEFER)
        sigdelset(&rmp->mp_sigmask, signo);
  else
        sigaddset(&rmp->mp_sigmask, signo);

  if (sigflags & SA_RESETHAND) {
        sigdelset(&rmp->mp_catch, signo);
        rmp->mp_sigact[signo].sa_handler = SIG_DFL;
  }
  sigdelset(&rmp->mp_sigpending, signo);

  if(vm_push_sig(rmp->mp_endpoint, &cur_sp) != OK)
        return(FALSE);

  sigmsg.sm_stkptr = cur_sp;

  /* Ask the kernel to deliver the signal */
  r = sys_sigsend(rmp->mp_endpoint, &sigmsg);
  if (r != OK)
        panic("sys_sigsend failed: %d", r);

  /* Was the process suspended in PM? Then interrupt the blocking call. */
  if (rmp->mp_flags & (PAUSED | WAITING | SIGSUSPENDED)) {
        rmp->mp_flags &= ~(PAUSED | WAITING | SIGSUSPENDED);

        setreply(slot, EINTR);
  }

  /* Was the process stopped just for this signal? Then resume it. */
  if ((rmp->mp_flags & (PM_SIG_PENDING | UNPAUSED)) == UNPAUSED) {
        rmp->mp_flags &= ~UNPAUSED;

        if ((r = sys_resume(rmp->mp_endpoint)) != OK)
                panic("sys_resume failed: %d", r);
  }

  return(TRUE);
}

/*===========================================================================*
 *                              vm_notify_sig_wrapper                        *
 *===========================================================================*/
PUBLIC void vm_notify_sig_wrapper(endpoint_t ep)
{
/* get IPC's endpoint,
 * the reason that we directly get the endpoint
 * instead of from DS server is that otherwise
 * it will cause deadlock between PM, VM and DS.
 */
  struct mproc *rmp;
  endpoint_t ipc_ep = 0;

  for (rmp = &mproc[0]; rmp < &mproc[NR_PROCS]; rmp++) {
        if (!(rmp->mp_flags & IN_USE))
                continue;
        if (!strcmp(rmp->mp_name, "ipc")) {
                ipc_ep = rmp->mp_endpoint;
                vm_notify_sig(ep, ipc_ep);

                return;
        }
  }
}