loader/signal.c

   1 #ifndef WINELIB
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <signal.h>
   5 #include <string.h>
   6 #include <errno.h>
   7 #include <time.h>
   8 #include <setjmp.h>
   9
  10 #include <sys/time.h>
  11 #include <sys/timeb.h>
  12
  13 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__svr4__) || defined(_SCO_DS)
  14 #ifndef _SCO_DS
  15 #include <sys/syscall.h>
  16 #endif
  17 #include <sys/param.h>
  18 #else
  19 #include <syscall.h>
  20 #endif
  21
  22 #include "debugger.h"
  23 #include "miscemu.h"
  24 #include "registers.h"
  25 #include "win.h"
  26
  27 #if !defined(BSD4_4) || defined(linux) || defined(__FreeBSD__)
  28 char * cstack[4096];
  29 #endif
  30
  31 #ifdef linux
  32 extern void ___sig_restore();
  33 extern void ___masksig_restore();
  34
  35 /* Similar to the sigaction function in libc, except it leaves alone the
  36    restorer field */
  37
  38 static int
  39 wine_sigaction(int sig,struct sigaction * new, struct sigaction * old)
  40 {
  41         __asm__("int $0x80":"=a" (sig)
  42                 :"0" (SYS_sigaction),"b" (sig),"c" (new),"d" (old));
  43         if (sig>=0)
  44                 return 0;
  45         errno = -sig;
  46         return -1;
  47 }
  48 #endif
  49
  50
  51 /**********************************************************************
  52  *              wine_timer
  53  *
  54  * SIGALRM handler.
  55  */
  56 #ifdef linux
  57 static void wine_timer(int signal, struct sigcontext_struct context_struct)
  58 {
  59 #elif defined(__svr4__)
  60 static void wine_timer(int signal, void *siginfo, ucontext_t *context)
  61 {
  62 #else
  63 static void wine_timer(int signal, int code, struct sigcontext *context)
  64 {
  65 #endif
  66     /* Should do real-time timers here */
  67
  68     DOSMEM_Tick();
  69 }
  70
  71
  72 /**********************************************************************
  73  *              SIGNAL_trap
  74  *
  75  * SIGTRAP handler.
  76  */
  77 #ifdef linux
  78 static void SIGNAL_trap(int signal, struct sigcontext_struct context_struct)
  79 {
  80     struct sigcontext_struct *context = &context_struct;
  81 #elif defined(__svr4__) || defined(_SCO_DS)
  82 static void SIGNAL_trap(int signal, void *siginfo, ucontext_t *context)
  83 {
  84 #else
  85 static void SIGNAL_trap(int signal, int code, struct sigcontext *context)
  86 {
  87 #endif
  88     wine_debug( signal, context );  /* Enter our debugger */
  89 }
  90
  91
  92 /**********************************************************************
  93  *              SIGNAL_fault
  94  *
  95  * Segfault handler.
  96  */
  97 #ifdef linux
  98 static void SIGNAL_fault(int signal, struct sigcontext_struct context_struct)
  99 {
 100     struct sigcontext_struct *context = &context_struct;
 101 #elif defined(__svr4__) || defined(_SCO_DS)
 102 static void SIGNAL_fault(int signal, void *siginfo, ucontext_t *context)
 103 {
 104 #else
 105 static void SIGNAL_fault(int signal, int code, struct sigcontext *context)
 106 {
 107 #endif
 108     if (CS_reg(context) == WINE_CODE_SELECTOR)
 109     {
 110         fprintf( stderr, "Segmentation fault in Wine program (%x:%lx)."
 111                          "  Please debug.\n",
 112                  CS_reg(context), EIP_reg(context) );
 113     }
 114     else
 115     {
 116         if (INSTR_EmulateInstruction( context )) return;
 117         fprintf( stderr, "Segmentation fault in Windows program %x:%lx.\n",
 118                  CS_reg(context), EIP_reg(context) );
 119     }
 120     wine_debug( signal, context );
 121 }
 122
 123
 124 /**********************************************************************
 125  *              SIGNAL_SetHandler
 126  */
 127 static void SIGNAL_SetHandler( int sig, void (*func)() )
 128 {
 129     int ret;
 130     struct sigaction sig_act;
 131
 132 #ifdef linux
 133     sig_act.sa_handler = func;
 134     sig_act.sa_flags = SA_RESTART | SA_NOMASK;
 135     /* Point to the top of the stack, minus 4 just in case, and make
 136        it aligned  */
 137     sig_act.sa_restorer =
 138         (void (*)()) (((unsigned int)(cstack) + sizeof(cstack) - 4) & ~3);
 139     ret = wine_sigaction( sig, &sig_act, NULL );
 140 #endif  /* linux */
 141
 142 #if defined(__NetBSD__) || defined(__FreeBSD__)
 143     sigset_t sig_mask;
 144     sigemptyset(&sig_mask);
 145     sig_act.sa_handler = func;
 146     sig_act.sa_flags = SA_ONSTACK;
 147     sig_act.sa_mask = sig_mask;
 148     ret = sigaction( sig, &sig_act, NULL );
 149 #endif  /* __FreeBSD__ || __NetBSD__ */
 150
 151 #if defined (__svr4__) || defined(_SCO_DS)
 152     sigset_t sig_mask;
 153     sigemptyset(&sig_mask);
 154     sig_act.sa_handler = func;
 155     sig_act.sa_flags = SA_ONSTACK | SA_SIGINFO;
 156     sig_act.sa_mask = sig_mask;
 157     ret = sigaction( sig, &sig_act, NULL );
 158 #endif  /* __svr4__ || _SCO_DS */
 159
 160     if (ret < 0)
 161     {
 162         perror( "sigaction" );
 163         exit(1);
 164     }
 165 }
 166
 167 extern void stop_wait(int a);
 168
 169
 170 /**********************************************************************
 171  *              init_wine_signals
 172  */
 173 void init_wine_signals(void)
 174 {
 175 #if defined(__NetBSD__) || defined(__FreeBSD__)
 176     struct sigaltstack ss;
 177
 178     if ((ss.ss_sp = malloc(MINSIGSTKSZ)) == NULL) {
 179         fprintf(stderr, "Unable to allocate signal stack (%d bytes)\n",
 180                 MINSIGSTKSZ);
 181         exit(1);
 182     }
 183     ss.ss_size = MINSIGSTKSZ;
 184     ss.ss_flags = 0;
 185     if (sigaltstack(&ss, NULL) < 0) {
 186         perror("sigstack");
 187         exit(1);
 188     }
 189 #endif  /* __FreeBSD__ || __NetBSD__ */
 190
 191 #if defined (__svr4__) || defined(_SCO_DS)
 192     struct sigaltstack ss;
 193
 194     if ((ss.ss_sp = malloc(SIGSTKSZ) ) == NULL) {
 195         fprintf(stderr, "Unable to allocate signal stack (%d bytes)\n",
 196                 SIGSTKSZ);
 197         exit(1);
 198     }
 199     ss.ss_size = SIGSTKSZ;
 200     ss.ss_flags = 0;
 201     if (sigaltstack(&ss, NULL) < 0) {
 202         perror("sigstack");
 203         exit(1);
 204     }
 205 #endif  /* __svr4__ || _SCO_DS */
 206
 207     SIGNAL_SetHandler( SIGALRM, (void (*)())wine_timer );
 208     SIGNAL_SetHandler( SIGSEGV, (void (*)())SIGNAL_fault );
 209     SIGNAL_SetHandler( SIGILL,  (void (*)())SIGNAL_fault );
 210     SIGNAL_SetHandler( SIGFPE,  (void (*)())SIGNAL_fault );
 211     SIGNAL_SetHandler( SIGTRAP, (void (*)())SIGNAL_trap ); /* debugger */
 212     SIGNAL_SetHandler( SIGHUP,  (void (*)())SIGNAL_trap ); /* forced break */
 213 #ifdef SIGBUS
 214     SIGNAL_SetHandler( SIGBUS,  (void (*)())SIGNAL_fault );
 215 #endif
 216 #ifdef CONFIG_IPC
 217     SIGNAL_SetHandler( SIGUSR2, (void (*)())stop_wait ); /* For IPC */
 218 #endif
 219 }
 220
 221
 222 /**********************************************************************
 223  *              SIGNAL_StartBIOSTimer
 224  *
 225  * Start the BIOS tick timer.
 226  */
 227 void SIGNAL_StartBIOSTimer(void)
 228 {
 229     struct itimerval vt_timer;
 230     static int timer_started = 0;
 231
 232     if (timer_started) return;
 233     timer_started = 1;
 234     vt_timer.it_interval.tv_sec = 0;
 235     vt_timer.it_interval.tv_usec = 54929;
 236     vt_timer.it_value = vt_timer.it_interval;
 237
 238     setitimer(ITIMER_REAL, &vt_timer, NULL);
 239 }
 240
 241 #endif /* ifndef WINELIB */