The CDPD Public Domain Collection for CDTV 3/CDPDIII.bin/pd/programming/gnuc/library/rcs/kern_sig.c,v

Text File | 1992-08-09 | 20.7 KB | 971 lines

head    1.3;
access;
symbols
    version39-41:1.2;
locks;
comment    @ *  @;


1.3
date    92.08.09.20.57.07;    author amiga;    state Exp;
branches;
next    1.2;

1.2
date    92.07.04.19.19.51;    author mwild;    state Exp;
branches;
next    1.1;

1.1
date    92.05.14.19.55.40;    author mwild;    state Exp;
branches;
next    ;


desc
@higher level signal management code
@


1.3
log
@import sysbase
@
text
@/*
 *  This file is part of ixemul.library for the Amiga.
 *  Copyright (C) 1991, 1992  Markus M. Wild
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  $Id: kern_sig.c,v 1.2 1992/07/04 19:19:51 mwild Exp $
 *
 *  $Log: kern_sig.c,v $
 *  Revision 1.2  1992/07/04  19:19:51  mwild
 *  change to new ix_sleep() semantics
 *
 * Revision 1.1  1992/05/14  19:55:40  mwild
 * Initial revision
 *
 *
 *  Since the code originated from Berkeley, the following copyright
 *  header applies as well. The code has been changed, it's not the
 *  original Berkeley code!
 */

/*
 * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution is only permitted until one year after the first shipment
 * of 4.4BSD by the Regents.  Otherwise, redistribution and use in source and
 * binary forms are permitted provided that: (1) source distributions retain
 * this entire copyright notice and comment, and (2) distributions including
 * binaries display the following acknowledgement:  This product includes
 * software developed by the University of California, Berkeley and its
 * contributors'' in the documentation or other materials provided with the
 * distribution and in all advertising materials mentioning features or use
 * of this software.  Neither the name of the University nor the names of
 * its contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *    @@(#)kern_sig.c    7.23 (Berkeley) 6/28/90
 */

#define KERNEL
#include "ixemul.h"

#ifdef DEBUG
#define DP(a) kprintf a
#else
#define DP(a)
#endif

extern struct ExecBase *SysBase;

#include <wait.h>

#define    ttystopsigmask    (sigmask(SIGTSTP)|sigmask(SIGTTIN)|sigmask(SIGTTOU))
#define    stopsigmask    (sigmask(SIGSTOP)|ttystopsigmask)
#define defaultignmask    (sigmask(SIGCONT)|sigmask(SIGIO)|sigmask(SIGURG)| \
            sigmask(SIGCHLD)|sigmask(SIGWINCH)|sigmask(SIGINFO)|sigmask(SIGMSG))

void setsigvec (int sig, struct sigaction *sa);
void _psignal (struct Task *t, int sig);
void sig_exit (int code);

/*
 * Can process p send the signal signo to process q?
 */
#define CANSIGNAL(p, q, signo) (1)

int
sigaction (int sig, const struct sigaction *nsa, struct sigaction *osa)
{
  struct sigaction vec;
  register struct sigaction *sa;
  int bit, error;

  if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP)
    {
      errno = EINVAL;
      return -1;
    }

  sa = &vec;
  if (osa)
    {
      sa->sa_handler = u.u_signal[sig];
      sa->sa_mask = u.u_sigmask[sig];
      bit = sigmask(sig);
      sa->sa_flags = 0;
      if ((u.u_sigonstack & bit) != 0)
    sa->sa_flags |= SA_ONSTACK;

      if ((u.u_sigintr & bit) == 0)
    sa->sa_flags |= SA_RESTART;

      if (u.p_flag & SNOCLDSTOP)
    sa->sa_flags |= SA_NOCLDSTOP;

      *osa = *sa;
    }

  if (nsa)
    {
      *sa = *nsa;
      setsigvec(sig, sa);
    }

  return (0);
}

void
setsigvec (int sig, struct sigaction *sa)
{
  register int bit;

  bit = sigmask(sig);
  /*
   * Change setting atomically.
   */
  Disable();

  u.u_signal[sig] = sa->sa_handler;
  u.u_sigmask[sig] = sa->sa_mask &~ sigcantmask;

  if ((sa->sa_flags & SA_RESTART) == 0)
    u.u_sigintr |= bit;
  else
    u.u_sigintr &= ~bit;

  if (sa->sa_flags & SA_ONSTACK)
    u.u_sigonstack |= bit;
  else
    u.u_sigonstack &= ~bit;

  if (sig == SIGCHLD)
    {
      if (sa->sa_flags & SA_NOCLDSTOP)
    u.p_flag |= SNOCLDSTOP;
      else
    u.p_flag &= ~SNOCLDSTOP;
    }

  /*
   * Set bit in p_sigignore for signals that are set to SIG_IGN,
   * and for signals set to SIG_DFL where the default is to ignore.
   * However, don't put SIGCONT in p_sigignore,
   * as we have to restart the process.
   */
  if (sa->sa_handler == SIG_IGN ||
      (bit & defaultignmask && sa->sa_handler == SIG_DFL))
    {
      u.p_sig &= ~bit;        /* never to be seen again */
      if (sig != SIGCONT)
    u.p_sigignore |= bit;    /* easier in _psignal */
      u.p_sigcatch &= ~bit;
    }
  else
    {
      u.p_sigignore &= ~bit;
      if (sa->sa_handler == SIG_DFL)
    u.p_sigcatch &= ~bit;
      else
    u.p_sigcatch |= bit;
    }

  Enable();
}


/*
 * Manipulate signal mask.
 */

int
sigprocmask (int how, const sigset_t *mask, sigset_t *omask)
{
  if (omask)
    *omask = u.p_sigmask;

  if (mask)
    {
      Disable();

      switch (how)
        {
        case SIG_BLOCK:
      u.p_sigmask |= *mask &~ sigcantmask;
      break;

        case SIG_UNBLOCK:
      u.p_sigmask &= ~*mask;
      break;

        case SIG_SETMASK:
      u.p_sigmask = *mask &~ sigcantmask;
      break;

        default:
      errno = EINVAL;
      goto err_ret;
        }

      Enable();
    }

  if (CURSIG (&u))
    setrun (FindTask (0));

  return 0;

err_ret:
  Enable ();
  return -1;
}

int
sigpending (sigset_t *sigs)
{
  *sigs = u.p_sig;
  return 0;
}

/*
 * Generalized interface signal handler, 4.3-compatible.
 * (included in amiga version, because I want to reduce the static part of the
 *  library to a minimum)
 */
/* ARGSUSED */
int
sigvec(int sig, const struct sigvec *nsv, struct sigvec *osv)
{
  struct sigvec vec;
  register struct sigvec *sv;
  struct user *p = &u;
  int bit, error;

  if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP)
    {
      *p->u_errno = EINVAL;
      return -1;
    }

  sv = &vec;
  if (osv)
    {
      *(sig_t *)&sv->sv_handler = p->u_signal[sig];
      sv->sv_mask = p->u_sigmask[sig];
      bit = sigmask(sig);
      sv->sv_flags = 0;
      if ((p->u_sigonstack & bit) != 0)
    sv->sv_flags |= SV_ONSTACK;
      if ((p->u_sigintr & bit) != 0)
    sv->sv_flags |= SV_INTERRUPT;
      if (p->p_flag & SNOCLDSTOP)
    sv->sv_flags |= SA_NOCLDSTOP;
      *osv = *sv;
    }

  if (nsv)
    {
      *sv = *nsv;
      sv->sv_flags ^= SA_RESTART;    /* opposite of SV_INTERRUPT */
      setsigvec(sig, (struct sigaction *)sv);
    }

  return (0);
}

sigset_t
sigblock (sigset_t mask)
{
  sigset_t result;

  Disable();
  result = u.p_sigmask;
  u.p_sigmask |= mask &~ sigcantmask;
  (void) Enable();

  errno = 0;
  return result;
}

sigset_t
sigsetmask(sigset_t mask)
{
  sigset_t result;
  struct user *p = &u;

  Disable();
  result = u.p_sigmask;
  u.p_sigmask = mask &~ sigcantmask;
  Enable();

  if (CURSIG (p))
    setrun (FindTask (0));

  errno = 0;
  return result;
}

/*
 * Suspend process until signal, providing mask to be set
 * in the meantime.
 */
/* ARGSUSED */
int
sigsuspend (const sigset_t *mask)
{
  struct user *p = &u;
  int rc;

#if 0
  /* clear the signal, which might already be set... */
  SetSignal (0, 1 << p->u_sleep_sig);
#endif

#ifdef DEBUG
  {
    if (SysBase->TDNestCnt >= 0)
      {
        DP(("PANIC!! sigsuspend called inside Forbid!!\n"));
        while (1);
      }
    if (SysBase->IDNestCnt >= 0)
      {
        DP(("PANIC!! sigsuspend called inside Disable!!\n"));
    while (1);
      }
  }
#endif

  /*
   * When returning from sigpause, we want
   * the old mask to be restored after the
   * signal handler has finished.  Thus, we
   * save it here and mark the proc structure
   * to indicate this (should be in u.).
   */

  Disable ();
  p->u_oldmask = p->p_sigmask;
  p->p_flag |= SOMASK;
  p->p_sigmask = *mask &~ sigcantmask;

/*  (void) tsleep((caddr_t)&u, PPAUSE | PCATCH, "pause", 0); */

  /* NOTE: we have to specify SIGBREAKF_CTRL_C here, as the OS doesn't seem
   *       to reschedule our task, if it receives a signal it isn't waiting
   *       for. If SIGINT is ignored, then this will jump back into the Wait,
   *       if not, we're leaving correctly, since we waited for a signal
   *       that now occured (lucky we, the OS tests the Recvd-field before
   *       tc_Launch has a chance to reset it ;-))
   */

#if 0
  if (CURSIG (p))
    setrun (FindTask (0));
  else
    Wait ((1 << p->u_sleep_sig) | SIGBREAKF_CTRL_C);
#else
DP(("sigsuspend: going to sleep\n"));
  while (ix_sleep (p, "sigsuspend") == 0)
    DP(("  ignoring masked out SIGINT\n"));
#endif
  Enable ();

  DP(("sigsuspend-setrun: state = %ld, sig = $%lx, mask = $%lx, i = %ld\n",
      p->p_stat, p->p_sig, p->p_sigmask, CURSIG(p)));
  setrun (FindTask (0));

  p->p_sigmask = p->u_oldmask;

  if (CURSIG (p))
    setrun (FindTask (0));

  /* always return EINTR rather than ERESTART... */
  errno = EINTR;
  return -1;
}


int
sigpause (sigset_t mask)
{
  return sigsuspend (&mask);
}


/* ARGSUSED */
int
sigstack(const struct sigstack *nss, struct sigstack *oss)
{
  if (oss) *oss = u.u_sigstack;
  if (nss) u.u_sigstack = *nss;

  return 0;
}


/*
 * Initialize signal state for process 0;
 * set to ignore signals that are ignored by default.
 */
void
siginit(struct user *p)
{
  p->p_sigignore = defaultignmask &~ sigmask(SIGCONT);
}

/*
 * This looks for the process p, validates it, and checks, whether the process
 * is currently using our signal mechanism (checks magic cookie in struct user)
 */
static inline struct Task *
pfind (pid_t p)
{
  struct Task *t;

  if (p && !(p & 1))
    {
      t = (struct Task *) p;
      if (t->tc_Node.ln_Type == NT_TASK ||
          t->tc_Node.ln_Type == NT_PROCESS)
        {
          struct user *tu = (struct user *) t->tc_TrapData;
          if (tu && !((int)t->tc_TrapData & 1) && tu->u_ixbase == u.u_ixbase)
        return t;
    }
    }
  else if (! p)
    return FindTask (0);

  return 0;
}

/* ARGSUSED */
int
kill(pid_t pid, int signo)
{
  register struct Task *t;

  if ((unsigned) signo >= NSIG)
    {
      errno = EINVAL;
      return -1;
    }

  if (pid >= 0)
    {
      /* kill single process */
      t = pfind(pid);
      if (t == 0)
        {
      /* there is a small chance, if pid == 0, that we may send the signal
       * as well. If signo == SIGINT, and pid refers to a valid Task, we send
       * it a SIGBREAKF_CTRL_C */
      if ((signo == SIGINT) && pid && !(pid & 1))
        {
          t = (struct Task *) pid;
          if (t->tc_Node.ln_Type == NT_TASK ||
              t->tc_Node.ln_Type == NT_PROCESS)
            {
          Signal (t, SIGBREAKF_CTRL_C);
          return 0;
        }
        }

          errno = ESRCH;
          return -1;
        }

      if (signo)
    _psignal(t, signo);

      return (0);
    }

  /* signalling process groups is not (yet) implemented */
  errno = ESRCH;
  return -1;
}

/* ARGSUSED */
int
killpg(int pgid, int signo)
{
  if ((unsigned) signo >= NSIG)
    errno = EINVAL;
  else
    errno = ESRCH;

  /* signalling process groups is not (yet) implemented */
  return -1;
}

/*
 * Send a signal caused by a trap to the current process.
 * If it will be caught immediately, deliver it with correct code.
 * Otherwise, post it normally.
 */
int
trapsignal(struct Task *t, int sig, unsigned code, void *addr)
{
  int mask;

  mask = sigmask(sig);
  if ((u.p_flag & STRC) == 0 && (u.p_sigcatch & mask) != 0 &&
      (u.p_sigmask & mask) == 0)
    {
      u.u_ru.ru_nsignals++;
      sendsig(t->tc_TrapData, u.u_signal[sig], sig, u.p_sigmask, code, addr);
      u.p_sigmask |= u.u_sigmask[sig] | mask;
      setrun (t);
    }
  else
    {
      u.u_code = code;    /* XXX for core dump/debugger */
      _psignal(t, sig);
    }
}

/*
 * Send the specified signal to the specified process.
 * Most signals do not do anything directly to a process;
 * they set a flag that asks the process to do something to itself.
 * Exceptions:
 *   o When a stop signal is sent to a sleeping process that takes the default
 *     action, the process is stopped without awakening it.
 *   o SIGCONT restarts stopped processes (or puts them back to sleep)
 *     regardless of the signal action (eg, blocked or ignored).
 * Other ignored signals are discarded immediately.
 */
void
_psignal(struct Task *t, int sig)    /* MAY be called in Supervisor/Interrupt  !*/
{
  register int s;
  register sig_t action;
  /* may be another process, so don't use u. here ! */
  struct user *p = (struct user *)t->tc_TrapData;
  int mask;

#if 0
  if ((unsigned)sig >= NSIG || sig == 0)
    ix_panic("psignal sig");
#endif

  mask = sigmask(sig);

  /*
   * If proc is traced, always give parent a chance.
   */
  if (p->p_flag & STRC)
    action = SIG_DFL;
  else
    {

      /* NOTE AMIGA !
       * I can't allow for trap signals to be either ignored or masked out.
       * This would cause the trap to reoccur immediately again, resulting
       * in a deadly loop. So if such a signal gets here, it is converted
       * in a SIGILL, masked in, not ignored, not caught, that's it.
       */
      if (((mask & p->p_sigignore) || (mask & p->p_sigmask))
      && (sig == SIGILL  || sig == SIGBUS || sig == SIGFPE ||
          sig == SIGTRAP || sig == SIGEMT))
    {
      sig = SIGILL;
      mask = sigmask (sig);
      p->p_sigignore &= ~mask;
      p->p_sigmask   &= ~mask;
      p->p_sigcatch  &= ~mask;
      /* that's it, SIGILL is now reset to SIG_DFL, which will exit() */
    }

      /*
       * If the signal is being ignored,
       * then we forget about it immediately.
       * (Note: we don't set SIGCONT in p_sigignore,
       * and if it is set to SIG_IGN,
       * action will be SIG_DFL here.)
       */
     if (p->p_sigignore & mask)
    return;

     if (p->p_sigmask & mask)
    action = SIG_HOLD;
     else if (p->p_sigcatch & mask)
    action = SIG_CATCH;
     else
    action = SIG_DFL;
    }

  switch (sig)
    {
    case SIGTERM:
      if ((p->p_flag&STRC) || action != SIG_DFL)
    break;
    /* FALLTHROUGH */

    case SIGKILL:
      break;

    case SIGCONT:
      p->p_sig &= ~stopsigmask;
      break;

    case SIGTSTP:
    case SIGTTIN:
    case SIGTTOU:
    case SIGSTOP:
      p->p_sig &= ~sigmask(SIGCONT);
      break;
    }
  p->p_sig |= mask;

  /*
   * Defer further processing for signals which are held,
   * except that stopped processes must be continued by SIGCONT.
   */
  if (action == SIG_HOLD && (sig != SIGCONT || p->p_stat != SSTOP))
    return;

  setrun(t);
out:
  ;
}

/*
 * If the current process has a signal to process (should be caught
 * or cause termination, should interrupt current syscall),
 * return the signal number.  Stop signals with default action
 * are processed immediately, then cleared; they aren't returned.
 * This is asked at least once each time a process enters the
 * system (though this can usually be done without actually
 * calling issig by checking the pending signal masks.)
 */
int
issig(struct user *p)    /* called in SUPERVISOR */
{
  register int sig, mask;

  for (;;)
    {
      mask = p->p_sig &~ p->p_sigmask;
      if (p->p_flag&SVFORK)
    mask &= ~stopsigmask;

      if (mask == 0)         /* no signal to send */
    return 0;

      sig = ffs((long)mask);
      mask = sigmask(sig);
      /*
       * We should see pending but ignored signals
       * only if STRC was on when they were posted.
       */
      if (mask & p->p_sigignore && (p->p_flag&STRC) == 0)
        {
          p->p_sig &= ~mask;
      continue;
    }

#if notyet
      if (p->p_flag&STRC && (p->p_flag&SVFORK) == 0)
        {
      /*
       * If traced, always stop, and stay
       * stopped until released by the parent.
       */
      p->p_xstat = sig;
      _psignal(p->p_pptr, SIGCHLD);
      do
            {
          stop(p);
          swtch();
        }
          while (!procxmt(p) && p->p_flag&STRC);

      /*
       * If the traced bit got turned off,
       * go back up to the top to rescan signals.
       * This ensures that p_sig* and u_signal are consistent.
       */
      if ((p->p_flag&STRC) == 0)
        continue;

      /*
       * If parent wants us to take the signal,
       * then it will leave it in p->p_xstat;
       * otherwise we just look for signals again.
       */
      p->p_sig &= ~mask;    /* clear the old signal */
      sig = p->p_xstat;
      if (sig == 0)
        continue;

      /*
       * Put the new signal into p_sig.
       * If signal is being masked,
       * look for other signals.
       */
      mask = sigmask(sig);
      p->p_sig |= mask;
      if (p->p_sigmask & mask)
        continue;
    }
#endif

      /*
       * Decide whether the signal should be returned.
       * Return the signal's number, or fall through
       * to clear it from the pending mask.
       */
      switch ((int)p->u_signal[sig])
        {
    case SIG_DFL:
#if notyet
      /*
       * Don't take default actions on system processes.
       */
      if (p->p_ppid == 0)
        break;        /* == ignore */
#endif
      /*
       * If there is a pending stop signal to process
       * with default action, stop here,
       * then clear the signal.  However,
       * if process is member of an orphaned
       * process group, ignore tty stop signals.
       */
      if (mask & stopsigmask)
        {
#if notyet
          if (p->p_flag&STRC ||
          (p->p_pgru.pg_jobc == 0 && mask & ttystopsigmask))
        break;    /* == ignore */
          u.p_xstat = sig;
          stop(p);
          if ((u.p_pptr->p_flag & SNOCLDSTOP) == 0)
        _psignal(u.p_pptr, SIGCHLD);
          swtch();
#endif
          break;
        }
          else if (mask & defaultignmask)
        {
          /*
           * Except for SIGCONT, shouldn't get here.
           * Default action is to ignore; drop it.
           */
          break;        /* == ignore */
        }
      else
        return (sig);
      /*NOTREACHED*/

    case SIG_IGN:
      /*
       * Masking above should prevent us ever trying
       * to take action on an ignored signal other
       * than SIGCONT, unless process is traced.
       */
#if 0
      if (sig != SIGCONT && (u.p_flag&STRC) == 0)
        printf("issig\n");
#endif
      break;        /* == ignore */

    default:
      /*
       * This signal has an action, let
       * psig process it.
       */
      return (sig);
    }
      u.p_sig &= ~mask;        /* take the signal! */
    }
  /* NOTREACHED */
}

#if notyet
/*
 * Put the argument process into the stopped
 * state and notify the parent via wakeup.
 * Signals are handled elsewhere.
 * The process must not be on the run queue.
 */
void
stop(struct Task *t)
{
  struct user *p = (struct user *) t->tc_TrapData;

  p->p_stat = SSTOP;
  p->p_flag &= ~SWTED;
  wakeup((caddr_t)u.p_pptr);
}
#endif

/*
 * Perform the action specified by the current signal.
 * The usual sequence is:
 *    if (sig = CURSIG(p))
 *        psig(p, sig);
 */
void
psig(struct user *p, int sig)    /* called in SUPERVISOR */
{
  int mask, returnmask;
  register sig_t action;

  do
    {
#if 0
      if (sig == 0)
    ix_panic("psig");
#endif
      mask = sigmask(sig);
      p->p_sig &= ~mask;
      action = p->u_signal[sig];
      if (action != SIG_DFL)
        {
       /*
        * Set the new mask value and also defer further
        * occurences of this signal.
        *
        * Special case: user has done a sigpause.  Here the
        * current mask is not of interest, but rather the
         * mask from before the sigpause is what we want
        * restored after the signal processing is completed.
        */
#if usermode
      /* not needed here, no interrupt will play with the signalmask... */
      (void) Disable();
#endif
      if (p->p_flag & SOMASK)
        {
          returnmask = p->u_oldmask;
          p->p_flag &= ~SOMASK;
        }
      else
        returnmask = p->p_sigmask;
      p->p_sigmask |= p->u_sigmask[sig] | mask;
#if usermode
      (void) Enable();
#endif

      p->u_ru.ru_nsignals++;
      sendsig(p, action, sig, returnmask, 0, 0);
      continue;
    }

#if whatdoesthisdo
      p->u_acflag |= AXSIG;
#endif

      switch (sig)
        {
    case SIGILL:
    case SIGIOT:
    case SIGBUS:
    case SIGQUIT:
    case SIGTRAP:
    case SIGEMT:
    case SIGFPE:
    case SIGSEGV:
    case SIGSYS:
      p->u_sig = sig;
      if (core() == 0)
        sig |= WCOREFLAG;
    }
      /* we can't call exit() when in supervisor mode, have to do this just like
       * it was a signal passed on its own frame */
      sendsig(p, sig_exit, sig, 0, 0, 0);
      /* NOTREACHED */

  } while (sig = CURSIG(p));
}

/*
 * Create a core image on the file "core".
 * It writes UPAGES block of the
 * user.h area followed by the entire
 * data+stack segments.
 */
int
core()
{
  return -1;
}
@


1.2
log
@change to new ix_sleep() semantics
@
text
@d19 1
a19 1
 *  $Id: kern_sig.c,v 1.1 1992/05/14 19:55:40 mwild Exp $
d22 3
d65 2
a331 1
    struct ExecBase *SysBase = *(void **)4;
@


1.1
log
@Initial revision
@
text
@d19 1
a19 1
 *  $Id$
d21 3
a23 1
 *  $Log$
d25 1
d371 1
a371 1
  while (ix_sleep (p) == 0)
@