Back to index

glibc  2.9
Classes | Functions | Variables
sigvec.c File Reference
#include <signal.h>
#include <errno.h>
#include <stddef.h>
#include <sigset-cvt-mask.h>
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  sigvec_wrapper_data

Functions

static void sigvec_wrapper_handler (int sig) __THROW
int __sigvec (int sig, const struct sigvec *vec, struct sigvec *ovec)
 weak_alias (__sigvec, sigvec)

Variables

static struct sigvec_wrapper_data [NSIG]

Class Documentation

struct sigvec_wrapper_data

Definition at line 29 of file sigvec.c.

Class Members
__sighandler_t sw_handler
unsigned int sw_mask

Function Documentation

int __sigvec ( int  sig,
const struct sigvec vec,
struct sigvec ovec 
)

Definition at line 47 of file sigvec.c.

{
  struct sigaction old;

#ifndef SA_RESETHAND
  if (vec == NULL || !(vec->sv_flags & SV_RESETHAND))
#endif
    {
      struct sigaction new, *n;

      if (vec == NULL)
       n = NULL;
      else
       {
         __sighandler_t handler;
         unsigned int mask;
         unsigned int sv_flags;
         unsigned int sa_flags;

         handler = vec->sv_handler;
         mask = vec->sv_mask;
         sv_flags = vec->sv_flags;
         sa_flags = 0;
         if (sv_flags & SV_ONSTACK)
           {
#ifdef SA_ONSTACK
             sa_flags |= SA_ONSTACK;
#else
             __set_errno (ENOSYS);
             return -1;
#endif
           }
#ifdef SA_RESTART
         if (!(sv_flags & SV_INTERRUPT))
           sa_flags |= SA_RESTART;
#endif
#ifdef SA_RESETHAND
         if (sv_flags & SV_RESETHAND)
           sa_flags |= SA_RESETHAND;
#endif
         n = &new;
         new.sa_handler = handler;
         if (sigset_set_old_mask (&new.sa_mask, mask) < 0)
           return -1;
         new.sa_flags = sa_flags;
       }

      if (__sigaction (sig, n, &old) < 0)
       return -1;
    }
#ifndef SA_RESETHAND
  else
    {
      __sighandler_t handler;
      unsigned int mask;
      struct sigvec_wrapper_data *data;
      struct sigaction wrapper;

      handler = vec->sv_handler;
      mask = (unsigned int)vec->sv_mask;
      data = &sigvec_wrapper_data[sig];
      wrapper.sa_handler = sigvec_wrapper_handler;
      /* FIXME: should we set wrapper.sa_mask, wrapper.sa_flags??  */
      data->sw_handler = handler;
      data->sw_mask = mask;

      if (__sigaction (sig, &wrapper, &old) < 0)
       return -1;
    }
#endif

  if (ovec != NULL)
    {
      __sighandler_t handler;
      unsigned int sv_flags;
      unsigned int sa_flags;
      unsigned int mask;

      handler = old.sa_handler;
      sv_flags = 0;
      sa_flags = old.sa_flags;
#ifndef SA_RESETHAND
      if (handler == sigvec_wrapper_handler)
       {
         handler = sigvec_wrapper_data[sig].sw_handler;
         /* should we use data->sw_mask?? */
         sv_flags |= SV_RESETHAND;
       }
#else
     if (sa_flags & SA_RESETHAND)
       sv_flags |= SV_RESETHAND;
#endif
      mask = sigset_get_old_mask (&old.sa_mask);
#ifdef SA_ONSTACK
     if (sa_flags & SA_ONSTACK)
       sv_flags |= SV_ONSTACK;
#endif
#ifdef SA_RESTART
     if (!(sa_flags & SA_RESTART))
#endif
       sv_flags |= SV_INTERRUPT;
      ovec->sv_handler = handler;
      ovec->sv_mask = (int)mask;
      ovec->sv_flags = (int)sv_flags;
    }

  return 0;
}

Here is the call graph for this function:

static void sigvec_wrapper_handler ( int  sig) [static]

Here is the caller graph for this function:

weak_alias ( __sigvec  ,
sigvec   
)

Definition at line 159 of file sigvec.c.

{
  struct sigvec_wrapper_data *data;
  struct sigaction act;
  int save;
  __sighandler_t handler;

  data = &sigvec_wrapper_data[sig];
  act.sa_handler = SIG_DFL;
  act.sa_flags = 0;
  sigset_set_old_mask (&act.sa_mask, data->sw_mask);
  handler = data->sw_handler;
  save = errno;
  (void) __sigaction (sig, &act, (struct sigaction *) NULL);
  __set_errno (save);

  (*handler) (sig);
}

Here is the call graph for this function:


Variable Documentation

struct sigvec_wrapper_data[NSIG] [static]

Definition at line 37 of file sigvec.c.