git.oblomov.eu Git - wine/blob - loader/signal.c

   1 /*
   2  * Wine signal handling
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include "config.h"
   8
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <string.h>
  12 #include <signal.h>
  13 #include <errno.h>
  14 #include <time.h>
  15 #include <setjmp.h>
  16
  17 #include <sys/time.h>
  18 #include <sys/timeb.h>
  19 #include <sys/types.h>
  20 #include <sys/wait.h>
  21
  22 #ifdef HAVE_SYS_PARAM_H
  23 # include <sys/param.h>
  24 #endif
  25 #ifdef HAVE_SYSCALL_H
  26 # include <syscall.h>
  27 #else
  28 # ifdef HAVE_SYS_SYSCALL_H
  29 #  include <sys/syscall.h>
  30 # endif
  31 #endif
  32
  33 #include "winsock.h"
  34 #include "global.h"
  35 #include "options.h"
  36 #include "miscemu.h"
  37 #include "dosexe.h"
  38 #include "thread.h"
  39 #include "wine/exception.h"
  40 #include "debugtools.h"
  41
  42
  43 /* Linux sigaction function */
  44
  45 #if defined(linux) && defined(__i386__)
  46 /* This is the sigaction structure from the Linux 2.1.20 kernel.  */
  47
  48 #undef sa_handler
  49 struct kernel_sigaction
  50 {
  51     void (*sa_handler)();
  52     unsigned long sa_mask;
  53     unsigned long sa_flags;
  54     void (*sa_restorer)();
  55 };
  56
  57 /* Similar to the sigaction function in libc, except it leaves alone the
  58    restorer field, which is used to specify the signal stack address */
  59 static inline int wine_sigaction( int sig, struct kernel_sigaction *new,
  60                                       struct kernel_sigaction *old )
  61 {
  62 #ifdef __PIC__
  63     __asm__ __volatile__( "pushl %%ebx\n\t"
  64                           "movl %2,%%ebx\n\t"
  65                           "int $0x80\n\t"
  66                           "popl %%ebx"
  67                           : "=a" (sig)
  68                           : "0" (SYS_sigaction),
  69                             "r" (sig),
  70                             "c" (new),
  71                             "d" (old) );
  72 #else
  73     __asm__ __volatile__( "int $0x80"
  74                           : "=a" (sig)
  75                           : "0" (SYS_sigaction),
  76                             "b" (sig),
  77                             "c" (new),
  78                             "d" (old) );
  79 #endif  /* __PIC__ */
  80     if (sig>=0)
  81         return 0;
  82     errno = -sig;
  83     return -1;
  84 }
  85 #endif /* linux && __i386__ */
  86
  87 /* Signal stack */
  88
  89 static char SIGNAL_Stack[16384];
  90 static sigset_t async_signal_set;
  91
  92 /**********************************************************************
  93  *              SIGNAL_child
  94  *
  95  * wait4 terminated child processes
  96  */
  97 static HANDLER_DEF(SIGNAL_child)
  98 {
  99     HANDLER_INIT();
 100 #ifdef HAVE_WAIT4
 101     wait4( 0, NULL, WNOHANG, NULL);
 102 #elif defined (HAVE_WAITPID)
 103     /* I am sort-of guessing that this is the same as the wait4 call.  */
 104     waitpid (0, NULL, WNOHANG);
 105 #else
 106     wait(NULL);
 107 #endif
 108 }
 109
 110
 111 /**********************************************************************
 112  *              SIGNAL_SetHandler
 113  */
 114 void SIGNAL_SetHandler( int sig, void (*func)(), int flags )
 115 {
 116     int ret;
 117
 118 #if defined(linux) && defined(__i386__)
 119
 120     struct kernel_sigaction sig_act;
 121     sig_act.sa_handler = func;
 122     sig_act.sa_flags   = SA_RESTART | (flags) ? SA_NOMASK : 0;
 123     sig_act.sa_mask    = 0;
 124     /* Point to the top of the stack, minus 4 just in case, and make
 125        it aligned  */
 126     sig_act.sa_restorer =
 127         (void (*)())((int)(SIGNAL_Stack + sizeof(SIGNAL_Stack) - 4) & ~3);
 128     ret = wine_sigaction( sig, &sig_act, NULL );
 129
 130 #else  /* linux && __i386__ */
 131
 132     struct sigaction sig_act;
 133     sig_act.sa_handler = func;
 134     sigemptyset( &sig_act.sa_mask );
 135
 136 # if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
 137     sig_act.sa_flags = SA_ONSTACK;
 138 # elif defined (__svr4__) || defined(_SCO_DS)
 139     sig_act.sa_flags = SA_SIGINFO | SA_ONSTACK | SA_RESTART;
 140 # elif defined(__EMX__)
 141     sig_act.sa_flags = 0; /* FIXME: EMX has only SA_ACK and SA_SYSV */
 142 # else
 143     sig_act.sa_flags = 0;
 144 # endif
 145     ret = sigaction( sig, &sig_act, NULL );
 146
 147 #endif  /* linux && __i386__ */
 148
 149     if (ret < 0)
 150     {
 151         perror( "sigaction" );
 152         exit(1);
 153     }
 154 }
 155
 156 extern void stop_wait(int a);
 157 extern void WINSOCK_sigio(int a);
 158 extern void ASYNC_sigio(int a);
 159
 160
 161 /**********************************************************************
 162  *              SIGNAL_MaskAsyncEvents
 163  */
 164 void SIGNAL_MaskAsyncEvents( BOOL flag )
 165 {
 166   sigprocmask( (flag) ? SIG_BLOCK : SIG_UNBLOCK , &async_signal_set, NULL);
 167 }
 168
 169
 170 /**********************************************************************
 171  *              SIGNAL_Init
 172  */
 173 BOOL SIGNAL_Init(void)
 174 {
 175 #ifdef HAVE_WORKING_SIGALTSTACK
 176     struct sigaltstack ss;
 177     ss.ss_sp    = SIGNAL_Stack;
 178     ss.ss_size  = sizeof(SIGNAL_Stack);
 179     ss.ss_flags = 0;
 180     if (sigaltstack(&ss, NULL) < 0)
 181     {
 182         perror("sigaltstack");
 183         /* fall through on error and try it differently */
 184     }
 185 #endif  /* HAVE_SIGALTSTACK */
 186
 187     sigemptyset(&async_signal_set);
 188
 189     SIGNAL_SetHandler( SIGCHLD, (void (*)())SIGNAL_child, 1);
 190 #ifdef SIGIO
 191     sigaddset(&async_signal_set, SIGIO);
 192 /*    SIGNAL_SetHandler( SIGIO,   (void (*)())WINSOCK_sigio, 0);  */
 193     SIGNAL_SetHandler( SIGIO,   (void (*)())ASYNC_sigio, 0);
 194 #endif
 195     sigaddset(&async_signal_set, SIGALRM);
 196
 197     /* ignore SIGPIPE so that WINSOCK can get a EPIPE error instead  */
 198     signal (SIGPIPE, SIG_IGN);
 199     EXC_InitHandlers();
 200     return TRUE;
 201 }