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 * 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 * 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 __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__ */
520
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.