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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 inline static 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  *              segv_handler
 153  *
 154  * Handler for SIGSEGV.
 155  */
 156 static void segv_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 157 {
 158     EXCEPTION_RECORD rec;
 159     CONTEXT context;
 160
 161     /* we want the page-fault case to be fast */
 162     if ( info->si_code == SEGV_ACCERR )
 163         if (VIRTUAL_HandleFault( (LPVOID)info->si_addr )) return;
 164
 165     save_context( &context, ucontext );
 166     rec.ExceptionCode    = EXCEPTION_ACCESS_VIOLATION;
 167     rec.ExceptionRecord  = NULL;
 168     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 169     rec.ExceptionAddress = (LPVOID)context.pc;
 170     rec.NumberParameters = 2;
 171     rec.ExceptionInformation[0] = 0;  /* FIXME: read/write access ? */
 172     rec.ExceptionInformation[1] = (ULONG_PTR)info->si_addr;
 173
 174     __regs_RtlRaiseException( &rec, &context );
 175     restore_context( &context, ucontext );
 176 }
 177
 178 /**********************************************************************
 179  *              bus_handler
 180  *
 181  * Handler for SIGBUS.
 182  */
 183 static void bus_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 184 {
 185     EXCEPTION_RECORD rec;
 186     CONTEXT context;
 187
 188     save_context( &context, ucontext );
 189     rec.ExceptionRecord  = NULL;
 190     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 191     rec.ExceptionAddress = (LPVOID)context.pc;
 192     rec.NumberParameters = 0;
 193
 194     if ( info->si_code == BUS_ADRALN )
 195         rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
 196     else
 197         rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
 198
 199     __regs_RtlRaiseException( &rec, &context );
 200     restore_context( &context, ucontext );
 201 }
 202
 203 /**********************************************************************
 204  *              ill_handler
 205  *
 206  * Handler for SIGILL.
 207  */
 208 static void ill_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 209 {
 210     EXCEPTION_RECORD rec;
 211     CONTEXT context;
 212
 213     switch ( info->si_code )
 214     {
 215     default:
 216     case ILL_ILLOPC:
 217     case ILL_ILLOPN:
 218     case ILL_ILLADR:
 219     case ILL_ILLTRP:
 220         rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
 221         break;
 222
 223     case ILL_PRVOPC:
 224     case ILL_PRVREG:
 225         rec.ExceptionCode = EXCEPTION_PRIV_INSTRUCTION;
 226         break;
 227
 228     case ILL_BADSTK:
 229         rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
 230         break;
 231     }
 232
 233     save_context( &context, ucontext );
 234     rec.ExceptionRecord  = NULL;
 235     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 236     rec.ExceptionAddress = (LPVOID)context.pc;
 237     rec.NumberParameters = 0;
 238     __regs_RtlRaiseException( &rec, &context );
 239     restore_context( &context, ucontext );
 240 }
 241
 242
 243 /**********************************************************************
 244  *              trap_handler
 245  *
 246  * Handler for SIGTRAP.
 247  */
 248 static void trap_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 249 {
 250     EXCEPTION_RECORD rec;
 251     CONTEXT context;
 252
 253     switch ( info->si_code )
 254     {
 255     case TRAP_TRACE:
 256         rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
 257         break;
 258     case TRAP_BRKPT:
 259     default:
 260         rec.ExceptionCode = EXCEPTION_BREAKPOINT;
 261         break;
 262     }
 263
 264     save_context( &context, ucontext );
 265     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 266     rec.ExceptionRecord  = NULL;
 267     rec.ExceptionAddress = (LPVOID)context.pc;
 268     rec.NumberParameters = 0;
 269     __regs_RtlRaiseException( &rec, &context );
 270     restore_context( &context, ucontext );
 271 }
 272
 273
 274 /**********************************************************************
 275  *              fpe_handler
 276  *
 277  * Handler for SIGFPE.
 278  */
 279 static void fpe_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 280 {
 281     EXCEPTION_RECORD rec;
 282     CONTEXT context;
 283
 284     switch ( info->si_code )
 285     {
 286     case FPE_FLTSUB:
 287         rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
 288         break;
 289     case FPE_INTDIV:
 290         rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
 291         break;
 292     case FPE_INTOVF:
 293         rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
 294         break;
 295     case FPE_FLTDIV:
 296         rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
 297         break;
 298     case FPE_FLTOVF:
 299         rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
 300         break;
 301     case FPE_FLTUND:
 302         rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
 303         break;
 304     case FPE_FLTRES:
 305         rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
 306         break;
 307     case FPE_FLTINV:
 308     default:
 309         rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
 310         break;
 311     }
 312
 313     save_context( &context, ucontext );
 314     save_fpu( &context, ucontext );
 315     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 316     rec.ExceptionRecord  = NULL;
 317     rec.ExceptionAddress = (LPVOID)context.pc;
 318     rec.NumberParameters = 0;
 319     __regs_RtlRaiseException( &rec, &context );
 320     restore_context( &context, ucontext );
 321     restore_fpu( &context, ucontext );
 322 }
 323
 324
 325 /**********************************************************************
 326  *              int_handler
 327  *
 328  * Handler for SIGINT.
 329  */
 330 static void int_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
 331 {
 332     if (!dispatch_signal(SIGINT))
 333     {
 334         EXCEPTION_RECORD rec;
 335         CONTEXT context;
 336
 337         save_context( &context, ucontext );
 338         rec.ExceptionCode    = CONTROL_C_EXIT;
 339         rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 340         rec.ExceptionRecord  = NULL;
 341         rec.ExceptionAddress = (LPVOID)context.pc;
 342         rec.NumberParameters = 0;
 343         __regs_RtlRaiseException( &rec, &context );
 344         restore_context( &context, ucontext );
 345     }
 346 }
 347
 348 /**********************************************************************
 349  *              abrt_handler
 350  *
 351  * Handler for SIGABRT.
 352  */
 353 static HANDLER_DEF(abrt_handler)
 354 {
 355     EXCEPTION_RECORD rec;
 356     CONTEXT context;
 357
 358     save_context( &context, HANDLER_CONTEXT );
 359     rec.ExceptionCode    = EXCEPTION_WINE_ASSERTION;
 360     rec.ExceptionFlags   = EH_NONCONTINUABLE;
 361     rec.ExceptionRecord  = NULL;
 362     rec.ExceptionAddress = (LPVOID)context.pc;
 363     rec.NumberParameters = 0;
 364     __regs_RtlRaiseException( &rec, &context ); /* Should never return.. */
 365     restore_context( &context, HANDLER_CONTEXT );
 366 }
 367
 368
 369 /**********************************************************************
 370  *              term_handler
 371  *
 372  * Handler for SIGTERM.
 373  */
 374 static HANDLER_DEF(term_handler)
 375 {
 376     server_abort_thread(0);
 377 }
 378
 379
 380 /**********************************************************************
 381  *              usr1_handler
 382  *
 383  * Handler for SIGUSR1, used to signal a thread that it got suspended.
 384  */
 385 static HANDLER_DEF(usr1_handler)
 386 {
 387     CONTEXT context;
 388
 389     save_context( &context, HANDLER_CONTEXT );
 390     wait_suspend( &context );
 391     restore_context( &context, HANDLER_CONTEXT );
 392 }
 393
 394
 395 /**********************************************************************
 396  *              get_signal_stack_total_size
 397  *
 398  * Retrieve the size to allocate for the signal stack, including the TEB at the bottom.
 399  * Must be a power of two.
 400  */
 401 size_t get_signal_stack_total_size(void)
 402 {
 403     assert( sizeof(TEB) <= getpagesize() );
 404     return getpagesize();  /* this is just for the TEB, we don't need a signal stack */
 405 }
 406
 407
 408 /***********************************************************************
 409  *           set_handler
 410  *
 411  * Set a signal handler
 412  */
 413 static int set_handler( int sig, void (*func)() )
 414 {
 415     struct sigaction sig_act;
 416
 417     sig_act.sa_handler = NULL;
 418     sig_act.sa_sigaction = func;
 419     sigemptyset( &sig_act.sa_mask );
 420     sig_act.sa_flags = SA_SIGINFO;
 421
 422     return sigaction( sig, &sig_act, NULL );
 423 }
 424
 425
 426 /***********************************************************************
 427  *           __wine_set_signal_handler   (NTDLL.@)
 428  */
 429 int __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
 430 {
 431     if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1;
 432     if (handlers[sig] != NULL) return -2;
 433     handlers[sig] = wsh;
 434     return 0;
 435 }
 436
 437
 438 /**********************************************************************
 439  *              SIGNAL_Init
 440  */
 441 BOOL SIGNAL_Init(void)
 442 {
 443     if (set_handler( SIGINT,  (void (*)())int_handler  ) == -1) goto error;
 444     if (set_handler( SIGFPE,  (void (*)())fpe_handler  ) == -1) goto error;
 445     if (set_handler( SIGSEGV, (void (*)())segv_handler ) == -1) goto error;
 446     if (set_handler( SIGILL,  (void (*)())ill_handler  ) == -1) goto error;
 447     if (set_handler( SIGBUS,  (void (*)())bus_handler  ) == -1) goto error;
 448     if (set_handler( SIGTRAP, (void (*)())trap_handler ) == -1) goto error;
 449     if (set_handler( SIGABRT, (void (*)())abrt_handler ) == -1) goto error;
 450     if (set_handler( SIGTERM, (void (*)())term_handler ) == -1) goto error;
 451     if (set_handler( SIGUSR1, (void (*)())usr1_handler ) == -1) goto error;
 452     /* 'ta 6' tells the kernel to synthesize any unaligned accesses this
 453        process makes, instead of just signalling an error and terminating
 454        the process.  wine-devel did not reach a conclusion on whether
 455        this is correct, because that is what x86 does, or it is harmful
 456        because it could obscure problems in user code */
 457     asm("ta 6"); /* 6 == ST_FIX_ALIGN defined in sys/trap.h */
 458    return TRUE;
 459
 460  error:
 461     perror("sigaction");
 462     return FALSE;
 463 }
 464
 465
 466 /**********************************************************************
 467  *              __wine_enter_vm86
 468  */
 469 void __wine_enter_vm86( CONTEXT *context )
 470 {
 471     MESSAGE("vm86 mode not supported on this platform\n");
 472 }
 473
 474 /**********************************************************************
 475  *              DbgBreakPoint   (NTDLL.@)
 476  */
 477 void WINAPI DbgBreakPoint(void)
 478 {
 479      kill(getpid(), SIGTRAP);
 480 }
 481
 482 /**********************************************************************
 483  *              DbgUserBreakPoint   (NTDLL.@)
 484  */
 485 void WINAPI DbgUserBreakPoint(void)
 486 {
 487      kill(getpid(), SIGTRAP);
 488 }
 489
 490 #endif  /* __sparc__ */