git.oblomov.eu Git - wine/blob - dlls/ntdll/signal_sparc.c

   1 /*
   2  * Sparc signal handling routines
   3  *
   4  * Copyright 1999 Ulrich Weigand
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #ifdef __sparc__
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <assert.h>
  27 #include <signal.h>
  28 #include <stdlib.h>
  29 #ifdef HAVE_UNISTD_H
  30 # include <unistd.h>
  31 #endif
  32 #include <stdarg.h>
  33 #include <stdio.h>
  34 #include <sys/ucontext.h>
  35
  36 #include "windef.h"
  37 #include "winternl.h"
  38 #include "winnt.h"
  39
  40 #include "wine/exception.h"
  41 #include "ntdll_misc.h"
  42
  43 #include "wine/debug.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(seh);
  46
  47 #define HANDLER_DEF(name) void name( int __signal, struct siginfo *__siginfo, ucontext_t *__context )
  48 #define HANDLER_CONTEXT (__context)
  49
  50 typedef int (*wine_signal_handler)(unsigned int sig);
  51
  52 static wine_signal_handler handlers[256];
  53
  54 /***********************************************************************
  55  *           dispatch_signal
  56  */
  57 static inline int dispatch_signal(unsigned int sig)
  58 {
  59     if (handlers[sig] == NULL) return 0;
  60     return handlers[sig](sig);
  61 }
  62
  63
  64 /*
  65  * FIXME:  All this works only on Solaris for now
  66  */
  67
  68 /**********************************************************************
  69  *              save_context
  70  */
  71 static void save_context( CONTEXT *context, ucontext_t *ucontext )
  72 {
  73     /* Special registers */
  74     context->psr = ucontext->uc_mcontext.gregs[REG_PSR];
  75     context->pc  = ucontext->uc_mcontext.gregs[REG_PC];
  76     context->npc = ucontext->uc_mcontext.gregs[REG_nPC];
  77     context->y   = ucontext->uc_mcontext.gregs[REG_Y];
  78     context->wim = 0;  /* FIXME */
  79     context->tbr = 0;  /* FIXME */
  80
  81     /* Global registers */
  82     context->g0 = 0;  /* always */
  83     context->g1 = ucontext->uc_mcontext.gregs[REG_G1];
  84     context->g2 = ucontext->uc_mcontext.gregs[REG_G2];
  85     context->g3 = ucontext->uc_mcontext.gregs[REG_G3];
  86     context->g4 = ucontext->uc_mcontext.gregs[REG_G4];
  87     context->g5 = ucontext->uc_mcontext.gregs[REG_G5];
  88     context->g6 = ucontext->uc_mcontext.gregs[REG_G6];
  89     context->g7 = ucontext->uc_mcontext.gregs[REG_G7];
  90
  91     /* Current 'out' registers */
  92     context->o0 = ucontext->uc_mcontext.gregs[REG_O0];
  93     context->o1 = ucontext->uc_mcontext.gregs[REG_O1];
  94     context->o2 = ucontext->uc_mcontext.gregs[REG_O2];
  95     context->o3 = ucontext->uc_mcontext.gregs[REG_O3];
  96     context->o4 = ucontext->uc_mcontext.gregs[REG_O4];
  97     context->o5 = ucontext->uc_mcontext.gregs[REG_O5];
  98     context->o6 = ucontext->uc_mcontext.gregs[REG_O6];
  99     context->o7 = ucontext->uc_mcontext.gregs[REG_O7];
 100
 101     /* FIXME: what if the current register window isn't saved? */
 102     if ( ucontext->uc_mcontext.gwins && ucontext->uc_mcontext.gwins->wbcnt > 0 )
 103     {
 104         /* Current 'local' registers from first register window */
 105         context->l0 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[0];
 106         context->l1 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[1];
 107         context->l2 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[2];
 108         context->l3 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[3];
 109         context->l4 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[4];
 110         context->l5 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[5];
 111         context->l6 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[6];
 112         context->l7 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[7];
 113
 114         /* Current 'in' registers from first register window */
 115         context->i0 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[0];
 116         context->i1 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[1];
 117         context->i2 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[2];
 118         context->i3 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[3];
 119         context->i4 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[4];
 120         context->i5 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[5];
 121         context->i6 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[6];
 122         context->i7 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[7];
 123     }
 124 }
 125
 126 /**********************************************************************
 127  *              restore_context
 128  */
 129 static void restore_context( CONTEXT *context, ucontext_t *ucontext )
 130 {
 131    /* FIXME */
 132 }
 133
 134 /**********************************************************************
 135  *              save_fpu
 136  */
 137 static void save_fpu( CONTEXT *context, ucontext_t *ucontext )
 138 {
 139    /* FIXME */
 140 }
 141
 142 /**********************************************************************
 143  *              restore_fpu
 144  */
 145 static void restore_fpu( CONTEXT *context, ucontext_t *ucontext )
 146 {
 147    /* FIXME */
 148 }
 149
 150
 151 /***********************************************************************
 152  *              RtlCaptureContext (NTDLL.@)
 153  */
 154 void WINAPI RtlCaptureContext( CONTEXT *context )
 155 {
 156     FIXME("not implemented\n");
 157     memset( context, 0, sizeof(*context) );
 158 }
 159
 160
 161 /***********************************************************************
 162  *           set_cpu_context
 163  *
 164  * Set the new CPU context.
 165  */
 166 void set_cpu_context( const CONTEXT *context )
 167 {
 168     FIXME("not implemented\n");
 169 }
 170
 171
 172 /**********************************************************************
 173  *              segv_handler
 174  *
 175  * Handler for SIGSEGV.
 176  */
 177 static void segv_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 178 {
 179     EXCEPTION_RECORD rec;
 180     CONTEXT context;
 181
 182     rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
 183
 184     /* we want the page-fault case to be fast */
 185     if ( info->si_code == SEGV_ACCERR )
 186         if (!(rec.ExceptionCode = virtual_handle_fault( info->si_addr, 0 ))) return;
 187
 188     save_context( &context, ucontext );
 189     rec.ExceptionRecord  = NULL;
 190     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 191     rec.ExceptionAddress = (LPVOID)context.pc;
 192     rec.NumberParameters = 2;
 193     rec.ExceptionInformation[0] = 0;  /* FIXME: read/write access ? */
 194     rec.ExceptionInformation[1] = (ULONG_PTR)info->si_addr;
 195
 196     __regs_RtlRaiseException( &rec, &context );
 197     restore_context( &context, ucontext );
 198 }
 199
 200 /**********************************************************************
 201  *              bus_handler
 202  *
 203  * Handler for SIGBUS.
 204  */
 205 static void bus_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 206 {
 207     EXCEPTION_RECORD rec;
 208     CONTEXT context;
 209
 210     save_context( &context, ucontext );
 211     rec.ExceptionRecord  = NULL;
 212     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 213     rec.ExceptionAddress = (LPVOID)context.pc;
 214     rec.NumberParameters = 0;
 215
 216     if ( info->si_code == BUS_ADRALN )
 217         rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
 218     else
 219         rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
 220
 221     __regs_RtlRaiseException( &rec, &context );
 222     restore_context( &context, ucontext );
 223 }
 224
 225 /**********************************************************************
 226  *              ill_handler
 227  *
 228  * Handler for SIGILL.
 229  */
 230 static void ill_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 231 {
 232     EXCEPTION_RECORD rec;
 233     CONTEXT context;
 234
 235     switch ( info->si_code )
 236     {
 237     default:
 238     case ILL_ILLOPC:
 239     case ILL_ILLOPN:
 240     case ILL_ILLADR:
 241     case ILL_ILLTRP:
 242         rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
 243         break;
 244
 245     case ILL_PRVOPC:
 246     case ILL_PRVREG:
 247         rec.ExceptionCode = EXCEPTION_PRIV_INSTRUCTION;
 248         break;
 249
 250     case ILL_BADSTK:
 251         rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
 252         break;
 253     }
 254
 255     save_context( &context, ucontext );
 256     rec.ExceptionRecord  = NULL;
 257     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 258     rec.ExceptionAddress = (LPVOID)context.pc;
 259     rec.NumberParameters = 0;
 260     __regs_RtlRaiseException( &rec, &context );
 261     restore_context( &context, ucontext );
 262 }
 263
 264
 265 /**********************************************************************
 266  *              trap_handler
 267  *
 268  * Handler for SIGTRAP.
 269  */
 270 static void trap_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 271 {
 272     EXCEPTION_RECORD rec;
 273     CONTEXT context;
 274
 275     switch ( info->si_code )
 276     {
 277     case TRAP_TRACE:
 278         rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
 279         break;
 280     case TRAP_BRKPT:
 281     default:
 282         rec.ExceptionCode = EXCEPTION_BREAKPOINT;
 283         break;
 284     }
 285
 286     save_context( &context, ucontext );
 287     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 288     rec.ExceptionRecord  = NULL;
 289     rec.ExceptionAddress = (LPVOID)context.pc;
 290     rec.NumberParameters = 0;
 291     __regs_RtlRaiseException( &rec, &context );
 292     restore_context( &context, ucontext );
 293 }
 294
 295
 296 /**********************************************************************
 297  *              fpe_handler
 298  *
 299  * Handler for SIGFPE.
 300  */
 301 static void fpe_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 302 {
 303     EXCEPTION_RECORD rec;
 304     CONTEXT context;
 305
 306     switch ( info->si_code )
 307     {
 308     case FPE_FLTSUB:
 309         rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
 310         break;
 311     case FPE_INTDIV:
 312         rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
 313         break;
 314     case FPE_INTOVF:
 315         rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
 316         break;
 317     case FPE_FLTDIV:
 318         rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
 319         break;
 320     case FPE_FLTOVF:
 321         rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
 322         break;
 323     case FPE_FLTUND:
 324         rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
 325         break;
 326     case FPE_FLTRES:
 327         rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
 328         break;
 329     case FPE_FLTINV:
 330     default:
 331         rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
 332         break;
 333     }
 334
 335     save_context( &context, ucontext );
 336     save_fpu( &context, ucontext );
 337     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 338     rec.ExceptionRecord  = NULL;
 339     rec.ExceptionAddress = (LPVOID)context.pc;
 340     rec.NumberParameters = 0;
 341     __regs_RtlRaiseException( &rec, &context );
 342     restore_context( &context, ucontext );
 343     restore_fpu( &context, ucontext );
 344 }
 345
 346
 347 /**********************************************************************
 348  *              int_handler
 349  *
 350  * Handler for SIGINT.
 351  */
 352 static void int_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 353 {
 354     if (!dispatch_signal(SIGINT))
 355     {
 356         EXCEPTION_RECORD rec;
 357         CONTEXT context;
 358
 359         save_context( &context, ucontext );
 360         rec.ExceptionCode    = CONTROL_C_EXIT;
 361         rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 362         rec.ExceptionRecord  = NULL;
 363         rec.ExceptionAddress = (LPVOID)context.pc;
 364         rec.NumberParameters = 0;
 365         __regs_RtlRaiseException( &rec, &context );
 366         restore_context( &context, ucontext );
 367     }
 368 }
 369
 370 /**********************************************************************
 371  *              abrt_handler
 372  *
 373  * Handler for SIGABRT.
 374  */
 375 static HANDLER_DEF(abrt_handler)
 376 {
 377     EXCEPTION_RECORD rec;
 378     CONTEXT context;
 379
 380     save_context( &context, HANDLER_CONTEXT );
 381     rec.ExceptionCode    = EXCEPTION_WINE_ASSERTION;
 382     rec.ExceptionFlags   = EH_NONCONTINUABLE;
 383     rec.ExceptionRecord  = NULL;
 384     rec.ExceptionAddress = (LPVOID)context.pc;
 385     rec.NumberParameters = 0;
 386     __regs_RtlRaiseException( &rec, &context ); /* Should never return.. */
 387     restore_context( &context, HANDLER_CONTEXT );
 388 }
 389
 390
 391 /**********************************************************************
 392  *              quit_handler
 393  *
 394  * Handler for SIGQUIT.
 395  */
 396 static HANDLER_DEF(quit_handler)
 397 {
 398     server_abort_thread(0);
 399 }
 400
 401
 402 /**********************************************************************
 403  *              usr1_handler
 404  *
 405  * Handler for SIGUSR1, used to signal a thread that it got suspended.
 406  */
 407 static HANDLER_DEF(usr1_handler)
 408 {
 409     CONTEXT context;
 410
 411     save_context( &context, HANDLER_CONTEXT );
 412     wait_suspend( &context );
 413     restore_context( &context, HANDLER_CONTEXT );
 414 }
 415
 416
 417 /**********************************************************************
 418  *              get_signal_stack_total_size
 419  *
 420  * Retrieve the size to allocate for the signal stack, including the TEB at the bottom.
 421  * Must be a power of two.
 422  */
 423 size_t get_signal_stack_total_size(void)
 424 {
 425     assert( sizeof(TEB) <= getpagesize() );
 426     return getpagesize();  /* this is just for the TEB, we don't need a signal stack */
 427 }
 428
 429
 430 /***********************************************************************
 431  *           set_handler
 432  *
 433  * Set a signal handler
 434  */
 435 static int set_handler( int sig, void (*func)() )
 436 {
 437     struct sigaction sig_act;
 438
 439     sig_act.sa_sigaction = func;
 440     sig_act.sa_mask = server_block_set;
 441     sig_act.sa_flags = SA_SIGINFO;
 442
 443     return sigaction( sig, &sig_act, NULL );
 444 }
 445
 446
 447 /***********************************************************************
 448  *           __wine_set_signal_handler   (NTDLL.@)
 449  */
 450 int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
 451 {
 452     if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1;
 453     if (handlers[sig] != NULL) return -2;
 454     handlers[sig] = wsh;
 455     return 0;
 456 }
 457
 458
 459 /**********************************************************************
 460  *              signal_init_thread
 461  */
 462 void signal_init_thread(void)
 463 {
 464 }
 465
 466 /**********************************************************************
 467  *              signal_init_process
 468  */
 469 void signal_init_process(void)
 470 {
 471     if (set_handler( SIGINT,  (void (*)())int_handler  ) == -1) goto error;
 472     if (set_handler( SIGFPE,  (void (*)())fpe_handler  ) == -1) goto error;
 473     if (set_handler( SIGSEGV, (void (*)())segv_handler ) == -1) goto error;
 474     if (set_handler( SIGILL,  (void (*)())ill_handler  ) == -1) goto error;
 475     if (set_handler( SIGBUS,  (void (*)())bus_handler  ) == -1) goto error;
 476     if (set_handler( SIGTRAP, (void (*)())trap_handler ) == -1) goto error;
 477     if (set_handler( SIGABRT, (void (*)())abrt_handler ) == -1) goto error;
 478     if (set_handler( SIGQUIT, (void (*)())quit_handler ) == -1) goto error;
 479     if (set_handler( SIGUSR1, (void (*)())usr1_handler ) == -1) goto error;
 480     /* 'ta 6' tells the kernel to synthesize any unaligned accesses this
 481        process makes, instead of just signalling an error and terminating
 482        the process.  wine-devel did not reach a conclusion on whether
 483        this is correct, because that is what x86 does, or it is harmful
 484        because it could obscure problems in user code */
 485     asm("ta 6"); /* 6 == ST_FIX_ALIGN defined in sys/trap.h */
 486     signal_init_thread();
 487     return;
 488
 489  error:
 490     perror("sigaction");
 491     exit(1);
 492 }
 493
 494
 495 /**********************************************************************
 496  *              __wine_enter_vm86
 497  */
 498 void __wine_enter_vm86( CONTEXT *context )
 499 {
 500     MESSAGE("vm86 mode not supported on this platform\n");
 501 }
 502
 503 /**********************************************************************
 504  *              DbgBreakPoint   (NTDLL.@)
 505  */
 506 void WINAPI DbgBreakPoint(void)
 507 {
 508      kill(getpid(), SIGTRAP);
 509 }
 510
 511 /**********************************************************************
 512  *              DbgUserBreakPoint   (NTDLL.@)
 513  */
 514 void WINAPI DbgUserBreakPoint(void)
 515 {
 516      kill(getpid(), SIGTRAP);
 517 }
 518
 519 #endif  /* __sparc__ */