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

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