ntdll: Make sure to not unmap anything from reserved areas
[wine] / 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 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  *              get_cpu_context
153  *
154  * Get the context of the current thread.
155  */
156 void get_cpu_context( CONTEXT *context )
157 {
158     FIXME("not implemented\n");
159 }
160
161
162 /***********************************************************************
163  *           set_cpu_context
164  *
165  * Set the new CPU context.
166  */
167 void set_cpu_context( const CONTEXT *context )
168 {
169     FIXME("not implemented\n");
170 }
171
172
173 /**********************************************************************
174  *              segv_handler
175  *
176  * Handler for SIGSEGV.
177  */
178 static void segv_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
179 {
180     EXCEPTION_RECORD rec;
181     CONTEXT context;
182
183     /* we want the page-fault case to be fast */
184     if ( info->si_code == SEGV_ACCERR )
185         if (VIRTUAL_HandleFault( (LPVOID)info->si_addr )) return;
186
187     save_context( &context, ucontext );
188     rec.ExceptionCode    = EXCEPTION_ACCESS_VIOLATION;
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  *              term_handler
393  *
394  * Handler for SIGTERM.
395  */
396 static HANDLER_DEF(term_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_handler = NULL;
440     sig_act.sa_sigaction = func;
441     sigemptyset( &sig_act.sa_mask );
442     sig_act.sa_flags = SA_SIGINFO;
443
444     return sigaction( sig, &sig_act, NULL );
445 }
446
447
448 /***********************************************************************
449  *           __wine_set_signal_handler   (NTDLL.@)
450  */
451 int __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
452 {
453     if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1;
454     if (handlers[sig] != NULL) return -2;
455     handlers[sig] = wsh;
456     return 0;
457 }
458
459
460 /**********************************************************************
461  *              SIGNAL_Init
462  */
463 BOOL SIGNAL_Init(void)
464 {
465     if (set_handler( SIGINT,  (void (*)())int_handler  ) == -1) goto error;
466     if (set_handler( SIGFPE,  (void (*)())fpe_handler  ) == -1) goto error;
467     if (set_handler( SIGSEGV, (void (*)())segv_handler ) == -1) goto error;
468     if (set_handler( SIGILL,  (void (*)())ill_handler  ) == -1) goto error;
469     if (set_handler( SIGBUS,  (void (*)())bus_handler  ) == -1) goto error;
470     if (set_handler( SIGTRAP, (void (*)())trap_handler ) == -1) goto error;
471     if (set_handler( SIGABRT, (void (*)())abrt_handler ) == -1) goto error;
472     if (set_handler( SIGTERM, (void (*)())term_handler ) == -1) goto error;
473     if (set_handler( SIGUSR1, (void (*)())usr1_handler ) == -1) goto error;
474     /* 'ta 6' tells the kernel to synthesize any unaligned accesses this 
475        process makes, instead of just signalling an error and terminating
476        the process.  wine-devel did not reach a conclusion on whether
477        this is correct, because that is what x86 does, or it is harmful 
478        because it could obscure problems in user code */
479     asm("ta 6"); /* 6 == ST_FIX_ALIGN defined in sys/trap.h */
480    return TRUE;
481
482  error:
483     perror("sigaction");
484     return FALSE;
485 }
486
487
488 /**********************************************************************
489  *              __wine_enter_vm86
490  */
491 void __wine_enter_vm86( CONTEXT *context )
492 {
493     MESSAGE("vm86 mode not supported on this platform\n");
494 }
495
496 /**********************************************************************
497  *              DbgBreakPoint   (NTDLL.@)
498  */
499 void WINAPI DbgBreakPoint(void)
500 {
501      kill(getpid(), SIGTRAP);
502 }
503
504 /**********************************************************************
505  *              DbgUserBreakPoint   (NTDLL.@)
506  */
507 void WINAPI DbgUserBreakPoint(void)
508 {
509      kill(getpid(), SIGTRAP);
510 }
511
512 #endif  /* __sparc__ */