Commit | Line | Data |
---|---|---|
3d06d20b AJ |
1 | /* |
2 | * i386 signal handling routines | |
9a624916 | 3 | * |
3d06d20b | 4 | * Copyright 1999 Alexandre Julliard |
0799c1a7 AJ |
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 | |
3d06d20b AJ |
19 | */ |
20 | ||
21 | #ifdef __i386__ | |
22 | ||
23 | #include "config.h" | |
894b188f | 24 | #include "wine/port.h" |
3d06d20b AJ |
25 | |
26 | #include <errno.h> | |
27 | #include <signal.h> | |
28 | #include <stdlib.h> | |
e37c6e18 | 29 | #include <stdarg.h> |
383da68c | 30 | #include <stdio.h> |
d016f819 PS |
31 | #ifdef HAVE_UNISTD_H |
32 | # include <unistd.h> | |
33 | #endif | |
3d06d20b AJ |
34 | |
35 | #ifdef HAVE_SYS_PARAM_H | |
36 | # include <sys/param.h> | |
37 | #endif | |
38 | #ifdef HAVE_SYSCALL_H | |
39 | # include <syscall.h> | |
40 | #else | |
41 | # ifdef HAVE_SYS_SYSCALL_H | |
42 | # include <sys/syscall.h> | |
43 | # endif | |
44 | #endif | |
45 | ||
45b2c868 AJ |
46 | #ifdef HAVE_SYS_VM86_H |
47 | # include <sys/vm86.h> | |
48 | #endif | |
49 | ||
2af03e45 DP |
50 | #ifdef HAVE_SYS_SIGNAL_H |
51 | # include <sys/signal.h> | |
52 | #endif | |
53 | ||
435e2e63 | 54 | #include "windef.h" |
e37c6e18 AJ |
55 | #include "winbase.h" |
56 | #include "winreg.h" | |
9c1de6de | 57 | #include "winternl.h" |
59008670 | 58 | #include "wine/library.h" |
217fdab7 | 59 | #include "ntdll_misc.h" |
916f9756 | 60 | |
3d06d20b AJ |
61 | /*********************************************************************** |
62 | * signal context platform-specific definitions | |
63 | */ | |
64 | ||
65 | #ifdef linux | |
66 | typedef struct | |
67 | { | |
68 | unsigned short sc_gs, __gsh; | |
69 | unsigned short sc_fs, __fsh; | |
70 | unsigned short sc_es, __esh; | |
71 | unsigned short sc_ds, __dsh; | |
72 | unsigned long sc_edi; | |
73 | unsigned long sc_esi; | |
74 | unsigned long sc_ebp; | |
75 | unsigned long sc_esp; | |
76 | unsigned long sc_ebx; | |
77 | unsigned long sc_edx; | |
78 | unsigned long sc_ecx; | |
79 | unsigned long sc_eax; | |
80 | unsigned long sc_trapno; | |
81 | unsigned long sc_err; | |
82 | unsigned long sc_eip; | |
83 | unsigned short sc_cs, __csh; | |
84 | unsigned long sc_eflags; | |
85 | unsigned long esp_at_signal; | |
86 | unsigned short sc_ss, __ssh; | |
87 | unsigned long i387; | |
88 | unsigned long oldmask; | |
89 | unsigned long cr2; | |
90 | } SIGCONTEXT; | |
91 | ||
92 | #define HANDLER_DEF(name) void name( int __signal, SIGCONTEXT __context ) | |
93 | #define HANDLER_CONTEXT (&__context) | |
94 | ||
95 | /* this is the sigaction structure from the Linux 2.1.20 kernel. */ | |
3d06d20b AJ |
96 | struct kernel_sigaction |
97 | { | |
0045def7 AJ |
98 | void (*ksa_handler)(); |
99 | unsigned long ksa_mask; | |
100 | unsigned long ksa_flags; | |
101 | void *ksa_restorer; | |
3d06d20b AJ |
102 | }; |
103 | ||
104 | /* Similar to the sigaction function in libc, except it leaves alone the | |
105 | restorer field, which is used to specify the signal stack address */ | |
106 | static inline int wine_sigaction( int sig, struct kernel_sigaction *new, | |
107 | struct kernel_sigaction *old ) | |
108 | { | |
109 | __asm__ __volatile__( "pushl %%ebx\n\t" | |
110 | "movl %2,%%ebx\n\t" | |
111 | "int $0x80\n\t" | |
112 | "popl %%ebx" | |
113 | : "=a" (sig) | |
114 | : "0" (SYS_sigaction), "r" (sig), "c" (new), "d" (old) ); | |
115 | if (sig>=0) return 0; | |
116 | errno = -sig; | |
117 | return -1; | |
118 | } | |
119 | ||
0045def7 AJ |
120 | #ifdef HAVE_SIGALTSTACK |
121 | /* direct syscall for sigaltstack to work around glibc 2.0 brain-damage */ | |
122 | static inline int wine_sigaltstack( const struct sigaltstack *new, | |
123 | struct sigaltstack *old ) | |
124 | { | |
125 | int ret; | |
126 | __asm__ __volatile__( "pushl %%ebx\n\t" | |
127 | "movl %2,%%ebx\n\t" | |
128 | "int $0x80\n\t" | |
129 | "popl %%ebx" | |
130 | : "=a" (ret) | |
131 | : "0" (SYS_sigaltstack), "r" (new), "c" (old) ); | |
132 | if (ret >= 0) return 0; | |
133 | errno = -ret; | |
134 | return -1; | |
135 | } | |
136 | #endif | |
137 | ||
4eb0bebd OK |
138 | #define VM86_EAX 0 /* the %eax value while vm86_enter is executing */ |
139 | ||
140 | int vm86_enter( void **vm86_ptr ); | |
141 | void vm86_return(void); | |
142 | void vm86_return_end(void); | |
b59627c8 AJ |
143 | __ASM_GLOBAL_FUNC(vm86_enter, |
144 | "pushl %ebp\n\t" | |
145 | "movl %esp, %ebp\n\t" | |
146 | "movl $166,%eax\n\t" /*SYS_vm86*/ | |
4eb0bebd OK |
147 | "movl 8(%ebp),%ecx\n\t" /* vm86_ptr */ |
148 | "movl (%ecx),%ecx\n\t" | |
b59627c8 AJ |
149 | "pushl %ebx\n\t" |
150 | "movl $1,%ebx\n\t" /*VM86_ENTER*/ | |
151 | "pushl %ecx\n\t" /* put vm86plus_struct ptr somewhere we can find it */ | |
0b6c6e76 | 152 | "pushl %fs\n\t" |
063cff86 | 153 | "pushl %gs\n\t" |
b59627c8 AJ |
154 | "int $0x80\n" |
155 | ".globl " __ASM_NAME("vm86_return") "\n\t" | |
65c6d385 | 156 | __ASM_FUNC("vm86_return") "\n" |
b59627c8 | 157 | __ASM_NAME("vm86_return") ":\n\t" |
78675ba2 | 158 | "popl %gs\n\t" |
063cff86 | 159 | "popl %fs\n\t" |
b59627c8 AJ |
160 | "popl %ecx\n\t" |
161 | "popl %ebx\n\t" | |
b59627c8 | 162 | "popl %ebp\n\t" |
4eb0bebd OK |
163 | "testl %eax,%eax\n\t" |
164 | "jl 0f\n\t" | |
165 | "cmpb $0,%al\n\t" /* VM86_SIGNAL */ | |
166 | "je " __ASM_NAME("vm86_enter") "\n\t" | |
167 | "0:\n\t" | |
168 | "movl 4(%esp),%ecx\n\t" /* vm86_ptr */ | |
169 | "movl $0,(%ecx)\n\t" | |
170 | ".globl " __ASM_NAME("vm86_return_end") "\n\t" | |
65c6d385 | 171 | __ASM_FUNC("vm86_return_end") "\n" |
4eb0bebd | 172 | __ASM_NAME("vm86_return_end") ":\n\t" |
b59627c8 | 173 | "ret" ); |
45b2c868 | 174 | |
727c31d7 MM |
175 | #ifdef HAVE_SYS_VM86_H |
176 | # define __HAVE_VM86 | |
177 | #endif | |
7f862cb2 | 178 | |
3d06d20b AJ |
179 | #endif /* linux */ |
180 | ||
181 | #ifdef BSDI | |
182 | ||
183 | #define EAX_sig(context) ((context)->tf_eax) | |
184 | #define EBX_sig(context) ((context)->tf_ebx) | |
185 | #define ECX_sig(context) ((context)->tf_ecx) | |
186 | #define EDX_sig(context) ((context)->tf_edx) | |
187 | #define ESI_sig(context) ((context)->tf_esi) | |
188 | #define EDI_sig(context) ((context)->tf_edi) | |
189 | #define EBP_sig(context) ((context)->tf_ebp) | |
9a624916 | 190 | |
3d06d20b AJ |
191 | #define CS_sig(context) ((context)->tf_cs) |
192 | #define DS_sig(context) ((context)->tf_ds) | |
193 | #define ES_sig(context) ((context)->tf_es) | |
194 | #define SS_sig(context) ((context)->tf_ss) | |
195 | ||
196 | #include <machine/frame.h> | |
197 | typedef struct trapframe SIGCONTEXT; | |
198 | ||
199 | #define HANDLER_DEF(name) void name( int __signal, int code, SIGCONTEXT *__context ) | |
200 | #define HANDLER_CONTEXT __context | |
201 | ||
202 | #define EFL_sig(context) ((context)->tf_eflags) | |
203 | ||
204 | #define EIP_sig(context) (*((unsigned long*)&(context)->tf_eip)) | |
205 | #define ESP_sig(context) (*((unsigned long*)&(context)->tf_esp)) | |
206 | ||
207 | #endif /* bsdi */ | |
208 | ||
209 | #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) | |
210 | ||
3d06d20b AJ |
211 | typedef struct sigcontext SIGCONTEXT; |
212 | ||
213 | #define HANDLER_DEF(name) void name( int __signal, int code, SIGCONTEXT *__context ) | |
214 | #define HANDLER_CONTEXT __context | |
215 | ||
216 | #endif /* FreeBSD */ | |
217 | ||
218 | #if defined(__svr4__) || defined(_SCO_DS) || defined(__sun) | |
219 | ||
3d06d20b AJ |
220 | #ifdef _SCO_DS |
221 | #include <sys/regset.h> | |
222 | #endif | |
223 | /* Solaris kludge */ | |
224 | #undef ERR | |
225 | #include <sys/ucontext.h> | |
226 | #undef ERR | |
227 | typedef struct ucontext SIGCONTEXT; | |
228 | ||
8b39cea3 | 229 | #define HANDLER_DEF(name) void name( int __signal, siginfo_t *__siginfo, SIGCONTEXT *__context ) |
3d06d20b AJ |
230 | #define HANDLER_CONTEXT __context |
231 | ||
232 | #endif /* svr4 || SCO_DS */ | |
233 | ||
234 | #ifdef __EMX__ | |
235 | ||
236 | typedef struct | |
237 | { | |
238 | unsigned long ContextFlags; | |
239 | FLOATING_SAVE_AREA sc_float; | |
240 | unsigned long sc_gs; | |
241 | unsigned long sc_fs; | |
242 | unsigned long sc_es; | |
243 | unsigned long sc_ds; | |
244 | unsigned long sc_edi; | |
245 | unsigned long sc_esi; | |
246 | unsigned long sc_eax; | |
247 | unsigned long sc_ebx; | |
248 | unsigned long sc_ecx; | |
249 | unsigned long sc_edx; | |
250 | unsigned long sc_ebp; | |
251 | unsigned long sc_eip; | |
252 | unsigned long sc_cs; | |
253 | unsigned long sc_eflags; | |
254 | unsigned long sc_esp; | |
255 | unsigned long sc_ss; | |
256 | } SIGCONTEXT; | |
257 | ||
258 | #endif /* __EMX__ */ | |
259 | ||
ac81d02a | 260 | #ifdef __CYGWIN__ |
3d06d20b | 261 | |
ac81d02a RK |
262 | /* FIXME: This section is just here so it can compile, it's most likely |
263 | * completely wrong. */ | |
264 | ||
265 | typedef struct | |
266 | { | |
267 | unsigned short sc_gs, __gsh; | |
268 | unsigned short sc_fs, __fsh; | |
269 | unsigned short sc_es, __esh; | |
270 | unsigned short sc_ds, __dsh; | |
271 | unsigned long sc_edi; | |
272 | unsigned long sc_esi; | |
273 | unsigned long sc_ebp; | |
274 | unsigned long sc_esp; | |
275 | unsigned long sc_ebx; | |
276 | unsigned long sc_edx; | |
277 | unsigned long sc_ecx; | |
278 | unsigned long sc_eax; | |
279 | unsigned long sc_trapno; | |
280 | unsigned long sc_err; | |
281 | unsigned long sc_eip; | |
282 | unsigned short sc_cs, __csh; | |
283 | unsigned long sc_eflags; | |
284 | unsigned long esp_at_signal; | |
285 | unsigned short sc_ss, __ssh; | |
286 | unsigned long i387; | |
287 | unsigned long oldmask; | |
288 | unsigned long cr2; | |
289 | } SIGCONTEXT; | |
290 | ||
291 | #define HANDLER_DEF(name) void name( int __signal, SIGCONTEXT __context ) | |
292 | #define HANDLER_CONTEXT (&__context) | |
293 | ||
294 | #endif /* __CYGWIN__ */ | |
295 | ||
296 | #if defined(linux) || defined(__NetBSD__) || defined(__FreeBSD__) ||\ | |
297 | defined(__OpenBSD__) || defined(__EMX__) || defined(__CYGWIN__) | |
3d06d20b AJ |
298 | |
299 | #define EAX_sig(context) ((context)->sc_eax) | |
300 | #define EBX_sig(context) ((context)->sc_ebx) | |
301 | #define ECX_sig(context) ((context)->sc_ecx) | |
302 | #define EDX_sig(context) ((context)->sc_edx) | |
303 | #define ESI_sig(context) ((context)->sc_esi) | |
304 | #define EDI_sig(context) ((context)->sc_edi) | |
305 | #define EBP_sig(context) ((context)->sc_ebp) | |
9a624916 | 306 | |
3d06d20b AJ |
307 | #define CS_sig(context) ((context)->sc_cs) |
308 | #define DS_sig(context) ((context)->sc_ds) | |
309 | #define ES_sig(context) ((context)->sc_es) | |
ba6d54a4 JL |
310 | #define FS_sig(context) ((context)->sc_fs) |
311 | #define GS_sig(context) ((context)->sc_gs) | |
14251f1b YH |
312 | #define SS_sig(context) ((context)->sc_ss) |
313 | ||
314 | #define TRAP_sig(context) ((context)->sc_trapno) | |
315 | ||
316 | #ifdef __NetBSD__ | |
317 | #define ERROR_sig(context) ((context)->sc_err) | |
ba6d54a4 JL |
318 | #endif |
319 | ||
320 | #ifdef linux | |
3d06d20b AJ |
321 | #define ERROR_sig(context) ((context)->sc_err) |
322 | #define FPU_sig(context) ((FLOATING_SAVE_AREA*)((context)->i387)) | |
ebe67a28 | 323 | #define FAULT_ADDRESS ((void *)HANDLER_CONTEXT->cr2) |
3d06d20b AJ |
324 | #endif |
325 | ||
14251f1b | 326 | #ifdef __FreeBSD__ |
3d06d20b AJ |
327 | #define EFL_sig(context) ((context)->sc_efl) |
328 | /* FreeBSD, see i386/i386/traps.c::trap_pfault va->err kludge */ | |
ebe67a28 | 329 | #define FAULT_ADDRESS ((void *)HANDLER_CONTEXT->sc_err) |
14251f1b YH |
330 | #else |
331 | #define EFL_sig(context) ((context)->sc_eflags) | |
9a624916 | 332 | #endif |
3d06d20b AJ |
333 | |
334 | #define EIP_sig(context) (*((unsigned long*)&(context)->sc_eip)) | |
335 | #define ESP_sig(context) (*((unsigned long*)&(context)->sc_esp)) | |
336 | ||
337 | #endif /* linux || __NetBSD__ || __FreeBSD__ || __OpenBSD__ */ | |
338 | ||
339 | #if defined(__svr4__) || defined(_SCO_DS) || defined(__sun) | |
340 | ||
341 | #ifdef _SCO_DS | |
342 | #define gregs regs | |
343 | #endif | |
344 | ||
345 | #define EAX_sig(context) ((context)->uc_mcontext.gregs[EAX]) | |
346 | #define EBX_sig(context) ((context)->uc_mcontext.gregs[EBX]) | |
347 | #define ECX_sig(context) ((context)->uc_mcontext.gregs[ECX]) | |
348 | #define EDX_sig(context) ((context)->uc_mcontext.gregs[EDX]) | |
349 | #define ESI_sig(context) ((context)->uc_mcontext.gregs[ESI]) | |
350 | #define EDI_sig(context) ((context)->uc_mcontext.gregs[EDI]) | |
351 | #define EBP_sig(context) ((context)->uc_mcontext.gregs[EBP]) | |
9a624916 | 352 | |
3d06d20b AJ |
353 | #define CS_sig(context) ((context)->uc_mcontext.gregs[CS]) |
354 | #define DS_sig(context) ((context)->uc_mcontext.gregs[DS]) | |
355 | #define ES_sig(context) ((context)->uc_mcontext.gregs[ES]) | |
356 | #define SS_sig(context) ((context)->uc_mcontext.gregs[SS]) | |
9a624916 | 357 | |
3d06d20b AJ |
358 | #define FS_sig(context) ((context)->uc_mcontext.gregs[FS]) |
359 | #define GS_sig(context) ((context)->uc_mcontext.gregs[GS]) | |
360 | ||
361 | #define EFL_sig(context) ((context)->uc_mcontext.gregs[EFL]) | |
9a624916 | 362 | |
3d06d20b | 363 | #define EIP_sig(context) ((context)->uc_mcontext.gregs[EIP]) |
93be5374 RL |
364 | #ifdef UESP |
365 | #define ESP_sig(context) ((context)->uc_mcontext.gregs[UESP]) | |
366 | #elif defined(R_ESP) | |
3d06d20b AJ |
367 | #define ESP_sig(context) ((context)->uc_mcontext.gregs[R_ESP]) |
368 | #else | |
369 | #define ESP_sig(context) ((context)->uc_mcontext.gregs[ESP]) | |
370 | #endif | |
371 | #ifdef TRAPNO | |
372 | #define TRAP_sig(context) ((context)->uc_mcontext.gregs[TRAPNO]) | |
373 | #endif | |
374 | ||
ebe67a28 AJ |
375 | #define FAULT_ADDRESS (__siginfo->si_addr) |
376 | ||
3d06d20b | 377 | #endif /* svr4 || SCO_DS */ |
de5e1af2 AJ |
378 | |
379 | ||
284a78f5 BJY |
380 | /* exception code definitions (already defined by FreeBSD/NetBSD) */ |
381 | #if !defined(__FreeBSD__) && !defined(__NetBSD__) /* FIXME: other BSDs? */ | |
de5e1af2 AJ |
382 | #define T_DIVIDE 0 /* Division by zero exception */ |
383 | #define T_TRCTRAP 1 /* Single-step exception */ | |
384 | #define T_NMI 2 /* NMI interrupt */ | |
385 | #define T_BPTFLT 3 /* Breakpoint exception */ | |
386 | #define T_OFLOW 4 /* Overflow exception */ | |
387 | #define T_BOUND 5 /* Bound range exception */ | |
388 | #define T_PRIVINFLT 6 /* Invalid opcode exception */ | |
389 | #define T_DNA 7 /* Device not available exception */ | |
390 | #define T_DOUBLEFLT 8 /* Double fault exception */ | |
391 | #define T_FPOPFLT 9 /* Coprocessor segment overrun */ | |
392 | #define T_TSSFLT 10 /* Invalid TSS exception */ | |
393 | #define T_SEGNPFLT 11 /* Segment not present exception */ | |
394 | #define T_STKFLT 12 /* Stack fault */ | |
395 | #define T_PROTFLT 13 /* General protection fault */ | |
396 | #define T_PAGEFLT 14 /* Page fault */ | |
397 | #define T_RESERVED 15 /* Unknown exception */ | |
398 | #define T_ARITHTRAP 16 /* Floating point exception */ | |
399 | #define T_ALIGNFLT 17 /* Alignment check exception */ | |
400 | #define T_MCHK 18 /* Machine check exception */ | |
401 | #define T_CACHEFLT 19 /* Cache flush exception */ | |
402 | #endif | |
284a78f5 BJY |
403 | #if defined(__NetBSD__) |
404 | #define T_MCHK 19 /* Machine check exception */ | |
405 | #endif | |
de5e1af2 AJ |
406 | |
407 | #define T_UNKNOWN (-1) /* Unknown fault (TRAP_sig not defined) */ | |
3d06d20b | 408 | |
eb94c7d2 | 409 | #include "wine/exception.h" |
0799c1a7 | 410 | #include "wine/debug.h" |
282b13bc | 411 | |
0799c1a7 | 412 | WINE_DEFAULT_DEBUG_CHANNEL(seh); |
282b13bc | 413 | |
4325554a | 414 | typedef int (*wine_signal_handler)(unsigned int sig); |
3d4d7e01 EP |
415 | |
416 | static wine_signal_handler handlers[256]; | |
417 | ||
b4a4c05a | 418 | extern void WINAPI EXC_RtlRaiseException( PEXCEPTION_RECORD, PCONTEXT ); |
4cb00196 | 419 | extern void DECLSPEC_NORETURN __wine_call_from_32_restore_regs( CONTEXT context ); |
3d06d20b | 420 | |
bff860c4 | 421 | |
3d4d7e01 EP |
422 | /*********************************************************************** |
423 | * dispatch_signal | |
424 | */ | |
4325554a | 425 | inline static int dispatch_signal(unsigned int sig) |
3d4d7e01 EP |
426 | { |
427 | if (handlers[sig] == NULL) return 0; | |
428 | return handlers[sig](sig); | |
429 | } | |
430 | ||
431 | ||
de5e1af2 AJ |
432 | /*********************************************************************** |
433 | * get_trap_code | |
434 | * | |
435 | * Get the trap code for a signal. | |
436 | */ | |
437 | static inline int get_trap_code( const SIGCONTEXT *sigcontext ) | |
438 | { | |
439 | #ifdef TRAP_sig | |
440 | return TRAP_sig(sigcontext); | |
441 | #else | |
442 | return T_UNKNOWN; /* unknown trap code */ | |
443 | #endif | |
444 | } | |
3d06d20b | 445 | |
45b2c868 AJ |
446 | /*********************************************************************** |
447 | * get_error_code | |
448 | * | |
449 | * Get the error code for a signal. | |
450 | */ | |
451 | static inline int get_error_code( const SIGCONTEXT *sigcontext ) | |
452 | { | |
453 | #ifdef ERROR_sig | |
454 | return ERROR_sig(sigcontext); | |
455 | #else | |
456 | return 0; | |
457 | #endif | |
458 | } | |
459 | ||
0f95d549 AJ |
460 | /*********************************************************************** |
461 | * get_signal_stack | |
462 | * | |
463 | * Get the base of the signal stack for the current thread. | |
464 | */ | |
465 | static inline void *get_signal_stack(void) | |
466 | { | |
7924f421 | 467 | return (char *)NtCurrentTeb() + 4096; |
0f95d549 AJ |
468 | } |
469 | ||
470 | ||
063cff86 AJ |
471 | /*********************************************************************** |
472 | * get_current_teb | |
473 | * | |
474 | * Get the current teb based on the stack pointer. | |
475 | */ | |
476 | static inline TEB *get_current_teb(void) | |
477 | { | |
478 | unsigned long esp; | |
479 | __asm__("movl %%esp,%0" : "=g" (esp) ); | |
480 | return (TEB *)((esp & ~4095) - 4096); | |
481 | } | |
482 | ||
483 | ||
a274dd91 | 484 | #ifdef __HAVE_VM86 |
0b6c6e76 OK |
485 | /*********************************************************************** |
486 | * save_vm86_context | |
487 | * | |
488 | * Set the register values from a vm86 structure. | |
489 | */ | |
490 | static void save_vm86_context( CONTEXT *context, const struct vm86plus_struct *vm86 ) | |
491 | { | |
492 | context->Eax = vm86->regs.eax; | |
493 | context->Ebx = vm86->regs.ebx; | |
494 | context->Ecx = vm86->regs.ecx; | |
495 | context->Edx = vm86->regs.edx; | |
496 | context->Esi = vm86->regs.esi; | |
497 | context->Edi = vm86->regs.edi; | |
498 | context->Esp = vm86->regs.esp; | |
499 | context->Ebp = vm86->regs.ebp; | |
500 | context->Eip = vm86->regs.eip; | |
501 | context->SegCs = vm86->regs.cs; | |
502 | context->SegDs = vm86->regs.ds; | |
503 | context->SegEs = vm86->regs.es; | |
504 | context->SegFs = vm86->regs.fs; | |
505 | context->SegGs = vm86->regs.gs; | |
506 | context->SegSs = vm86->regs.ss; | |
507 | context->EFlags = vm86->regs.eflags; | |
508 | } | |
509 | ||
510 | ||
511 | /*********************************************************************** | |
512 | * restore_vm86_context | |
513 | * | |
514 | * Build a vm86 structure from the register values. | |
515 | */ | |
516 | static void restore_vm86_context( const CONTEXT *context, struct vm86plus_struct *vm86 ) | |
517 | { | |
518 | vm86->regs.eax = context->Eax; | |
519 | vm86->regs.ebx = context->Ebx; | |
520 | vm86->regs.ecx = context->Ecx; | |
521 | vm86->regs.edx = context->Edx; | |
522 | vm86->regs.esi = context->Esi; | |
523 | vm86->regs.edi = context->Edi; | |
524 | vm86->regs.esp = context->Esp; | |
525 | vm86->regs.ebp = context->Ebp; | |
526 | vm86->regs.eip = context->Eip; | |
527 | vm86->regs.cs = context->SegCs; | |
528 | vm86->regs.ds = context->SegDs; | |
529 | vm86->regs.es = context->SegEs; | |
530 | vm86->regs.fs = context->SegFs; | |
531 | vm86->regs.gs = context->SegGs; | |
532 | vm86->regs.ss = context->SegSs; | |
533 | vm86->regs.eflags = context->EFlags; | |
534 | } | |
d7ee5f3f JH |
535 | |
536 | ||
537 | /********************************************************************** | |
538 | * merge_vm86_pending_flags | |
539 | * | |
540 | * Merges TEB.vm86_ptr and TEB.vm86_pending VIP flags and | |
541 | * raises exception if there are pending events and VIF flag | |
542 | * has been turned on. | |
543 | * | |
544 | * Called from __wine_enter_vm86 because vm86_enter | |
545 | * doesn't check for pending events. | |
546 | * | |
547 | * Called from raise_vm86_sti_exception to check for | |
548 | * pending events in a signal safe way. | |
549 | */ | |
550 | static void merge_vm86_pending_flags( EXCEPTION_RECORD *rec ) | |
551 | { | |
552 | BOOL check_pending = TRUE; | |
553 | struct vm86plus_struct *vm86 = | |
554 | (struct vm86plus_struct*)(NtCurrentTeb()->vm86_ptr); | |
555 | ||
556 | /* | |
557 | * In order to prevent a race when SIGUSR2 occurs while | |
558 | * we are returning from exception handler, pending events | |
559 | * will be rechecked after each raised exception. | |
560 | */ | |
561 | while (check_pending && NtCurrentTeb()->vm86_pending) | |
562 | { | |
563 | check_pending = FALSE; | |
564 | NtCurrentTeb()->vm86_ptr = NULL; | |
565 | ||
566 | /* | |
567 | * If VIF is set, throw exception. | |
568 | * Note that SIGUSR2 may turn VIF flag off so | |
569 | * VIF check must occur only when TEB.vm86_ptr is NULL. | |
570 | */ | |
571 | if (vm86->regs.eflags & VIF_MASK) | |
572 | { | |
573 | CONTEXT vcontext; | |
574 | save_vm86_context( &vcontext, vm86 ); | |
575 | ||
576 | rec->ExceptionCode = EXCEPTION_VM86_STI; | |
577 | rec->ExceptionFlags = EXCEPTION_CONTINUABLE; | |
578 | rec->ExceptionRecord = NULL; | |
579 | rec->NumberParameters = 0; | |
580 | rec->ExceptionAddress = (LPVOID)vcontext.Eip; | |
581 | ||
582 | vcontext.EFlags &= ~VIP_MASK; | |
583 | NtCurrentTeb()->vm86_pending = 0; | |
584 | EXC_RtlRaiseException( rec, &vcontext ); | |
585 | ||
586 | restore_vm86_context( &vcontext, vm86 ); | |
587 | check_pending = TRUE; | |
588 | } | |
589 | ||
590 | NtCurrentTeb()->vm86_ptr = vm86; | |
591 | } | |
592 | ||
593 | /* | |
594 | * Merge VIP flags in a signal safe way. This requires | |
595 | * that the following operation compiles into atomic | |
596 | * instruction. | |
597 | */ | |
598 | vm86->regs.eflags |= NtCurrentTeb()->vm86_pending; | |
599 | } | |
a274dd91 | 600 | #endif /* __HAVE_VM86 */ |
0b6c6e76 OK |
601 | |
602 | ||
4cb00196 AJ |
603 | typedef void (WINAPI *raise_func)( EXCEPTION_RECORD *rec, CONTEXT *context ); |
604 | ||
3d06d20b | 605 | |
d04ccb8e AJ |
606 | /*********************************************************************** |
607 | * init_handler | |
608 | * | |
609 | * Handler initialization when the full context is not needed. | |
610 | */ | |
0f95d549 | 611 | static void *init_handler( const SIGCONTEXT *sigcontext ) |
d04ccb8e | 612 | { |
0f95d549 | 613 | void *stack = (void *)ESP_sig(sigcontext); |
063cff86 | 614 | TEB *teb = get_current_teb(); |
0f95d549 | 615 | |
063cff86 AJ |
616 | wine_set_fs( teb->teb_sel ); |
617 | ||
618 | /* now restore a proper %gs for the fault handler */ | |
8fb98a41 AJ |
619 | if (!wine_ldt_is_system(CS_sig(sigcontext)) || |
620 | !wine_ldt_is_system(SS_sig(sigcontext))) /* 16-bit mode */ | |
d04ccb8e | 621 | { |
0f95d549 AJ |
622 | /* |
623 | * Win16 or DOS protected mode. Note that during switch | |
624 | * from 16-bit mode to linear mode, CS may be set to system | |
625 | * segment before FS is restored. Fortunately, in this case | |
626 | * SS is still non-system segment. This is why both CS and SS | |
627 | * are checked. | |
628 | */ | |
063cff86 AJ |
629 | wine_set_gs( teb->gs_sel ); |
630 | stack = (void *)teb->cur_stack; | |
d04ccb8e AJ |
631 | } |
632 | #ifdef __HAVE_VM86 | |
633 | else if ((void *)EIP_sig(sigcontext) == vm86_return) /* vm86 mode */ | |
634 | { | |
0f95d549 | 635 | unsigned int *int_stack = stack; |
063cff86 | 636 | /* fetch the saved %gs from the stack */ |
0f95d549 AJ |
637 | wine_set_gs( int_stack[0] ); |
638 | } | |
639 | #endif | |
640 | else /* 32-bit mode */ | |
d04ccb8e | 641 | { |
78675ba2 AJ |
642 | #ifdef GS_sig |
643 | wine_set_gs( GS_sig(sigcontext) ); | |
644 | #endif | |
d04ccb8e | 645 | } |
0f95d549 | 646 | return stack; |
d04ccb8e AJ |
647 | } |
648 | ||
649 | ||
3d06d20b AJ |
650 | /*********************************************************************** |
651 | * save_fpu | |
652 | * | |
9a624916 | 653 | * Set the FPU context from a sigcontext. |
3d06d20b | 654 | */ |
650ba4df | 655 | inline static void save_fpu( CONTEXT *context, const SIGCONTEXT *sigcontext ) |
3d06d20b AJ |
656 | { |
657 | #ifdef FPU_sig | |
658 | if (FPU_sig(sigcontext)) | |
659 | { | |
660 | context->FloatSave = *FPU_sig(sigcontext); | |
661 | return; | |
662 | } | |
663 | #endif /* FPU_sig */ | |
664 | #ifdef __GNUC__ | |
665 | __asm__ __volatile__( "fnsave %0; fwait" : "=m" (context->FloatSave) ); | |
666 | #endif /* __GNUC__ */ | |
667 | } | |
668 | ||
669 | ||
670 | /*********************************************************************** | |
671 | * restore_fpu | |
672 | * | |
9a624916 | 673 | * Restore the FPU context to a sigcontext. |
3d06d20b | 674 | */ |
4cb00196 | 675 | inline static void restore_fpu( CONTEXT *context ) |
3d06d20b | 676 | { |
52b6bd95 DH |
677 | /* reset the current interrupt status */ |
678 | context->FloatSave.StatusWord &= context->FloatSave.ControlWord | 0xffffff80; | |
3d06d20b AJ |
679 | #ifdef __GNUC__ |
680 | /* avoid nested exceptions */ | |
3d06d20b AJ |
681 | __asm__ __volatile__( "frstor %0; fwait" : : "m" (context->FloatSave) ); |
682 | #endif /* __GNUC__ */ | |
683 | } | |
684 | ||
685 | ||
4cb00196 AJ |
686 | /*********************************************************************** |
687 | * setup_exception | |
688 | * | |
689 | * Setup a proper stack frame for the raise function, and modify the | |
690 | * sigcontext so that the return from the signal handler will call | |
691 | * the raise function. | |
692 | */ | |
693 | static EXCEPTION_RECORD *setup_exception( SIGCONTEXT *sigcontext, raise_func func ) | |
694 | { | |
695 | struct stack_layout | |
696 | { | |
697 | void *ret_addr; /* return address from raise_func */ | |
698 | EXCEPTION_RECORD *rec_ptr; /* first arg for raise_func */ | |
699 | CONTEXT *context_ptr; /* second arg for raise_func */ | |
700 | void *dummy; /* dummy ret addr for __wine_call_from_32_restore_regs */ | |
701 | CONTEXT context; | |
702 | EXCEPTION_RECORD rec; | |
703 | DWORD ebp; | |
704 | DWORD eip; | |
705 | } *stack; | |
706 | ||
707 | WORD fs, gs; | |
708 | ||
709 | /* get %fs and %gs at time of the fault */ | |
710 | #ifdef FS_sig | |
711 | fs = LOWORD(FS_sig(sigcontext)); | |
712 | #else | |
713 | fs = wine_get_fs(); | |
714 | #endif | |
715 | #ifdef GS_sig | |
716 | gs = LOWORD(GS_sig(sigcontext)); | |
717 | #else | |
718 | gs = wine_get_gs(); | |
719 | #endif | |
720 | ||
0f95d549 | 721 | stack = init_handler( sigcontext ); |
4cb00196 AJ |
722 | |
723 | /* stack sanity checks */ | |
724 | ||
0f95d549 AJ |
725 | if ((char *)stack >= (char *)get_signal_stack() && |
726 | (char *)stack < (char *)get_signal_stack() + SIGNAL_STACK_SIZE) | |
4cb00196 AJ |
727 | { |
728 | ERR( "nested exception on signal stack in thread %04lx eip %08lx esp %08lx stack %p-%p\n", | |
729 | GetCurrentThreadId(), EIP_sig(sigcontext), ESP_sig(sigcontext), | |
730 | NtCurrentTeb()->Tib.StackLimit, NtCurrentTeb()->Tib.StackBase ); | |
4dba172e | 731 | server_abort_thread(1); |
4cb00196 AJ |
732 | } |
733 | ||
7924f421 | 734 | if ((char *)(stack - 1) < (char *)NtCurrentTeb()->Tib.StackLimit + 4096 || |
4cb00196 AJ |
735 | (char *)stack > (char *)NtCurrentTeb()->Tib.StackBase) |
736 | { | |
7924f421 | 737 | UINT diff = (char *)NtCurrentTeb()->Tib.StackLimit + 4096 - (char *)stack; |
4cb00196 | 738 | if (diff < 4096) |
7924f421 | 739 | { |
4cb00196 AJ |
740 | ERR( "stack overflow %u bytes in thread %04lx eip %08lx esp %08lx stack %p-%p\n", |
741 | diff, GetCurrentThreadId(), EIP_sig(sigcontext), ESP_sig(sigcontext), | |
742 | NtCurrentTeb()->Tib.StackLimit, NtCurrentTeb()->Tib.StackBase ); | |
4dba172e | 743 | server_abort_thread(1); |
7924f421 AJ |
744 | } |
745 | else WARN( "exception outside of stack limits in thread %04lx eip %08lx esp %08lx stack %p-%p\n", | |
746 | GetCurrentThreadId(), EIP_sig(sigcontext), ESP_sig(sigcontext), | |
747 | NtCurrentTeb()->Tib.StackLimit, NtCurrentTeb()->Tib.StackBase ); | |
4cb00196 AJ |
748 | } |
749 | ||
750 | stack--; /* push the stack_layout structure */ | |
751 | stack->ret_addr = __wine_call_from_32_restore_regs; | |
752 | stack->rec_ptr = &stack->rec; | |
753 | stack->context_ptr = &stack->context; | |
754 | ||
755 | stack->rec.ExceptionRecord = NULL; | |
756 | stack->rec.ExceptionFlags = EXCEPTION_CONTINUABLE; | |
757 | stack->rec.ExceptionAddress = (LPVOID)EIP_sig(sigcontext); | |
758 | stack->rec.NumberParameters = 0; | |
759 | ||
760 | stack->context.ContextFlags = CONTEXT_FULL; | |
761 | stack->context.Eax = EAX_sig(sigcontext); | |
762 | stack->context.Ebx = EBX_sig(sigcontext); | |
763 | stack->context.Ecx = ECX_sig(sigcontext); | |
764 | stack->context.Edx = EDX_sig(sigcontext); | |
765 | stack->context.Esi = ESI_sig(sigcontext); | |
766 | stack->context.Edi = EDI_sig(sigcontext); | |
767 | stack->context.Ebp = EBP_sig(sigcontext); | |
768 | stack->context.EFlags = EFL_sig(sigcontext); | |
769 | stack->context.Eip = EIP_sig(sigcontext); | |
770 | stack->context.Esp = ESP_sig(sigcontext); | |
771 | stack->context.SegCs = LOWORD(CS_sig(sigcontext)); | |
772 | stack->context.SegDs = LOWORD(DS_sig(sigcontext)); | |
773 | stack->context.SegEs = LOWORD(ES_sig(sigcontext)); | |
774 | stack->context.SegFs = fs; | |
775 | stack->context.SegGs = gs; | |
776 | stack->context.SegSs = LOWORD(SS_sig(sigcontext)); | |
777 | ||
778 | /* now modify the sigcontext to return to the raise function */ | |
779 | ESP_sig(sigcontext) = (DWORD)stack; | |
780 | EIP_sig(sigcontext) = (DWORD)func; | |
781 | CS_sig(sigcontext) = wine_get_cs(); | |
782 | DS_sig(sigcontext) = wine_get_ds(); | |
783 | ES_sig(sigcontext) = wine_get_es(); | |
784 | FS_sig(sigcontext) = wine_get_fs(); | |
785 | GS_sig(sigcontext) = wine_get_gs(); | |
786 | SS_sig(sigcontext) = wine_get_ss(); | |
787 | ||
788 | return stack->rec_ptr; | |
789 | } | |
790 | ||
791 | ||
792 | /*********************************************************************** | |
793 | * get_exception_context | |
794 | * | |
795 | * Get a pointer to the context built by setup_exception. | |
796 | */ | |
797 | static inline CONTEXT *get_exception_context( EXCEPTION_RECORD *rec ) | |
798 | { | |
799 | return (CONTEXT *)rec - 1; /* cf. stack_layout structure */ | |
800 | } | |
801 | ||
802 | ||
3d06d20b AJ |
803 | /********************************************************************** |
804 | * get_fpu_code | |
805 | * | |
806 | * Get the FPU exception code from the FPU status. | |
807 | */ | |
808 | static inline DWORD get_fpu_code( const CONTEXT *context ) | |
809 | { | |
810 | DWORD status = context->FloatSave.StatusWord; | |
811 | ||
812 | if (status & 0x01) /* IE */ | |
813 | { | |
814 | if (status & 0x40) /* SF */ | |
815 | return EXCEPTION_FLT_STACK_CHECK; | |
816 | else | |
817 | return EXCEPTION_FLT_INVALID_OPERATION; | |
818 | } | |
819 | if (status & 0x02) return EXCEPTION_FLT_DENORMAL_OPERAND; /* DE flag */ | |
820 | if (status & 0x04) return EXCEPTION_FLT_DIVIDE_BY_ZERO; /* ZE flag */ | |
821 | if (status & 0x08) return EXCEPTION_FLT_OVERFLOW; /* OE flag */ | |
822 | if (status & 0x10) return EXCEPTION_FLT_UNDERFLOW; /* UE flag */ | |
823 | if (status & 0x20) return EXCEPTION_FLT_INEXACT_RESULT; /* PE flag */ | |
824 | return EXCEPTION_FLT_INVALID_OPERATION; /* generic error */ | |
825 | } | |
826 | ||
827 | ||
828 | /********************************************************************** | |
4cb00196 | 829 | * raise_segv_exception |
3d06d20b | 830 | */ |
4cb00196 | 831 | static void WINAPI raise_segv_exception( EXCEPTION_RECORD *rec, CONTEXT *context ) |
3d06d20b | 832 | { |
4cb00196 | 833 | switch(rec->ExceptionCode) |
3d06d20b | 834 | { |
4cb00196 AJ |
835 | case EXCEPTION_ACCESS_VIOLATION: |
836 | if (rec->NumberParameters == 2) | |
837 | { | |
838 | if (!(rec->ExceptionCode = VIRTUAL_HandleFault( (void *)rec->ExceptionInformation[1] ))) | |
839 | return; | |
840 | } | |
3d06d20b | 841 | break; |
4cb00196 | 842 | case EXCEPTION_DATATYPE_MISALIGNMENT: |
3d06d20b | 843 | /* FIXME: pass through exception handler first? */ |
45b2c868 | 844 | if (context->EFlags & 0x00040000) |
3d06d20b AJ |
845 | { |
846 | /* Disable AC flag, return */ | |
45b2c868 AJ |
847 | context->EFlags &= ~0x00040000; |
848 | return; | |
849 | } | |
3d06d20b AJ |
850 | break; |
851 | } | |
4cb00196 | 852 | EXC_RtlRaiseException( rec, context ); |
3d06d20b AJ |
853 | } |
854 | ||
855 | ||
856 | /********************************************************************** | |
4cb00196 | 857 | * raise_trap_exception |
3d06d20b | 858 | */ |
4cb00196 | 859 | static void WINAPI raise_trap_exception( EXCEPTION_RECORD *rec, CONTEXT *context ) |
3d06d20b | 860 | { |
a993df86 | 861 | DWORD dr0, dr1, dr2, dr3, dr6, dr7; |
3d06d20b | 862 | |
4cb00196 | 863 | if (rec->ExceptionCode == EXCEPTION_SINGLE_STEP) |
de5e1af2 | 864 | { |
0d588a4a EP |
865 | if (context->EFlags & 0x100) |
866 | { | |
0d588a4a EP |
867 | context->EFlags &= ~0x100; /* clear single-step flag */ |
868 | } | |
a993df86 | 869 | else /* hardware breakpoint, fetch the debug registers */ |
0d588a4a | 870 | { |
a993df86 | 871 | context->ContextFlags = CONTEXT_DEBUG_REGISTERS; |
088bcf9c | 872 | NtGetContextThread(GetCurrentThread(), context); |
8638b264 EP |
873 | /* do we really have a bp from a debug register ? |
874 | * if not, then someone did a kill(SIGTRAP) on us, and we | |
875 | * shall return a breakpoint, not a single step exception | |
876 | */ | |
4cb00196 | 877 | if (!(context->Dr6 & 0xf)) rec->ExceptionCode = EXCEPTION_BREAKPOINT; |
0d588a4a | 878 | } |
de5e1af2 | 879 | } |
4cb00196 | 880 | |
a993df86 AJ |
881 | dr0 = context->Dr0; |
882 | dr1 = context->Dr1; | |
883 | dr2 = context->Dr2; | |
884 | dr3 = context->Dr3; | |
885 | dr6 = context->Dr6; | |
886 | dr7 = context->Dr7; | |
887 | ||
4cb00196 | 888 | EXC_RtlRaiseException( rec, context ); |
a993df86 AJ |
889 | |
890 | if (dr0 != context->Dr0 || dr1 != context->Dr1 || dr2 != context->Dr2 || | |
891 | dr3 != context->Dr3 || dr6 != context->Dr6 || dr7 != context->Dr7) | |
892 | { | |
893 | /* the debug registers have changed, set the new values */ | |
894 | context->ContextFlags = CONTEXT_DEBUG_REGISTERS; | |
088bcf9c | 895 | NtSetContextThread(GetCurrentThread(), context); |
a993df86 | 896 | } |
3d06d20b AJ |
897 | } |
898 | ||
899 | ||
900 | /********************************************************************** | |
4cb00196 | 901 | * raise_fpu_exception |
3d06d20b | 902 | */ |
4cb00196 | 903 | static void WINAPI raise_fpu_exception( EXCEPTION_RECORD *rec, CONTEXT *context ) |
3d06d20b | 904 | { |
4cb00196 AJ |
905 | EXC_RtlRaiseException( rec, context ); |
906 | restore_fpu( context ); | |
45b2c868 AJ |
907 | } |
908 | ||
909 | ||
a274dd91 | 910 | #ifdef __HAVE_VM86 |
6e33f63e | 911 | /********************************************************************** |
063cff86 | 912 | * raise_vm86_sti_exception |
6e33f63e | 913 | */ |
063cff86 | 914 | static void WINAPI raise_vm86_sti_exception( EXCEPTION_RECORD *rec, CONTEXT *context ) |
6e33f63e | 915 | { |
d7ee5f3f | 916 | /* merge_vm86_pending_flags merges the vm86_pending flag in safely */ |
063cff86 AJ |
917 | NtCurrentTeb()->vm86_pending |= VIP_MASK; |
918 | ||
d7ee5f3f | 919 | if (NtCurrentTeb()->vm86_ptr) |
6e33f63e | 920 | { |
4eb0bebd OK |
921 | if (((char*)context->Eip >= (char*)vm86_return) && |
922 | ((char*)context->Eip <= (char*)vm86_return_end) && | |
923 | (VM86_TYPE(context->Eax) != VM86_SIGNAL)) { | |
924 | /* exiting from VM86, can't throw */ | |
925 | return; | |
926 | } | |
d7ee5f3f | 927 | merge_vm86_pending_flags( rec ); |
6e33f63e | 928 | } |
063cff86 | 929 | else if (NtCurrentTeb()->dpmi_vif && |
8fb98a41 AJ |
930 | !wine_ldt_is_system(context->SegCs) && |
931 | !wine_ldt_is_system(context->SegSs)) | |
063cff86 AJ |
932 | { |
933 | /* Executing DPMI code and virtual interrupts are enabled. */ | |
934 | NtCurrentTeb()->vm86_pending = 0; | |
935 | EXC_RtlRaiseException( rec, context ); | |
936 | } | |
6e33f63e OK |
937 | } |
938 | ||
939 | ||
7f862cb2 AJ |
940 | /********************************************************************** |
941 | * usr2_handler | |
942 | * | |
943 | * Handler for SIGUSR2. | |
944 | * We use it to signal that the running __wine_enter_vm86() should | |
945 | * immediately set VIP_MASK, causing pending events to be handled | |
946 | * as early as possible. | |
947 | */ | |
948 | static HANDLER_DEF(usr2_handler) | |
949 | { | |
063cff86 AJ |
950 | EXCEPTION_RECORD *rec = setup_exception( HANDLER_CONTEXT, raise_vm86_sti_exception ); |
951 | rec->ExceptionCode = EXCEPTION_VM86_STI; | |
7f862cb2 | 952 | } |
a274dd91 | 953 | #endif /* __HAVE_VM86 */ |
7f862cb2 AJ |
954 | |
955 | ||
45b2c868 AJ |
956 | /********************************************************************** |
957 | * segv_handler | |
958 | * | |
959 | * Handler for SIGSEGV and related errors. | |
960 | */ | |
961 | static HANDLER_DEF(segv_handler) | |
962 | { | |
4cb00196 | 963 | EXCEPTION_RECORD *rec = setup_exception( HANDLER_CONTEXT, raise_segv_exception ); |
ebe67a28 | 964 | |
4cb00196 AJ |
965 | switch(get_trap_code(HANDLER_CONTEXT)) |
966 | { | |
967 | case T_OFLOW: /* Overflow exception */ | |
968 | rec->ExceptionCode = EXCEPTION_INT_OVERFLOW; | |
969 | break; | |
970 | case T_BOUND: /* Bound range exception */ | |
971 | rec->ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED; | |
972 | break; | |
973 | case T_PRIVINFLT: /* Invalid opcode exception */ | |
974 | rec->ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION; | |
975 | break; | |
976 | case T_STKFLT: /* Stack fault */ | |
977 | rec->ExceptionCode = EXCEPTION_STACK_OVERFLOW; | |
978 | break; | |
979 | case T_SEGNPFLT: /* Segment not present exception */ | |
980 | case T_PROTFLT: /* General protection fault */ | |
981 | case T_UNKNOWN: /* Unknown fault code */ | |
982 | rec->ExceptionCode = get_error_code(HANDLER_CONTEXT) ? EXCEPTION_ACCESS_VIOLATION | |
983 | : EXCEPTION_PRIV_INSTRUCTION; | |
984 | break; | |
985 | case T_PAGEFLT: /* Page fault */ | |
986 | rec->ExceptionCode = EXCEPTION_ACCESS_VIOLATION; | |
ebe67a28 | 987 | #ifdef FAULT_ADDRESS |
4cb00196 AJ |
988 | rec->NumberParameters = 2; |
989 | rec->ExceptionInformation[0] = (get_error_code(HANDLER_CONTEXT) & 2) != 0; | |
990 | rec->ExceptionInformation[1] = (DWORD)FAULT_ADDRESS; | |
ebe67a28 | 991 | #endif |
4cb00196 AJ |
992 | break; |
993 | case T_ALIGNFLT: /* Alignment check exception */ | |
994 | rec->ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT; | |
995 | break; | |
996 | default: | |
997 | ERR( "Got unexpected trap %d\n", get_trap_code(HANDLER_CONTEXT) ); | |
998 | /* fall through */ | |
999 | case T_NMI: /* NMI interrupt */ | |
1000 | case T_DNA: /* Device not available exception */ | |
1001 | case T_DOUBLEFLT: /* Double fault exception */ | |
1002 | case T_TSSFLT: /* Invalid TSS exception */ | |
1003 | case T_RESERVED: /* Unknown exception */ | |
1004 | case T_MCHK: /* Machine check exception */ | |
1005 | #ifdef T_CACHEFLT | |
1006 | case T_CACHEFLT: /* Cache flush exception */ | |
1007 | #endif | |
1008 | rec->ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION; | |
1009 | break; | |
1010 | } | |
45b2c868 AJ |
1011 | } |
1012 | ||
1013 | ||
1014 | /********************************************************************** | |
1015 | * trap_handler | |
1016 | * | |
1017 | * Handler for SIGTRAP. | |
1018 | */ | |
1019 | static HANDLER_DEF(trap_handler) | |
1020 | { | |
4cb00196 AJ |
1021 | EXCEPTION_RECORD *rec = setup_exception( HANDLER_CONTEXT, raise_trap_exception ); |
1022 | ||
1023 | switch(get_trap_code(HANDLER_CONTEXT)) | |
1024 | { | |
1025 | case T_TRCTRAP: /* Single-step exception */ | |
1026 | rec->ExceptionCode = EXCEPTION_SINGLE_STEP; | |
1027 | EFL_sig(HANDLER_CONTEXT) &= ~0x100; /* clear single-step flag */ | |
1028 | break; | |
1029 | case T_BPTFLT: /* Breakpoint exception */ | |
1030 | rec->ExceptionAddress = (char *)rec->ExceptionAddress - 1; /* back up over the int3 instruction */ | |
1031 | /* fall through */ | |
1032 | default: | |
1033 | rec->ExceptionCode = EXCEPTION_BREAKPOINT; | |
1034 | break; | |
1035 | } | |
45b2c868 AJ |
1036 | } |
1037 | ||
1038 | ||
1039 | /********************************************************************** | |
1040 | * fpe_handler | |
1041 | * | |
1042 | * Handler for SIGFPE. | |
1043 | */ | |
1044 | static HANDLER_DEF(fpe_handler) | |
1045 | { | |
4cb00196 AJ |
1046 | EXCEPTION_RECORD *rec = setup_exception( HANDLER_CONTEXT, raise_fpu_exception ); |
1047 | CONTEXT *context; | |
1048 | ||
1049 | context = get_exception_context( rec ); | |
1050 | save_fpu( context, HANDLER_CONTEXT ); | |
1051 | ||
1052 | switch(get_trap_code(HANDLER_CONTEXT)) | |
1053 | { | |
1054 | case T_DIVIDE: /* Division by zero exception */ | |
1055 | rec->ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO; | |
1056 | break; | |
1057 | case T_FPOPFLT: /* Coprocessor segment overrun */ | |
1058 | rec->ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION; | |
1059 | break; | |
1060 | case T_ARITHTRAP: /* Floating point exception */ | |
1061 | case T_UNKNOWN: /* Unknown fault code */ | |
1062 | rec->ExceptionCode = get_fpu_code( context ); | |
1063 | break; | |
1064 | default: | |
1065 | ERR( "Got unexpected trap %d\n", get_trap_code(HANDLER_CONTEXT) ); | |
1066 | rec->ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION; | |
1067 | break; | |
1068 | } | |
3d06d20b AJ |
1069 | } |
1070 | ||
1071 | ||
1072 | /********************************************************************** | |
1073 | * int_handler | |
1074 | * | |
1075 | * Handler for SIGINT. | |
1076 | */ | |
1077 | static HANDLER_DEF(int_handler) | |
1078 | { | |
d04ccb8e | 1079 | init_handler( HANDLER_CONTEXT ); |
3d4d7e01 | 1080 | if (!dispatch_signal(SIGINT)) |
93bfa0d6 | 1081 | { |
4cb00196 AJ |
1082 | EXCEPTION_RECORD *rec = setup_exception( HANDLER_CONTEXT, EXC_RtlRaiseException ); |
1083 | rec->ExceptionCode = CONTROL_C_EXIT; | |
93bfa0d6 | 1084 | } |
3d06d20b AJ |
1085 | } |
1086 | ||
bdb44555 LU |
1087 | /********************************************************************** |
1088 | * abrt_handler | |
1089 | * | |
1090 | * Handler for SIGABRT. | |
1091 | */ | |
1092 | static HANDLER_DEF(abrt_handler) | |
1093 | { | |
4cb00196 AJ |
1094 | EXCEPTION_RECORD *rec = setup_exception( HANDLER_CONTEXT, EXC_RtlRaiseException ); |
1095 | rec->ExceptionCode = EXCEPTION_WINE_ASSERTION; | |
1096 | rec->ExceptionFlags = EH_NONCONTINUABLE; | |
bdb44555 LU |
1097 | } |
1098 | ||
3d06d20b | 1099 | |
6a26e3f7 AJ |
1100 | /********************************************************************** |
1101 | * term_handler | |
1102 | * | |
1103 | * Handler for SIGTERM. | |
1104 | */ | |
1105 | static HANDLER_DEF(term_handler) | |
1106 | { | |
1107 | init_handler( HANDLER_CONTEXT ); | |
4dba172e | 1108 | server_abort_thread(0); |
6a26e3f7 AJ |
1109 | } |
1110 | ||
1111 | ||
d04ccb8e AJ |
1112 | /********************************************************************** |
1113 | * usr1_handler | |
1114 | * | |
1115 | * Handler for SIGUSR1, used to signal a thread that it got suspended. | |
1116 | */ | |
1117 | static HANDLER_DEF(usr1_handler) | |
1118 | { | |
14d04b60 EP |
1119 | LARGE_INTEGER timeout; |
1120 | ||
d04ccb8e AJ |
1121 | init_handler( HANDLER_CONTEXT ); |
1122 | /* wait with 0 timeout, will only return once the thread is no longer suspended */ | |
14d04b60 | 1123 | timeout.QuadPart = 0; |
217fdab7 | 1124 | NTDLL_wait_for_multiple_objects( 0, NULL, 0, &timeout ); |
d04ccb8e AJ |
1125 | } |
1126 | ||
1127 | ||
3d06d20b AJ |
1128 | /*********************************************************************** |
1129 | * set_handler | |
1130 | * | |
1131 | * Set a signal handler | |
1132 | */ | |
0045def7 | 1133 | static int set_handler( int sig, int have_sigaltstack, void (*func)() ) |
3d06d20b | 1134 | { |
3d06d20b | 1135 | struct sigaction sig_act; |
0045def7 AJ |
1136 | |
1137 | #ifdef linux | |
8824c38e | 1138 | if (!have_sigaltstack) |
0045def7 AJ |
1139 | { |
1140 | struct kernel_sigaction sig_act; | |
1141 | sig_act.ksa_handler = func; | |
e4a98ec1 OK |
1142 | sig_act.ksa_flags = SA_RESTART; |
1143 | sig_act.ksa_mask = (1 << (SIGINT-1)) | | |
ae906923 | 1144 | (1 << (SIGUSR2-1)); |
8824c38e | 1145 | /* point to the top of the signal stack */ |
0f95d549 | 1146 | sig_act.ksa_restorer = (char *)get_signal_stack() + SIGNAL_STACK_SIZE; |
0045def7 AJ |
1147 | return wine_sigaction( sig, &sig_act, NULL ); |
1148 | } | |
1149 | #endif /* linux */ | |
3d06d20b AJ |
1150 | sig_act.sa_handler = func; |
1151 | sigemptyset( &sig_act.sa_mask ); | |
e4a98ec1 | 1152 | sigaddset( &sig_act.sa_mask, SIGINT ); |
bbb7dc0f | 1153 | sigaddset( &sig_act.sa_mask, SIGUSR2 ); |
3d06d20b | 1154 | |
c2de5fbc | 1155 | #if defined(linux) || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) |
e4a98ec1 | 1156 | sig_act.sa_flags = SA_RESTART; |
0045def7 AJ |
1157 | #elif defined (__svr4__) || defined(_SCO_DS) |
1158 | sig_act.sa_flags = SA_SIGINFO | SA_RESTART; | |
1159 | #else | |
3d06d20b | 1160 | sig_act.sa_flags = 0; |
0045def7 AJ |
1161 | #endif |
1162 | ||
1163 | #ifdef SA_ONSTACK | |
1164 | if (have_sigaltstack) sig_act.sa_flags |= SA_ONSTACK; | |
1165 | #endif | |
3d06d20b | 1166 | return sigaction( sig, &sig_act, NULL ); |
3d06d20b AJ |
1167 | } |
1168 | ||
1169 | ||
3d4d7e01 EP |
1170 | /*********************************************************************** |
1171 | * __wine_set_signal_handler (NTDLL.@) | |
1172 | */ | |
4325554a | 1173 | int __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh) |
3d4d7e01 EP |
1174 | { |
1175 | if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1; | |
1176 | if (handlers[sig] != NULL) return -2; | |
1177 | handlers[sig] = wsh; | |
1178 | return 0; | |
1179 | } | |
1180 | ||
1181 | ||
3d06d20b AJ |
1182 | /********************************************************************** |
1183 | * SIGNAL_Init | |
1184 | */ | |
1185 | BOOL SIGNAL_Init(void) | |
1186 | { | |
0045def7 AJ |
1187 | int have_sigaltstack = 0; |
1188 | ||
1189 | #ifdef HAVE_SIGALTSTACK | |
3d06d20b | 1190 | struct sigaltstack ss; |
0f95d549 | 1191 | ss.ss_sp = get_signal_stack(); |
8824c38e AJ |
1192 | ss.ss_size = SIGNAL_STACK_SIZE; |
1193 | ss.ss_flags = 0; | |
1194 | if (!sigaltstack(&ss, NULL)) have_sigaltstack = 1; | |
0045def7 | 1195 | #ifdef linux |
8824c38e AJ |
1196 | /* sigaltstack may fail because the kernel is too old, or |
1197 | because glibc is brain-dead. In the latter case a | |
1198 | direct system call should succeed. */ | |
1199 | else if (!wine_sigaltstack(&ss, NULL)) have_sigaltstack = 1; | |
0045def7 | 1200 | #endif /* linux */ |
3d06d20b | 1201 | #endif /* HAVE_SIGALTSTACK */ |
e4a98ec1 | 1202 | |
0045def7 AJ |
1203 | if (set_handler( SIGINT, have_sigaltstack, (void (*)())int_handler ) == -1) goto error; |
1204 | if (set_handler( SIGFPE, have_sigaltstack, (void (*)())fpe_handler ) == -1) goto error; | |
1205 | if (set_handler( SIGSEGV, have_sigaltstack, (void (*)())segv_handler ) == -1) goto error; | |
1206 | if (set_handler( SIGILL, have_sigaltstack, (void (*)())segv_handler ) == -1) goto error; | |
bdb44555 | 1207 | if (set_handler( SIGABRT, have_sigaltstack, (void (*)())abrt_handler ) == -1) goto error; |
6a26e3f7 | 1208 | if (set_handler( SIGTERM, have_sigaltstack, (void (*)())term_handler ) == -1) goto error; |
d04ccb8e | 1209 | if (set_handler( SIGUSR1, have_sigaltstack, (void (*)())usr1_handler ) == -1) goto error; |
3d06d20b | 1210 | #ifdef SIGBUS |
0045def7 | 1211 | if (set_handler( SIGBUS, have_sigaltstack, (void (*)())segv_handler ) == -1) goto error; |
3d06d20b AJ |
1212 | #endif |
1213 | #ifdef SIGTRAP | |
0045def7 | 1214 | if (set_handler( SIGTRAP, have_sigaltstack, (void (*)())trap_handler ) == -1) goto error; |
3d06d20b | 1215 | #endif |
7f862cb2 | 1216 | |
a274dd91 | 1217 | #ifdef __HAVE_VM86 |
6e33f63e | 1218 | if (set_handler( SIGUSR2, have_sigaltstack, (void (*)())usr2_handler ) == -1) goto error; |
7f862cb2 AJ |
1219 | #endif |
1220 | ||
3d06d20b AJ |
1221 | return TRUE; |
1222 | ||
1223 | error: | |
1224 | perror("sigaction"); | |
1225 | return FALSE; | |
1226 | } | |
1227 | ||
45b2c868 | 1228 | |
a274dd91 | 1229 | #ifdef __HAVE_VM86 |
45b2c868 | 1230 | /********************************************************************** |
a62a26ce | 1231 | * __wine_enter_vm86 (NTDLL.@) |
45b2c868 AJ |
1232 | * |
1233 | * Enter vm86 mode with the specified register context. | |
1234 | */ | |
1235 | void __wine_enter_vm86( CONTEXT *context ) | |
1236 | { | |
1237 | EXCEPTION_RECORD rec; | |
6e33f63e | 1238 | TEB *teb = NtCurrentTeb(); |
45b2c868 AJ |
1239 | int res; |
1240 | struct vm86plus_struct vm86; | |
1241 | ||
b59627c8 | 1242 | memset( &vm86, 0, sizeof(vm86) ); |
45b2c868 AJ |
1243 | for (;;) |
1244 | { | |
0b6c6e76 | 1245 | restore_vm86_context( context, &vm86 ); |
4cb00196 | 1246 | |
d7ee5f3f JH |
1247 | teb->vm86_ptr = &vm86; |
1248 | merge_vm86_pending_flags( &rec ); | |
45b2c868 | 1249 | |
d7ee5f3f JH |
1250 | res = vm86_enter( &teb->vm86_ptr ); /* uses and clears teb->vm86_ptr */ |
1251 | if (res < 0) | |
b59627c8 | 1252 | { |
d7ee5f3f JH |
1253 | errno = -res; |
1254 | return; | |
1255 | } | |
45b2c868 | 1256 | |
0b6c6e76 | 1257 | save_vm86_context( context, &vm86 ); |
45b2c868 | 1258 | |
4cb00196 AJ |
1259 | rec.ExceptionFlags = EXCEPTION_CONTINUABLE; |
1260 | rec.ExceptionRecord = NULL; | |
1261 | rec.ExceptionAddress = (LPVOID)context->Eip; | |
1262 | rec.NumberParameters = 0; | |
1263 | ||
45b2c868 AJ |
1264 | switch(VM86_TYPE(res)) |
1265 | { | |
45b2c868 | 1266 | case VM86_UNKNOWN: /* unhandled GP fault - IO-instruction or similar */ |
4cb00196 AJ |
1267 | rec.ExceptionCode = EXCEPTION_PRIV_INSTRUCTION; |
1268 | raise_segv_exception( &rec, context ); | |
45b2c868 AJ |
1269 | continue; |
1270 | case VM86_TRAP: /* return due to DOS-debugger request */ | |
4cb00196 AJ |
1271 | switch(VM86_ARG(res)) |
1272 | { | |
1273 | case T_TRCTRAP: /* Single-step exception */ | |
1274 | rec.ExceptionCode = EXCEPTION_SINGLE_STEP; | |
1275 | context->EFlags &= ~0x100; /* clear single-step flag */ | |
1276 | break; | |
1277 | case T_BPTFLT: /* Breakpoint exception */ | |
1278 | rec.ExceptionAddress = (char *)rec.ExceptionAddress - 1; /* back up over the int3 instruction */ | |
1279 | /* fall through */ | |
1280 | default: | |
1281 | rec.ExceptionCode = EXCEPTION_BREAKPOINT; | |
1282 | break; | |
1283 | } | |
1284 | raise_trap_exception( &rec, context ); | |
45b2c868 AJ |
1285 | continue; |
1286 | case VM86_INTx: /* int3/int x instruction (ARG = x) */ | |
1287 | rec.ExceptionCode = EXCEPTION_VM86_INTx; | |
4cb00196 AJ |
1288 | rec.NumberParameters = 1; |
1289 | rec.ExceptionInformation[0] = VM86_ARG(res); | |
45b2c868 AJ |
1290 | break; |
1291 | case VM86_STI: /* sti/popf/iret instruction enabled virtual interrupts */ | |
d7ee5f3f JH |
1292 | context->EFlags |= VIF_MASK; |
1293 | context->EFlags &= ~VIP_MASK; | |
6e33f63e | 1294 | teb->vm86_pending = 0; |
45b2c868 AJ |
1295 | rec.ExceptionCode = EXCEPTION_VM86_STI; |
1296 | break; | |
1297 | case VM86_PICRETURN: /* return due to pending PIC request */ | |
1298 | rec.ExceptionCode = EXCEPTION_VM86_PICRETURN; | |
1299 | break; | |
d7ee5f3f | 1300 | case VM86_SIGNAL: /* cannot happen because vm86_enter handles this case */ |
45b2c868 AJ |
1301 | default: |
1302 | ERR( "unhandled result from vm86 mode %x\n", res ); | |
1303 | continue; | |
1304 | } | |
45b2c868 AJ |
1305 | EXC_RtlRaiseException( &rec, context ); |
1306 | } | |
1307 | } | |
1308 | ||
a274dd91 | 1309 | #else /* __HAVE_VM86 */ |
a62a26ce PS |
1310 | /********************************************************************** |
1311 | * __wine_enter_vm86 (NTDLL.@) | |
1312 | */ | |
45b2c868 AJ |
1313 | void __wine_enter_vm86( CONTEXT *context ) |
1314 | { | |
1315 | MESSAGE("vm86 mode not supported on this platform\n"); | |
1316 | } | |
a274dd91 | 1317 | #endif /* __HAVE_VM86 */ |
45b2c868 | 1318 | |
7d0dd5f3 | 1319 | /********************************************************************** |
3ca98239 | 1320 | * DbgBreakPoint (NTDLL.@) |
7d0dd5f3 | 1321 | */ |
d628f436 | 1322 | __ASM_GLOBAL_FUNC( DbgBreakPoint, "int $3; ret"); |
7d0dd5f3 AJ |
1323 | |
1324 | /********************************************************************** | |
3ca98239 | 1325 | * DbgUserBreakPoint (NTDLL.@) |
7d0dd5f3 | 1326 | */ |
d628f436 | 1327 | __ASM_GLOBAL_FUNC( DbgUserBreakPoint, "int $3; ret"); |
7d0dd5f3 | 1328 | |
3d06d20b | 1329 | #endif /* __i386__ */ |