?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Create a thread to run the ctrl-C routine instead of raising an exception.
[wine.git] / dlls / ntdll / unix / signal_i386.c
blobb5afbcf0aac1ad3531f1811600dc17bc49d35eb9
1 /*
2 * i386 signal handling routines
3 *
4 * Copyright 1999 Alexandre Julliard
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 #if 0
22 #pragma makedep unix
23 #endif
24
25 #ifdef __i386__
26
27 #include "config.h"
28 #include "wine/port.h"
29
30 #include <errno.h>
31 #include <signal.h>
32 #include <stdlib.h>
33 #include <stdarg.h>
34 #include <stdio.h>
35 #include <sys/types.h>
36 #include <assert.h>
37 #ifdef HAVE_UNISTD_H
38 # include <unistd.h>
39 #endif
40 #ifdef HAVE_SYS_PARAM_H
41 # include <sys/param.h>
42 #endif
43 #ifdef HAVE_SYSCALL_H
44 # include <syscall.h>
45 #else
46 # ifdef HAVE_SYS_SYSCALL_H
47 # include <sys/syscall.h>
48 # endif
49 #endif
50 #ifdef HAVE_SYS_SIGNAL_H
51 # include <sys/signal.h>
52 #endif
53 #ifdef HAVE_SYS_UCONTEXT_H
54 # include <sys/ucontext.h>
55 #endif
56
57 #include "ntstatus.h"
58 #define WIN32_NO_STATUS
59 #include "windef.h"
60 #include "winternl.h"
61 #include "ddk/wdm.h"
62 #include "wine/asm.h"
63 #include "wine/exception.h"
64 #include "unix_private.h"
65 #include "wine/debug.h"
66
67 WINE_DEFAULT_DEBUG_CHANNEL(seh);
68
69 #undef ERR /* Solaris needs to define this */
70
71 /***********************************************************************
72 * signal context platform-specific definitions
73 */
74
75 #ifdef __linux__
76
77 #ifndef HAVE_SYS_UCONTEXT_H
78
79 enum
80 {
81 REG_GS, REG_FS, REG_ES, REG_DS, REG_EDI, REG_ESI, REG_EBP, REG_ESP,
82 REG_EBX, REG_EDX, REG_ECX, REG_EAX, REG_TRAPNO, REG_ERR, REG_EIP,
83 REG_CS, REG_EFL, REG_UESP, REG_SS, NGREG
84 };
85
86 typedef int greg_t;
87 typedef greg_t gregset_t[NGREG];
88
89 struct _libc_fpreg
90 {
91 unsigned short significand[4];
92 unsigned short exponent;
93 };
94
95 struct _libc_fpstate
96 {
97 unsigned long cw;
98 unsigned long sw;
99 unsigned long tag;
100 unsigned long ipoff;
101 unsigned long cssel;
102 unsigned long dataoff;
103 unsigned long datasel;
104 struct _libc_fpreg _st[8];
105 unsigned long status;
106 };
107
108 typedef struct _libc_fpstate* fpregset_t;
109
110 typedef struct
111 {
112 gregset_t gregs;
113 fpregset_t fpregs;
114 unsigned long oldmask;
115 unsigned long cr2;
116 } mcontext_t;
117
118 typedef struct ucontext
119 {
120 unsigned long uc_flags;
121 struct ucontext *uc_link;
122 stack_t uc_stack;
123 mcontext_t uc_mcontext;
124 sigset_t uc_sigmask;
125 } ucontext_t;
126 #endif /* HAVE_SYS_UCONTEXT_H */
127
128 #ifndef FP_XSTATE_MAGIC1
129 #define FP_XSTATE_MAGIC1 0x46505853
130 #endif
131
132 #define EAX_sig(context) ((context)->uc_mcontext.gregs[REG_EAX])
133 #define EBX_sig(context) ((context)->uc_mcontext.gregs[REG_EBX])
134 #define ECX_sig(context) ((context)->uc_mcontext.gregs[REG_ECX])
135 #define EDX_sig(context) ((context)->uc_mcontext.gregs[REG_EDX])
136 #define ESI_sig(context) ((context)->uc_mcontext.gregs[REG_ESI])
137 #define EDI_sig(context) ((context)->uc_mcontext.gregs[REG_EDI])
138 #define EBP_sig(context) ((context)->uc_mcontext.gregs[REG_EBP])
139 #define ESP_sig(context) ((context)->uc_mcontext.gregs[REG_ESP])
140
141 #define CS_sig(context) ((context)->uc_mcontext.gregs[REG_CS])
142 #define DS_sig(context) ((context)->uc_mcontext.gregs[REG_DS])
143 #define ES_sig(context) ((context)->uc_mcontext.gregs[REG_ES])
144 #define SS_sig(context) ((context)->uc_mcontext.gregs[REG_SS])
145 #define FS_sig(context) ((context)->uc_mcontext.gregs[REG_FS])
146 #define GS_sig(context) ((context)->uc_mcontext.gregs[REG_GS])
147
148 #define EFL_sig(context) ((context)->uc_mcontext.gregs[REG_EFL])
149 #define EIP_sig(context) ((context)->uc_mcontext.gregs[REG_EIP])
150 #define TRAP_sig(context) ((context)->uc_mcontext.gregs[REG_TRAPNO])
151 #define ERROR_sig(context) ((context)->uc_mcontext.gregs[REG_ERR])
152
153 #define FPU_sig(context) ((FLOATING_SAVE_AREA*)((context)->uc_mcontext.fpregs))
154 #define FPUX_sig(context) (FPU_sig(context) && !((context)->uc_mcontext.fpregs->status >> 16) ? (XSAVE_FORMAT *)(FPU_sig(context) + 1) : NULL)
155 #define XState_sig(fpu) (((unsigned int *)fpu->Reserved4)[12] == FP_XSTATE_MAGIC1 ? (XSTATE *)(fpu + 1) : NULL)
156
157 #ifdef __ANDROID__
158 /* custom signal restorer since we may have unmapped the one in vdso, and bionic doesn't check for that */
159 void rt_sigreturn(void);
160 __ASM_GLOBAL_FUNC( rt_sigreturn,
161 "movl $173,%eax\n\t" /* NR_rt_sigreturn */
162 "int $0x80" );
163 #endif
164
165 struct modify_ldt_s
166 {
167 unsigned int entry_number;
168 void *base_addr;
169 unsigned int limit;
170 unsigned int seg_32bit : 1;
171 unsigned int contents : 2;
172 unsigned int read_exec_only : 1;
173 unsigned int limit_in_pages : 1;
174 unsigned int seg_not_present : 1;
175 unsigned int usable : 1;
176 unsigned int garbage : 25;
177 };
178
179 static inline int modify_ldt( int func, struct modify_ldt_s *ptr, unsigned long count )
180 {
181 return syscall( 123 /* SYS_modify_ldt */, func, ptr, count );
182 }
183
184 static inline int set_thread_area( struct modify_ldt_s *ptr )
185 {
186 return syscall( 243 /* SYS_set_thread_area */, ptr );
187 }
188
189 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
190
191 #include <machine/trap.h>
192 #include <machine/segments.h>
193 #include <machine/sysarch.h>
194
195 #define EAX_sig(context) ((context)->uc_mcontext.mc_eax)
196 #define EBX_sig(context) ((context)->uc_mcontext.mc_ebx)
197 #define ECX_sig(context) ((context)->uc_mcontext.mc_ecx)
198 #define EDX_sig(context) ((context)->uc_mcontext.mc_edx)
199 #define ESI_sig(context) ((context)->uc_mcontext.mc_esi)
200 #define EDI_sig(context) ((context)->uc_mcontext.mc_edi)
201 #define EBP_sig(context) ((context)->uc_mcontext.mc_ebp)
202
203 #define CS_sig(context) ((context)->uc_mcontext.mc_cs)
204 #define DS_sig(context) ((context)->uc_mcontext.mc_ds)
205 #define ES_sig(context) ((context)->uc_mcontext.mc_es)
206 #define FS_sig(context) ((context)->uc_mcontext.mc_fs)
207 #define GS_sig(context) ((context)->uc_mcontext.mc_gs)
208 #define SS_sig(context) ((context)->uc_mcontext.mc_ss)
209
210 #define TRAP_sig(context) ((context)->uc_mcontext.mc_trapno)
211 #define ERROR_sig(context) ((context)->uc_mcontext.mc_err)
212 #define EFL_sig(context) ((context)->uc_mcontext.mc_eflags)
213
214 #define EIP_sig(context) ((context)->uc_mcontext.mc_eip)
215 #define ESP_sig(context) ((context)->uc_mcontext.mc_esp)
216
217 #define FPU_sig(context) NULL /* FIXME */
218 #define FPUX_sig(context) NULL /* FIXME */
219 #define XState_sig(context) NULL /* FIXME */
220
221 #elif defined (__OpenBSD__)
222
223 #include <machine/segments.h>
224 #include <machine/sysarch.h>
225
226 #define EAX_sig(context) ((context)->sc_eax)
227 #define EBX_sig(context) ((context)->sc_ebx)
228 #define ECX_sig(context) ((context)->sc_ecx)
229 #define EDX_sig(context) ((context)->sc_edx)
230 #define ESI_sig(context) ((context)->sc_esi)
231 #define EDI_sig(context) ((context)->sc_edi)
232 #define EBP_sig(context) ((context)->sc_ebp)
233
234 #define CS_sig(context) ((context)->sc_cs)
235 #define DS_sig(context) ((context)->sc_ds)
236 #define ES_sig(context) ((context)->sc_es)
237 #define FS_sig(context) ((context)->sc_fs)
238 #define GS_sig(context) ((context)->sc_gs)
239 #define SS_sig(context) ((context)->sc_ss)
240
241 #define TRAP_sig(context) ((context)->sc_trapno)
242 #define ERROR_sig(context) ((context)->sc_err)
243 #define EFL_sig(context) ((context)->sc_eflags)
244
245 #define EIP_sig(context) ((context)->sc_eip)
246 #define ESP_sig(context) ((context)->sc_esp)
247
248 #define FPU_sig(context) NULL /* FIXME */
249 #define FPUX_sig(context) NULL /* FIXME */
250 #define XState_sig(context) NULL /* FIXME */
251
252 #define T_MCHK T_MACHK
253 #define T_XMMFLT T_XFTRAP
254
255 #elif defined(__svr4__) || defined(_SCO_DS) || defined(__sun)
256
257 #if defined(_SCO_DS) || defined(__sun)
258 #include <sys/regset.h>
259 #endif
260
261 #ifdef _SCO_DS
262 #define gregs regs
263 #endif
264
265 #define EAX_sig(context) ((context)->uc_mcontext.gregs[EAX])
266 #define EBX_sig(context) ((context)->uc_mcontext.gregs[EBX])
267 #define ECX_sig(context) ((context)->uc_mcontext.gregs[ECX])
268 #define EDX_sig(context) ((context)->uc_mcontext.gregs[EDX])
269 #define ESI_sig(context) ((context)->uc_mcontext.gregs[ESI])
270 #define EDI_sig(context) ((context)->uc_mcontext.gregs[EDI])
271 #define EBP_sig(context) ((context)->uc_mcontext.gregs[EBP])
272
273 #define CS_sig(context) ((context)->uc_mcontext.gregs[CS])
274 #define DS_sig(context) ((context)->uc_mcontext.gregs[DS])
275 #define ES_sig(context) ((context)->uc_mcontext.gregs[ES])
276 #define SS_sig(context) ((context)->uc_mcontext.gregs[SS])
277
278 #define FS_sig(context) ((context)->uc_mcontext.gregs[FS])
279 #define GS_sig(context) ((context)->uc_mcontext.gregs[GS])
280
281 #define EFL_sig(context) ((context)->uc_mcontext.gregs[EFL])
282
283 #define EIP_sig(context) ((context)->uc_mcontext.gregs[EIP])
284 #ifdef UESP
285 #define ESP_sig(context) ((context)->uc_mcontext.gregs[UESP])
286 #elif defined(R_ESP)
287 #define ESP_sig(context) ((context)->uc_mcontext.gregs[R_ESP])
288 #else
289 #define ESP_sig(context) ((context)->uc_mcontext.gregs[ESP])
290 #endif
291 #define ERROR_sig(context) ((context)->uc_mcontext.gregs[ERR])
292 #define TRAP_sig(context) ((context)->uc_mcontext.gregs[TRAPNO])
293
294 #define FPU_sig(context) NULL /* FIXME */
295 #define FPUX_sig(context) NULL /* FIXME */
296 #define XState_sig(context) NULL /* FIXME */
297
298 #elif defined (__APPLE__)
299
300 #include <i386/user_ldt.h>
301
302 /* work around silly renaming of struct members in OS X 10.5 */
303 #if __DARWIN_UNIX03 && defined(_STRUCT_X86_EXCEPTION_STATE32)
304 #define EAX_sig(context) ((context)->uc_mcontext->__ss.__eax)
305 #define EBX_sig(context) ((context)->uc_mcontext->__ss.__ebx)
306 #define ECX_sig(context) ((context)->uc_mcontext->__ss.__ecx)
307 #define EDX_sig(context) ((context)->uc_mcontext->__ss.__edx)
308 #define ESI_sig(context) ((context)->uc_mcontext->__ss.__esi)
309 #define EDI_sig(context) ((context)->uc_mcontext->__ss.__edi)
310 #define EBP_sig(context) ((context)->uc_mcontext->__ss.__ebp)
311 #define CS_sig(context) ((context)->uc_mcontext->__ss.__cs)
312 #define DS_sig(context) ((context)->uc_mcontext->__ss.__ds)
313 #define ES_sig(context) ((context)->uc_mcontext->__ss.__es)
314 #define FS_sig(context) ((context)->uc_mcontext->__ss.__fs)
315 #define GS_sig(context) ((context)->uc_mcontext->__ss.__gs)
316 #define SS_sig(context) ((context)->uc_mcontext->__ss.__ss)
317 #define EFL_sig(context) ((context)->uc_mcontext->__ss.__eflags)
318 #define EIP_sig(context) (*((unsigned long*)&(context)->uc_mcontext->__ss.__eip))
319 #define ESP_sig(context) (*((unsigned long*)&(context)->uc_mcontext->__ss.__esp))
320 #define TRAP_sig(context) ((context)->uc_mcontext->__es.__trapno)
321 #define ERROR_sig(context) ((context)->uc_mcontext->__es.__err)
322 #define FPU_sig(context) NULL
323 #define FPUX_sig(context) ((XSAVE_FORMAT *)&(context)->uc_mcontext->__fs.__fpu_fcw)
324 #define XState_sig(context) NULL /* FIXME */
325 #else
326 #define EAX_sig(context) ((context)->uc_mcontext->ss.eax)
327 #define EBX_sig(context) ((context)->uc_mcontext->ss.ebx)
328 #define ECX_sig(context) ((context)->uc_mcontext->ss.ecx)
329 #define EDX_sig(context) ((context)->uc_mcontext->ss.edx)
330 #define ESI_sig(context) ((context)->uc_mcontext->ss.esi)
331 #define EDI_sig(context) ((context)->uc_mcontext->ss.edi)
332 #define EBP_sig(context) ((context)->uc_mcontext->ss.ebp)
333 #define CS_sig(context) ((context)->uc_mcontext->ss.cs)
334 #define DS_sig(context) ((context)->uc_mcontext->ss.ds)
335 #define ES_sig(context) ((context)->uc_mcontext->ss.es)
336 #define FS_sig(context) ((context)->uc_mcontext->ss.fs)
337 #define GS_sig(context) ((context)->uc_mcontext->ss.gs)
338 #define SS_sig(context) ((context)->uc_mcontext->ss.ss)
339 #define EFL_sig(context) ((context)->uc_mcontext->ss.eflags)
340 #define EIP_sig(context) (*((unsigned long*)&(context)->uc_mcontext->ss.eip))
341 #define ESP_sig(context) (*((unsigned long*)&(context)->uc_mcontext->ss.esp))
342 #define TRAP_sig(context) ((context)->uc_mcontext->es.trapno)
343 #define ERROR_sig(context) ((context)->uc_mcontext->es.err)
344 #define FPU_sig(context) NULL
345 #define FPUX_sig(context) ((XSAVE_FORMAT *)&(context)->uc_mcontext->fs.fpu_fcw)
346 #define XState_sig(context) NULL /* FIXME */
347 #endif
348
349 #elif defined(__NetBSD__)
350
351 #include <machine/segments.h>
352 #include <machine/sysarch.h>
353
354 #define EAX_sig(context) ((context)->uc_mcontext.__gregs[_REG_EAX])
355 #define EBX_sig(context) ((context)->uc_mcontext.__gregs[_REG_EBX])
356 #define ECX_sig(context) ((context)->uc_mcontext.__gregs[_REG_ECX])
357 #define EDX_sig(context) ((context)->uc_mcontext.__gregs[_REG_EDX])
358 #define ESI_sig(context) ((context)->uc_mcontext.__gregs[_REG_ESI])
359 #define EDI_sig(context) ((context)->uc_mcontext.__gregs[_REG_EDI])
360 #define EBP_sig(context) ((context)->uc_mcontext.__gregs[_REG_EBP])
361 #define ESP_sig(context) _UC_MACHINE_SP(context)
362
363 #define CS_sig(context) ((context)->uc_mcontext.__gregs[_REG_CS])
364 #define DS_sig(context) ((context)->uc_mcontext.__gregs[_REG_DS])
365 #define ES_sig(context) ((context)->uc_mcontext.__gregs[_REG_ES])
366 #define SS_sig(context) ((context)->uc_mcontext.__gregs[_REG_SS])
367 #define FS_sig(context) ((context)->uc_mcontext.__gregs[_REG_FS])
368 #define GS_sig(context) ((context)->uc_mcontext.__gregs[_REG_GS])
369
370 #define EFL_sig(context) ((context)->uc_mcontext.__gregs[_REG_EFL])
371 #define EIP_sig(context) _UC_MACHINE_PC(context)
372 #define TRAP_sig(context) ((context)->uc_mcontext.__gregs[_REG_TRAPNO])
373 #define ERROR_sig(context) ((context)->uc_mcontext.__gregs[_REG_ERR])
374
375 #define FPU_sig(context) NULL
376 #define FPUX_sig(context) ((XSAVE_FORMAT *)&((context)->uc_mcontext.__fpregs))
377 #define XState_sig(context) NULL /* FIXME */
378
379 #define T_MCHK T_MCA
380 #define T_XMMFLT T_XMM
381
382 #elif defined(__GNU__)
383
384 #include <mach/i386/mach_i386.h>
385 #include <mach/mach_traps.h>
386
387 #define EAX_sig(context) ((context)->uc_mcontext.gregs[REG_EAX])
388 #define EBX_sig(context) ((context)->uc_mcontext.gregs[REG_EBX])
389 #define ECX_sig(context) ((context)->uc_mcontext.gregs[REG_ECX])
390 #define EDX_sig(context) ((context)->uc_mcontext.gregs[REG_EDX])
391 #define ESI_sig(context) ((context)->uc_mcontext.gregs[REG_ESI])
392 #define EDI_sig(context) ((context)->uc_mcontext.gregs[REG_EDI])
393 #define EBP_sig(context) ((context)->uc_mcontext.gregs[REG_EBP])
394 #define ESP_sig(context) ((context)->uc_mcontext.gregs[REG_ESP])
395
396 #define CS_sig(context) ((context)->uc_mcontext.gregs[REG_CS])
397 #define DS_sig(context) ((context)->uc_mcontext.gregs[REG_DS])
398 #define ES_sig(context) ((context)->uc_mcontext.gregs[REG_ES])
399 #define SS_sig(context) ((context)->uc_mcontext.gregs[REG_SS])
400 #define FS_sig(context) ((context)->uc_mcontext.gregs[REG_FS])
401 #define GS_sig(context) ((context)->uc_mcontext.gregs[REG_GS])
402
403 #define EFL_sig(context) ((context)->uc_mcontext.gregs[REG_EFL])
404 #define EIP_sig(context) ((context)->uc_mcontext.gregs[REG_EIP])
405 #define TRAP_sig(context) ((context)->uc_mcontext.gregs[REG_TRAPNO])
406 #define ERROR_sig(context) ((context)->uc_mcontext.gregs[REG_ERR])
407
408 #define FPU_sig(context) ((FLOATING_SAVE_AREA *)&(context)->uc_mcontext.fpregs.fp_reg_set.fpchip_state)
409 #define FPUX_sig(context) NULL
410 #define XState_sig(context) NULL /* FIXME */
411
412 #else
413 #error You must define the signal context functions for your platform
414 #endif /* linux */
415
416 static ULONG first_ldt_entry = 32;
417
418 enum i386_trap_code
419 {
420 #if defined(__FreeBSD__) || defined (__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
421 TRAP_x86_DIVIDE = T_DIVIDE, /* Division by zero exception */
422 TRAP_x86_TRCTRAP = T_TRCTRAP, /* Single-step exception */
423 TRAP_x86_NMI = T_NMI, /* NMI interrupt */
424 TRAP_x86_BPTFLT = T_BPTFLT, /* Breakpoint exception */
425 TRAP_x86_OFLOW = T_OFLOW, /* Overflow exception */
426 TRAP_x86_BOUND = T_BOUND, /* Bound range exception */
427 TRAP_x86_PRIVINFLT = T_PRIVINFLT, /* Invalid opcode exception */
428 TRAP_x86_DNA = T_DNA, /* Device not available exception */
429 TRAP_x86_DOUBLEFLT = T_DOUBLEFLT, /* Double fault exception */
430 TRAP_x86_FPOPFLT = T_FPOPFLT, /* Coprocessor segment overrun */
431 TRAP_x86_TSSFLT = T_TSSFLT, /* Invalid TSS exception */
432 TRAP_x86_SEGNPFLT = T_SEGNPFLT, /* Segment not present exception */
433 TRAP_x86_STKFLT = T_STKFLT, /* Stack fault */
434 TRAP_x86_PROTFLT = T_PROTFLT, /* General protection fault */
435 TRAP_x86_PAGEFLT = T_PAGEFLT, /* Page fault */
436 TRAP_x86_ARITHTRAP = T_ARITHTRAP, /* Floating point exception */
437 TRAP_x86_ALIGNFLT = T_ALIGNFLT, /* Alignment check exception */
438 TRAP_x86_MCHK = T_MCHK, /* Machine check exception */
439 TRAP_x86_CACHEFLT = T_XMMFLT /* Cache flush exception */
440 #else
441 TRAP_x86_DIVIDE = 0, /* Division by zero exception */
442 TRAP_x86_TRCTRAP = 1, /* Single-step exception */
443 TRAP_x86_NMI = 2, /* NMI interrupt */
444 TRAP_x86_BPTFLT = 3, /* Breakpoint exception */
445 TRAP_x86_OFLOW = 4, /* Overflow exception */
446 TRAP_x86_BOUND = 5, /* Bound range exception */
447 TRAP_x86_PRIVINFLT = 6, /* Invalid opcode exception */
448 TRAP_x86_DNA = 7, /* Device not available exception */
449 TRAP_x86_DOUBLEFLT = 8, /* Double fault exception */
450 TRAP_x86_FPOPFLT = 9, /* Coprocessor segment overrun */
451 TRAP_x86_TSSFLT = 10, /* Invalid TSS exception */
452 TRAP_x86_SEGNPFLT = 11, /* Segment not present exception */
453 TRAP_x86_STKFLT = 12, /* Stack fault */
454 TRAP_x86_PROTFLT = 13, /* General protection fault */
455 TRAP_x86_PAGEFLT = 14, /* Page fault */
456 TRAP_x86_ARITHTRAP = 16, /* Floating point exception */
457 TRAP_x86_ALIGNFLT = 17, /* Alignment check exception */
458 TRAP_x86_MCHK = 18, /* Machine check exception */
459 TRAP_x86_CACHEFLT = 19 /* SIMD exception (via SIGFPE) if CPU is SSE capable
460 otherwise Cache flush exception (via SIGSEV) */
461 #endif
462 };
463
464 struct syscall_xsave
465 {
466 union
467 {
468 XSAVE_FORMAT xsave;
469 FLOATING_SAVE_AREA fsave;
470 } u;
471 struct
472 {
473 ULONG64 mask;
474 ULONG64 compaction_mask;
475 ULONG64 reserved[6];
476 M128A ymm_high[8];
477 } xstate;
478 };
479
480 C_ASSERT( sizeof(struct syscall_xsave) == 0x2c0 );
481
482 struct syscall_frame
483 {
484 DWORD restore_flags; /* 00 */
485 DWORD eflags; /* 04 */
486 DWORD eip; /* 08 */
487 DWORD esp; /* 0c */
488 WORD cs; /* 10 */
489 WORD ss; /* 12 */
490 WORD ds; /* 14 */
491 WORD es; /* 16 */
492 WORD fs; /* 18 */
493 WORD gs; /* 1a */
494 DWORD eax; /* 1c */
495 DWORD ebx; /* 20 */
496 DWORD ecx; /* 24 */
497 DWORD edx; /* 28 */
498 DWORD edi; /* 2c */
499 DWORD esi; /* 30 */
500 DWORD ebp; /* 34 */
501 };
502
503 C_ASSERT( sizeof(struct syscall_frame) == 0x38 );
504
505 struct x86_thread_data
506 {
507 DWORD fs; /* 1d4 TEB selector */
508 DWORD gs; /* 1d8 libc selector; update winebuild if you move this! */
509 DWORD dr0; /* 1dc debug registers */
510 DWORD dr1; /* 1e0 */
511 DWORD dr2; /* 1e4 */
512 DWORD dr3; /* 1e8 */
513 DWORD dr6; /* 1ec */
514 DWORD dr7; /* 1f0 */
515 void *exit_frame; /* 1f4 exit frame pointer */
516 struct syscall_frame *syscall_frame; /* 1f8 frame pointer on syscall entry */
517 };
518
519 C_ASSERT( sizeof(struct x86_thread_data) <= sizeof(((struct ntdll_thread_data *)0)->cpu_data) );
520 C_ASSERT( offsetof( TEB, GdiTebBatch ) + offsetof( struct x86_thread_data, gs ) == 0x1d8 );
521 C_ASSERT( offsetof( TEB, GdiTebBatch ) + offsetof( struct x86_thread_data, exit_frame ) == 0x1f4 );
522 C_ASSERT( offsetof( TEB, GdiTebBatch ) + offsetof( struct x86_thread_data, syscall_frame ) == 0x1f8 );
523
524 /* flags to control the behavior of the syscall dispatcher */
525 #define SYSCALL_HAVE_XSAVE 1
526 #define SYSCALL_HAVE_XSAVEC 2
527 #define SYSCALL_HAVE_FXSAVE 4
528
529 static inline struct x86_thread_data *x86_thread_data(void)
530 {
531 return (struct x86_thread_data *)ntdll_get_thread_data()->cpu_data;
532 }
533
534 static struct syscall_xsave *get_syscall_xsave( struct syscall_frame *frame )
535 {
536 return (struct syscall_xsave *)((ULONG_PTR)((struct syscall_xsave *)frame - 1) & ~63);
537 }
538
539 static inline WORD get_cs(void) { WORD res; __asm__( "movw %%cs,%0" : "=r" (res) ); return res; }
540 static inline WORD get_ds(void) { WORD res; __asm__( "movw %%ds,%0" : "=r" (res) ); return res; }
541 static inline WORD get_fs(void) { WORD res; __asm__( "movw %%fs,%0" : "=r" (res) ); return res; }
542 static inline WORD get_gs(void) { WORD res; __asm__( "movw %%gs,%0" : "=r" (res) ); return res; }
543 static inline void set_fs( WORD val ) { __asm__( "mov %0,%%fs" :: "r" (val)); }
544 static inline void set_gs( WORD val ) { __asm__( "mov %0,%%gs" :: "r" (val)); }
545
546
547 /***********************************************************************
548 * unwind_builtin_dll
549 */
550 NTSTATUS CDECL unwind_builtin_dll( ULONG type, struct _DISPATCHER_CONTEXT *dispatch, CONTEXT *context )
551 {
552 return STATUS_UNSUCCESSFUL;
553 }
554
555
556 /***********************************************************************
557 * is_gdt_sel
558 */
559 static inline int is_gdt_sel( WORD sel )
560 {
561 return !(sel & 4);
562 }
563
564
565 /***********************************************************************
566 * ldt_is_system
567 */
568 static inline int ldt_is_system( WORD sel )
569 {
570 return is_gdt_sel( sel ) || ((sel >> 3) < first_ldt_entry);
571 }
572
573
574 /***********************************************************************
575 * get_current_teb
576 *
577 * Get the current teb based on the stack pointer.
578 */
579 static inline TEB *get_current_teb(void)
580 {
581 unsigned long esp;
582 __asm__("movl %%esp,%0" : "=g" (esp) );
583 return (TEB *)((esp & ~signal_stack_mask) + teb_offset);
584 }
585
586
587 #ifdef __sun
588
589 /* We have to workaround two Solaris breakages:
590 * - Solaris doesn't restore %ds and %es before calling the signal handler so exceptions in 16-bit
591 * code crash badly.
592 * - Solaris inserts a libc trampoline to call our handler, but the trampoline expects that registers
593 * are setup correctly. So we need to insert our own trampoline below the libc trampoline to set %gs.
594 */
595
596 extern int sigaction_syscall( int sig, const struct sigaction *new, struct sigaction *old );
597 __ASM_GLOBAL_FUNC( sigaction_syscall,
598 "movl $0x62,%eax\n\t"
599 "int $0x91\n\t"
600 "ret" )
601
602 /* assume the same libc handler is used for all signals */
603 static void (*libc_sigacthandler)( int signal, siginfo_t *siginfo, void *context );
604
605 static void wine_sigacthandler( int signal, siginfo_t *siginfo, void *sigcontext )
606 {
607 struct x86_thread_data *thread_data;
608
609 __asm__ __volatile__("mov %ss,%ax; mov %ax,%ds; mov %ax,%es");
610
611 thread_data = (struct x86_thread_data *)get_current_teb()->GdiTebBatch;
612 set_fs( thread_data->fs );
613 set_gs( thread_data->gs );
614
615 libc_sigacthandler( signal, siginfo, sigcontext );
616 }
617
618 static int solaris_sigaction( int sig, const struct sigaction *new, struct sigaction *old )
619 {
620 struct sigaction real_act;
621
622 if (sigaction( sig, new, old ) == -1) return -1;
623
624 /* retrieve the real handler and flags with a direct syscall */
625 sigaction_syscall( sig, NULL, &real_act );
626 libc_sigacthandler = real_act.sa_sigaction;
627 real_act.sa_sigaction = wine_sigacthandler;
628 sigaction_syscall( sig, &real_act, NULL );
629 return 0;
630 }
631 #define sigaction(sig,new,old) solaris_sigaction(sig,new,old)
632
633 #endif
634
635 extern void clear_alignment_flag(void) DECLSPEC_HIDDEN;
636 __ASM_GLOBAL_FUNC( clear_alignment_flag,
637 "pushfl\n\t"
638 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
639 "andl $~0x40000,(%esp)\n\t"
640 "popfl\n\t"
641 __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
642 "ret" )
643
644
645 /***********************************************************************
646 * init_handler
647 *
648 * Handler initialization when the full context is not needed.
649 * Return the stack pointer to use for pushing the exception data.
650 */
651 static inline void *init_handler( const ucontext_t *sigcontext )
652 {
653 TEB *teb = get_current_teb();
654
655 clear_alignment_flag();
656
657 #ifndef __sun /* see above for Solaris handling */
658 {
659 struct x86_thread_data *thread_data = (struct x86_thread_data *)&teb->GdiTebBatch;
660 set_fs( thread_data->fs );
661 set_gs( thread_data->gs );
662 }
663 #endif
664
665 if (!ldt_is_system(CS_sig(sigcontext)) || !ldt_is_system(SS_sig(sigcontext))) /* 16-bit mode */
666 {
667 /*
668 * Win16 or DOS protected mode. Note that during switch
669 * from 16-bit mode to linear mode, CS may be set to system
670 * segment before FS is restored. Fortunately, in this case
671 * SS is still non-system segment. This is why both CS and SS
672 * are checked.
673 */
674 return teb->SystemReserved1[0];
675 }
676 return (void *)(ESP_sig(sigcontext) & ~3);
677 }
678
679
680 /***********************************************************************
681 * save_fpu
682 *
683 * Save the thread FPU context.
684 */
685 static inline void save_fpu( CONTEXT *context )
686 {
687 struct
688 {
689 DWORD ControlWord;
690 DWORD StatusWord;
691 DWORD TagWord;
692 DWORD ErrorOffset;
693 DWORD ErrorSelector;
694 DWORD DataOffset;
695 DWORD DataSelector;
696 }
697 float_status;
698
699 context->ContextFlags |= CONTEXT_FLOATING_POINT;
700 __asm__ __volatile__( "fnsave %0; fwait" : "=m" (context->FloatSave) );
701
702 /* Reset unmasked exceptions status to avoid firing an exception. */
703 memcpy(&float_status, &context->FloatSave, sizeof(float_status));
704 float_status.StatusWord &= float_status.ControlWord | 0xffffff80;
705
706 __asm__ __volatile__( "fldenv %0" : : "m" (float_status) );
707 }
708
709
710 /***********************************************************************
711 * restore_fpu
712 *
713 * Restore the x87 FPU context
714 */
715 static inline void restore_fpu( const CONTEXT *context )
716 {
717 FLOATING_SAVE_AREA float_status = context->FloatSave;
718 /* reset the current interrupt status */
719 float_status.StatusWord &= float_status.ControlWord | 0xffffff80;
720 __asm__ __volatile__( "frstor %0; fwait" : : "m" (float_status) );
721 }
722
723
724 /***********************************************************************
725 * fpux_to_fpu
726 *
727 * Build a standard FPU context from an extended one.
728 */
729 static void fpux_to_fpu( FLOATING_SAVE_AREA *fpu, const XSAVE_FORMAT *fpux )
730 {
731 unsigned int i, tag, stack_top;
732
733 fpu->ControlWord = fpux->ControlWord | 0xffff0000;
734 fpu->StatusWord = fpux->StatusWord | 0xffff0000;
735 fpu->ErrorOffset = fpux->ErrorOffset;
736 fpu->ErrorSelector = fpux->ErrorSelector | (fpux->ErrorOpcode << 16);
737 fpu->DataOffset = fpux->DataOffset;
738 fpu->DataSelector = fpux->DataSelector;
739 fpu->Cr0NpxState = fpux->StatusWord | 0xffff0000;
740
741 stack_top = (fpux->StatusWord >> 11) & 7;
742 fpu->TagWord = 0xffff0000;
743 for (i = 0; i < 8; i++)
744 {
745 memcpy( &fpu->RegisterArea[10 * i], &fpux->FloatRegisters[i], 10 );
746 if (!(fpux->TagWord & (1 << i))) tag = 3; /* empty */
747 else
748 {
749 const M128A *reg = &fpux->FloatRegisters[(i - stack_top) & 7];
750 if ((reg->High & 0x7fff) == 0x7fff) /* exponent all ones */
751 {
752 tag = 2; /* special */
753 }
754 else if (!(reg->High & 0x7fff)) /* exponent all zeroes */
755 {
756 if (reg->Low) tag = 2; /* special */
757 else tag = 1; /* zero */
758 }
759 else
760 {
761 if (reg->Low >> 63) tag = 0; /* valid */
762 else tag = 2; /* special */
763 }
764 }
765 fpu->TagWord |= tag << (2 * i);
766 }
767 }
768
769
770 /***********************************************************************
771 * fpu_to_fpux
772 *
773 * Fill extended FPU context from standard one.
774 */
775 static void fpu_to_fpux( XSAVE_FORMAT *fpux, const FLOATING_SAVE_AREA *fpu )
776 {
777 unsigned int i;
778
779 fpux->ControlWord = fpu->ControlWord;
780 fpux->StatusWord = fpu->StatusWord;
781 fpux->ErrorOffset = fpu->ErrorOffset;
782 fpux->ErrorSelector = fpu->ErrorSelector;
783 fpux->ErrorOpcode = fpu->ErrorSelector >> 16;
784 fpux->DataOffset = fpu->DataOffset;
785 fpux->DataSelector = fpu->DataSelector;
786 fpux->TagWord = 0;
787 for (i = 0; i < 8; i++)
788 {
789 if (((fpu->TagWord >> (i * 2)) & 3) != 3)
790 fpux->TagWord |= 1 << i;
791 memcpy( &fpux->FloatRegisters[i], &fpu->RegisterArea[10 * i], 10 );
792 }
793 }
794
795
796 /***********************************************************************
797 * save_context
798 *
799 * Build a context structure from the signal info.
800 */
801 static inline void save_context( struct xcontext *xcontext, const ucontext_t *sigcontext )
802 {
803 FLOATING_SAVE_AREA *fpu = FPU_sig(sigcontext);
804 XSAVE_FORMAT *fpux = FPUX_sig(sigcontext);
805 CONTEXT *context = &xcontext->c;
806
807 memset(context, 0, sizeof(*context));
808 context->ContextFlags = CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS;
809 context->Eax = EAX_sig(sigcontext);
810 context->Ebx = EBX_sig(sigcontext);
811 context->Ecx = ECX_sig(sigcontext);
812 context->Edx = EDX_sig(sigcontext);
813 context->Esi = ESI_sig(sigcontext);
814 context->Edi = EDI_sig(sigcontext);
815 context->Ebp = EBP_sig(sigcontext);
816 context->EFlags = EFL_sig(sigcontext);
817 context->Eip = EIP_sig(sigcontext);
818 context->Esp = ESP_sig(sigcontext);
819 context->SegCs = LOWORD(CS_sig(sigcontext));
820 context->SegDs = LOWORD(DS_sig(sigcontext));
821 context->SegEs = LOWORD(ES_sig(sigcontext));
822 context->SegFs = LOWORD(FS_sig(sigcontext));
823 context->SegGs = LOWORD(GS_sig(sigcontext));
824 context->SegSs = LOWORD(SS_sig(sigcontext));
825 context->Dr0 = x86_thread_data()->dr0;
826 context->Dr1 = x86_thread_data()->dr1;
827 context->Dr2 = x86_thread_data()->dr2;
828 context->Dr3 = x86_thread_data()->dr3;
829 context->Dr6 = x86_thread_data()->dr6;
830 context->Dr7 = x86_thread_data()->dr7;
831
832 if (fpu)
833 {
834 context->ContextFlags |= CONTEXT_FLOATING_POINT;
835 context->FloatSave = *fpu;
836 }
837 if (fpux)
838 {
839 XSTATE *xs;
840
841 context->ContextFlags |= CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS;
842 memcpy( context->ExtendedRegisters, fpux, sizeof(*fpux) );
843 if (!fpu) fpux_to_fpu( &context->FloatSave, fpux );
844 if ((cpu_info.ProcessorFeatureBits & CPU_FEATURE_AVX) && (xs = XState_sig(fpux)))
845 {
846 context_init_xstate( context, xs );
847 xcontext->host_compaction_mask = xs->CompactionMask;
848 }
849 }
850 if (!fpu && !fpux) save_fpu( context );
851 }
852
853
854 /***********************************************************************
855 * restore_context
856 *
857 * Restore the signal info from the context.
858 */
859 static inline void restore_context( const struct xcontext *xcontext, ucontext_t *sigcontext )
860 {
861 FLOATING_SAVE_AREA *fpu = FPU_sig(sigcontext);
862 XSAVE_FORMAT *fpux = FPUX_sig(sigcontext);
863 const CONTEXT *context = &xcontext->c;
864
865 x86_thread_data()->dr0 = context->Dr0;
866 x86_thread_data()->dr1 = context->Dr1;
867 x86_thread_data()->dr2 = context->Dr2;
868 x86_thread_data()->dr3 = context->Dr3;
869 x86_thread_data()->dr6 = context->Dr6;
870 x86_thread_data()->dr7 = context->Dr7;
871 EAX_sig(sigcontext) = context->Eax;
872 EBX_sig(sigcontext) = context->Ebx;
873 ECX_sig(sigcontext) = context->Ecx;
874 EDX_sig(sigcontext) = context->Edx;
875 ESI_sig(sigcontext) = context->Esi;
876 EDI_sig(sigcontext) = context->Edi;
877 EBP_sig(sigcontext) = context->Ebp;
878 EFL_sig(sigcontext) = context->EFlags;
879 EIP_sig(sigcontext) = context->Eip;
880 ESP_sig(sigcontext) = context->Esp;
881 CS_sig(sigcontext) = context->SegCs;
882 DS_sig(sigcontext) = context->SegDs;
883 ES_sig(sigcontext) = context->SegEs;
884 FS_sig(sigcontext) = context->SegFs;
885 GS_sig(sigcontext) = context->SegGs;
886 SS_sig(sigcontext) = context->SegSs;
887
888 if (fpu) *fpu = context->FloatSave;
889 if (fpux)
890 {
891 XSTATE *src_xs, *dst_xs;
892
893 memcpy( fpux, context->ExtendedRegisters, sizeof(*fpux) );
894
895 if ((dst_xs = XState_sig(fpux)) && (src_xs = xstate_from_context( context )))
896 {
897 memcpy( &dst_xs->YmmContext, &src_xs->YmmContext, sizeof(dst_xs->YmmContext) );
898 dst_xs->Mask |= src_xs->Mask;
899 dst_xs->CompactionMask = xcontext->host_compaction_mask;
900 }
901 }
902 if (!fpu && !fpux) restore_fpu( context );
903 }
904
905
906 /***********************************************************************
907 * signal_restore_full_cpu_context
908 *
909 * Restore full context from syscall frame
910 */
911 void signal_restore_full_cpu_context(void)
912 {
913 x86_thread_data()->syscall_frame->restore_flags |= CONTEXT_INTEGER;
914 }
915
916
917 /***********************************************************************
918 * NtSetContextThread (NTDLL.@)
919 * ZwSetContextThread (NTDLL.@)
920 */
921 NTSTATUS WINAPI NtSetContextThread( HANDLE handle, const CONTEXT *context )
922 {
923 NTSTATUS ret = STATUS_SUCCESS;
924 struct syscall_frame *frame = x86_thread_data()->syscall_frame;
925 DWORD flags = context->ContextFlags & ~CONTEXT_i386;
926 BOOL self = (handle == GetCurrentThread());
927
928 if ((flags & CONTEXT_XSTATE) && (cpu_info.ProcessorFeatureBits & CPU_FEATURE_AVX))
929 {
930 CONTEXT_EX *context_ex = (CONTEXT_EX *)(context + 1);
931 XSTATE *xs = (XSTATE *)((char *)context_ex + context_ex->XState.Offset);
932
933 if (context_ex->XState.Length < offsetof(XSTATE, YmmContext) ||
934 context_ex->XState.Length > sizeof(XSTATE))
935 return STATUS_INVALID_PARAMETER;
936 if ((xs->Mask & XSTATE_MASK_GSSE) && (context_ex->XState.Length < sizeof(XSTATE)))
937 return STATUS_BUFFER_OVERFLOW;
938 }
939 else flags &= ~CONTEXT_XSTATE;
940
941 /* debug registers require a server call */
942 if (self && (flags & CONTEXT_DEBUG_REGISTERS))
943 self = (x86_thread_data()->dr0 == context->Dr0 &&
944 x86_thread_data()->dr1 == context->Dr1 &&
945 x86_thread_data()->dr2 == context->Dr2 &&
946 x86_thread_data()->dr3 == context->Dr3 &&
947 x86_thread_data()->dr6 == context->Dr6 &&
948 x86_thread_data()->dr7 == context->Dr7);
949
950 if (!self)
951 {
952 ret = set_thread_context( handle, context, &self, IMAGE_FILE_MACHINE_I386 );
953 if (ret || !self) return ret;
954 if (flags & CONTEXT_DEBUG_REGISTERS)
955 {
956 x86_thread_data()->dr0 = context->Dr0;
957 x86_thread_data()->dr1 = context->Dr1;
958 x86_thread_data()->dr2 = context->Dr2;
959 x86_thread_data()->dr3 = context->Dr3;
960 x86_thread_data()->dr6 = context->Dr6;
961 x86_thread_data()->dr7 = context->Dr7;
962 }
963 }
964
965 if (flags & CONTEXT_INTEGER)
966 {
967 frame->eax = context->Eax;
968 frame->ebx = context->Ebx;
969 frame->ecx = context->Ecx;
970 frame->edx = context->Edx;
971 frame->esi = context->Esi;
972 frame->edi = context->Edi;
973 }
974 if (flags & CONTEXT_CONTROL)
975 {
976 frame->esp = context->Esp;
977 frame->ebp = context->Ebp;
978 frame->eip = context->Eip;
979 frame->eflags = context->EFlags;
980 frame->cs = context->SegCs;
981 frame->ss = context->SegSs;
982 }
983 if (flags & CONTEXT_SEGMENTS)
984 {
985 frame->ds = context->SegDs;
986 frame->es = context->SegEs;
987 frame->fs = context->SegFs;
988 frame->gs = context->SegGs;
989 }
990 if (flags & CONTEXT_EXTENDED_REGISTERS)
991 {
992 struct syscall_xsave *xsave = get_syscall_xsave( frame );
993 memcpy( &xsave->u.xsave, context->ExtendedRegisters, sizeof(xsave->u.xsave) );
994 /* reset the current interrupt status */
995 xsave->u.xsave.StatusWord &= xsave->u.xsave.ControlWord | 0xff80;
996 xsave->xstate.mask |= XSTATE_MASK_LEGACY;
997 }
998 else if (flags & CONTEXT_FLOATING_POINT)
999 {
1000 struct syscall_xsave *xsave = get_syscall_xsave( frame );
1001 if (cpu_info.ProcessorFeatureBits & CPU_FEATURE_FXSR)
1002 {
1003 fpu_to_fpux( &xsave->u.xsave, &context->FloatSave );
1004 }
1005 else
1006 {
1007 xsave->u.fsave = context->FloatSave;
1008 }
1009 xsave->xstate.mask |= XSTATE_MASK_LEGACY_FLOATING_POINT;
1010 }
1011 if (flags & CONTEXT_XSTATE)
1012 {
1013 struct syscall_xsave *xsave = get_syscall_xsave( frame );
1014 CONTEXT_EX *context_ex = (CONTEXT_EX *)(context + 1);
1015 XSTATE *xs = (XSTATE *)((char *)context_ex + context_ex->XState.Offset);
1016
1017 if (xs->Mask & XSTATE_MASK_GSSE)
1018 {
1019 xsave->xstate.mask |= XSTATE_MASK_GSSE;
1020 memcpy( &xsave->xstate.ymm_high, &xs->YmmContext, sizeof(xsave->xstate.ymm_high) );
1021 }
1022 else xsave->xstate.mask &= ~XSTATE_MASK_GSSE;
1023 }
1024
1025 frame->restore_flags |= flags & ~CONTEXT_INTEGER;
1026 return STATUS_SUCCESS;
1027 }
1028
1029
1030 /***********************************************************************
1031 * NtGetContextThread (NTDLL.@)
1032 * ZwGetContextThread (NTDLL.@)
1033 *
1034 * Note: we use a small assembly wrapper to save the necessary registers
1035 * in case we are fetching the context of the current thread.
1036 */
1037 NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context )
1038 {
1039 struct syscall_frame *frame = x86_thread_data()->syscall_frame;
1040 DWORD needed_flags = context->ContextFlags & ~CONTEXT_i386;
1041 BOOL self = (handle == GetCurrentThread());
1042 NTSTATUS ret;
1043
1044 /* debug registers require a server call */
1045 if (needed_flags & CONTEXT_DEBUG_REGISTERS) self = FALSE;
1046
1047 if (!self)
1048 {
1049 if ((ret = get_thread_context( handle, context, &self, IMAGE_FILE_MACHINE_I386 ))) return ret;
1050 needed_flags &= ~context->ContextFlags;
1051 }
1052
1053 if (self)
1054 {
1055 struct syscall_xsave *xsave = get_syscall_xsave( frame );
1056 XSTATE *xstate;
1057 if (needed_flags & CONTEXT_INTEGER)
1058 {
1059 context->Eax = frame->eax;
1060 context->Ebx = frame->ebx;
1061 context->Ecx = frame->ecx;
1062 context->Edx = frame->edx;
1063 context->Esi = frame->esi;
1064 context->Edi = frame->edi;
1065 context->ContextFlags |= CONTEXT_INTEGER;
1066 }
1067 if (needed_flags & CONTEXT_CONTROL)
1068 {
1069 context->Esp = frame->esp;
1070 context->Ebp = frame->ebp;
1071 context->Eip = frame->eip;
1072 context->EFlags = frame->eflags;
1073 context->SegCs = frame->cs;
1074 context->SegSs = frame->ss;
1075 context->ContextFlags |= CONTEXT_CONTROL;
1076 }
1077 if (needed_flags & CONTEXT_SEGMENTS)
1078 {
1079 context->SegDs = frame->ds;
1080 context->SegEs = frame->es;
1081 context->SegFs = frame->fs;
1082 context->SegGs = frame->gs;
1083 context->ContextFlags |= CONTEXT_SEGMENTS;
1084 }
1085 if (needed_flags & CONTEXT_FLOATING_POINT)
1086 {
1087 if (!(cpu_info.ProcessorFeatureBits & CPU_FEATURE_FXSR))
1088 {
1089 context->FloatSave = xsave->u.fsave;
1090 }
1091 else if (!xstate_compaction_enabled ||
1092 (xsave->xstate.mask & XSTATE_MASK_LEGACY_FLOATING_POINT))
1093 {
1094 fpux_to_fpu( &context->FloatSave, &xsave->u.xsave );
1095 }
1096 else
1097 {
1098 memset( &context->FloatSave, 0, sizeof(context->FloatSave) );
1099 context->FloatSave.ControlWord = 0x37f;
1100 }
1101 context->ContextFlags |= CONTEXT_FLOATING_POINT;
1102 }
1103 if (needed_flags & CONTEXT_EXTENDED_REGISTERS)
1104 {
1105 XSAVE_FORMAT *xs = (XSAVE_FORMAT *)context->ExtendedRegisters;
1106
1107 if (!xstate_compaction_enabled ||
1108 (xsave->xstate.mask & XSTATE_MASK_LEGACY_FLOATING_POINT))
1109 {
1110 memcpy( xs, &xsave->u.xsave, FIELD_OFFSET( XSAVE_FORMAT, MxCsr ));
1111 memcpy( xs->FloatRegisters, xsave->u.xsave.FloatRegisters,
1112 sizeof( xs->FloatRegisters ));
1113 }
1114 else
1115 {
1116 memset( xs, 0, FIELD_OFFSET( XSAVE_FORMAT, MxCsr ));
1117 memset( xs->FloatRegisters, 0, sizeof( xs->FloatRegisters ));
1118 xs->ControlWord = 0x37f;
1119 }
1120
1121 if (!xstate_compaction_enabled || (xsave->xstate.mask & XSTATE_MASK_LEGACY_SSE))
1122 {
1123 memcpy( xs->XmmRegisters, xsave->u.xsave.XmmRegisters, sizeof( xs->XmmRegisters ));
1124 xs->MxCsr = xsave->u.xsave.MxCsr;
1125 xs->MxCsr_Mask = xsave->u.xsave.MxCsr_Mask;
1126 }
1127 else
1128 {
1129 memset( xs->XmmRegisters, 0, sizeof( xs->XmmRegisters ));
1130 xs->MxCsr = 0x1f80;
1131 xs->MxCsr_Mask = 0x2ffff;
1132 }
1133
1134 context->ContextFlags |= CONTEXT_EXTENDED_REGISTERS;
1135 }
1136 /* update the cached version of the debug registers */
1137 if (context->ContextFlags & (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_i386))
1138 {
1139 x86_thread_data()->dr0 = context->Dr0;
1140 x86_thread_data()->dr1 = context->Dr1;
1141 x86_thread_data()->dr2 = context->Dr2;
1142 x86_thread_data()->dr3 = context->Dr3;
1143 x86_thread_data()->dr6 = context->Dr6;
1144 x86_thread_data()->dr7 = context->Dr7;
1145 }
1146 if ((cpu_info.ProcessorFeatureBits & CPU_FEATURE_AVX) && (xstate = xstate_from_context( context )))
1147 {
1148 struct syscall_xsave *xsave = get_syscall_xsave( frame );
1149 CONTEXT_EX *context_ex = (CONTEXT_EX *)(context + 1);
1150 unsigned int mask;
1151
1152 if (context_ex->XState.Length < offsetof(XSTATE, YmmContext)
1153 || context_ex->XState.Length > sizeof(XSTATE))
1154 return STATUS_INVALID_PARAMETER;
1155
1156 mask = (xstate_compaction_enabled ? xstate->CompactionMask : xstate->Mask) & XSTATE_MASK_GSSE;
1157 xstate->Mask = xsave->xstate.mask & mask;
1158 xstate->CompactionMask = xstate_compaction_enabled ? (0x8000000000000000 | mask) : 0;
1159 memset( xstate->Reserved, 0, sizeof(xstate->Reserved) );
1160 if (xstate->Mask)
1161 {
1162 if (context_ex->XState.Length < sizeof(XSTATE))
1163 return STATUS_BUFFER_OVERFLOW;
1164
1165 memcpy( &xstate->YmmContext, xsave->xstate.ymm_high, sizeof(xsave->xstate.ymm_high) );
1166 }
1167 }
1168 }
1169
1170 if (context->ContextFlags & (CONTEXT_INTEGER & ~CONTEXT_i386))
1171 TRACE( "%p: eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n", handle,
1172 context->Eax, context->Ebx, context->Ecx, context->Edx, context->Esi, context->Edi );
1173 if (context->ContextFlags & (CONTEXT_CONTROL & ~CONTEXT_i386))
1174 TRACE( "%p: ebp=%08x esp=%08x eip=%08x cs=%04x ss=%04x flags=%08x\n", handle,
1175 context->Ebp, context->Esp, context->Eip, context->SegCs, context->SegSs, context->EFlags );
1176 if (context->ContextFlags & (CONTEXT_SEGMENTS & ~CONTEXT_i386))
1177 TRACE( "%p: ds=%04x es=%04x fs=%04x gs=%04x\n", handle,
1178 context->SegDs, context->SegEs, context->SegFs, context->SegGs );
1179 if (context->ContextFlags & (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_i386))
1180 TRACE( "%p: dr0=%08x dr1=%08x dr2=%08x dr3=%08x dr6=%08x dr7=%08x\n", handle,
1181 context->Dr0, context->Dr1, context->Dr2, context->Dr3, context->Dr6, context->Dr7 );
1182
1183 return STATUS_SUCCESS;
1184 }
1185
1186
1187 /***********************************************************************
1188 * set_thread_wow64_context
1189 */
1190 NTSTATUS set_thread_wow64_context( HANDLE handle, const void *ctx, ULONG size )
1191 {
1192 return STATUS_INVALID_INFO_CLASS;
1193 }
1194
1195
1196 /***********************************************************************
1197 * get_thread_wow64_context
1198 */
1199 NTSTATUS get_thread_wow64_context( HANDLE handle, void *ctx, ULONG size )
1200 {
1201 return STATUS_INVALID_INFO_CLASS;
1202 }
1203
1204
1205 /***********************************************************************
1206 * is_privileged_instr
1207 *
1208 * Check if the fault location is a privileged instruction.
1209 * Based on the instruction emulation code in dlls/kernel/instr.c.
1210 */
1211 static inline DWORD is_privileged_instr( CONTEXT *context )
1212 {
1213 BYTE instr[16];
1214 unsigned int i, len, prefix_count = 0;
1215
1216 if (!ldt_is_system( context->SegCs )) return 0;
1217 len = virtual_uninterrupted_read_memory( (BYTE *)context->Eip, instr, sizeof(instr) );
1218
1219 for (i = 0; i < len; i++) switch (instr[i])
1220 {
1221 /* instruction prefixes */
1222 case 0x2e: /* %cs: */
1223 case 0x36: /* %ss: */
1224 case 0x3e: /* %ds: */
1225 case 0x26: /* %es: */
1226 case 0x64: /* %fs: */
1227 case 0x65: /* %gs: */
1228 case 0x66: /* opcode size */
1229 case 0x67: /* addr size */
1230 case 0xf0: /* lock */
1231 case 0xf2: /* repne */
1232 case 0xf3: /* repe */
1233 if (++prefix_count >= 15) return EXCEPTION_ILLEGAL_INSTRUCTION;
1234 continue;
1235
1236 case 0x0f: /* extended instruction */
1237 if (i == len - 1) return 0;
1238 switch(instr[i + 1])
1239 {
1240 case 0x20: /* mov crX, reg */
1241 case 0x21: /* mov drX, reg */
1242 case 0x22: /* mov reg, crX */
1243 case 0x23: /* mov reg drX */
1244 return EXCEPTION_PRIV_INSTRUCTION;
1245 }
1246 return 0;
1247 case 0x6c: /* insb (%dx) */
1248 case 0x6d: /* insl (%dx) */
1249 case 0x6e: /* outsb (%dx) */
1250 case 0x6f: /* outsl (%dx) */
1251 case 0xcd: /* int $xx */
1252 case 0xe4: /* inb al,XX */
1253 case 0xe5: /* in (e)ax,XX */
1254 case 0xe6: /* outb XX,al */
1255 case 0xe7: /* out XX,(e)ax */
1256 case 0xec: /* inb (%dx),%al */
1257 case 0xed: /* inl (%dx),%eax */
1258 case 0xee: /* outb %al,(%dx) */
1259 case 0xef: /* outl %eax,(%dx) */
1260 case 0xf4: /* hlt */
1261 case 0xfa: /* cli */
1262 case 0xfb: /* sti */
1263 return EXCEPTION_PRIV_INSTRUCTION;
1264 default:
1265 return 0;
1266 }
1267 return 0;
1268 }
1269
1270
1271 /***********************************************************************
1272 * check_invalid_gs
1273 *
1274 * Check for fault caused by invalid %gs value (some copy protection schemes mess with it).
1275 */
1276 static inline BOOL check_invalid_gs( ucontext_t *sigcontext, CONTEXT *context )
1277 {
1278 unsigned int prefix_count = 0;
1279 const BYTE *instr = (BYTE *)context->Eip;
1280 WORD system_gs = x86_thread_data()->gs;
1281
1282 if (context->SegGs == system_gs) return FALSE;
1283 if (!ldt_is_system( context->SegCs )) return FALSE;
1284 /* only handle faults in system libraries */
1285 if (virtual_is_valid_code_address( instr, 1 )) return FALSE;
1286
1287 for (;;) switch(*instr)
1288 {
1289 /* instruction prefixes */
1290 case 0x2e: /* %cs: */
1291 case 0x36: /* %ss: */
1292 case 0x3e: /* %ds: */
1293 case 0x26: /* %es: */
1294 case 0x64: /* %fs: */
1295 case 0x66: /* opcode size */
1296 case 0x67: /* addr size */
1297 case 0xf0: /* lock */
1298 case 0xf2: /* repne */
1299 case 0xf3: /* repe */
1300 if (++prefix_count >= 15) return FALSE;
1301 instr++;
1302 continue;
1303 case 0x65: /* %gs: */
1304 TRACE( "%04x/%04x at %p, fixing up\n", context->SegGs, system_gs, instr );
1305 GS_sig(sigcontext) = system_gs;
1306 return TRUE;
1307 default:
1308 return FALSE;
1309 }
1310 }
1311
1312
1313 #include "pshpack1.h"
1314 union atl_thunk
1315 {
1316 struct
1317 {
1318 DWORD movl; /* movl this,4(%esp) */
1319 DWORD this;
1320 BYTE jmp; /* jmp func */
1321 int func;
1322 } t1;
1323 struct
1324 {
1325 BYTE movl; /* movl this,ecx */
1326 DWORD this;
1327 BYTE jmp; /* jmp func */
1328 int func;
1329 } t2;
1330 struct
1331 {
1332 BYTE movl1; /* movl this,edx */
1333 DWORD this;
1334 BYTE movl2; /* movl func,ecx */
1335 DWORD func;
1336 WORD jmp; /* jmp ecx */
1337 } t3;
1338 struct
1339 {
1340 BYTE movl1; /* movl this,ecx */
1341 DWORD this;
1342 BYTE movl2; /* movl func,eax */
1343 DWORD func;
1344 WORD jmp; /* jmp eax */
1345 } t4;
1346 struct
1347 {
1348 DWORD inst1; /* pop ecx
1349 * pop eax
1350 * push ecx
1351 * jmp 4(%eax) */
1352 WORD inst2;
1353 } t5;
1354 };
1355 #include "poppack.h"
1356
1357 /**********************************************************************
1358 * check_atl_thunk
1359 *
1360 * Check if code destination is an ATL thunk, and emulate it if so.
1361 */
1362 static BOOL check_atl_thunk( ucontext_t *sigcontext, EXCEPTION_RECORD *rec, CONTEXT *context )
1363 {
1364 const union atl_thunk *thunk = (const union atl_thunk *)rec->ExceptionInformation[1];
1365 union atl_thunk thunk_copy;
1366 SIZE_T thunk_len;
1367
1368 thunk_len = virtual_uninterrupted_read_memory( thunk, &thunk_copy, sizeof(*thunk) );
1369 if (!thunk_len) return FALSE;
1370
1371 if (thunk_len >= sizeof(thunk_copy.t1) && thunk_copy.t1.movl == 0x042444c7 &&
1372 thunk_copy.t1.jmp == 0xe9)
1373 {
1374 if (!virtual_uninterrupted_write_memory( (DWORD *)context->Esp + 1,
1375 &thunk_copy.t1.this, sizeof(DWORD) ))
1376 {
1377 EIP_sig(sigcontext) = (DWORD_PTR)(&thunk->t1.func + 1) + thunk_copy.t1.func;
1378 TRACE( "emulating ATL thunk type 1 at %p, func=%08x arg=%08x\n",
1379 thunk, EIP_sig(sigcontext), thunk_copy.t1.this );
1380 return TRUE;
1381 }
1382 }
1383 else if (thunk_len >= sizeof(thunk_copy.t2) && thunk_copy.t2.movl == 0xb9 &&
1384 thunk_copy.t2.jmp == 0xe9)
1385 {
1386 ECX_sig(sigcontext) = thunk_copy.t2.this;
1387 EIP_sig(sigcontext) = (DWORD_PTR)(&thunk->t2.func + 1) + thunk_copy.t2.func;
1388 TRACE( "emulating ATL thunk type 2 at %p, func=%08x ecx=%08x\n",
1389 thunk, EIP_sig(sigcontext), ECX_sig(sigcontext) );
1390 return TRUE;
1391 }
1392 else if (thunk_len >= sizeof(thunk_copy.t3) && thunk_copy.t3.movl1 == 0xba &&
1393 thunk_copy.t3.movl2 == 0xb9 &&
1394 thunk_copy.t3.jmp == 0xe1ff)
1395 {
1396 EDX_sig(sigcontext) = thunk_copy.t3.this;
1397 ECX_sig(sigcontext) = thunk_copy.t3.func;
1398 EIP_sig(sigcontext) = thunk_copy.t3.func;
1399 TRACE( "emulating ATL thunk type 3 at %p, func=%08x ecx=%08x edx=%08x\n",
1400 thunk, EIP_sig(sigcontext), ECX_sig(sigcontext), EDX_sig(sigcontext) );
1401 return TRUE;
1402 }
1403 else if (thunk_len >= sizeof(thunk_copy.t4) && thunk_copy.t4.movl1 == 0xb9 &&
1404 thunk_copy.t4.movl2 == 0xb8 &&
1405 thunk_copy.t4.jmp == 0xe0ff)
1406 {
1407 ECX_sig(sigcontext) = thunk_copy.t4.this;
1408 EAX_sig(sigcontext) = thunk_copy.t4.func;
1409 EIP_sig(sigcontext) = thunk_copy.t4.func;
1410 TRACE( "emulating ATL thunk type 4 at %p, func=%08x eax=%08x ecx=%08x\n",
1411 thunk, EIP_sig(sigcontext), EAX_sig(sigcontext), ECX_sig(sigcontext) );
1412 return TRUE;
1413 }
1414 else if (thunk_len >= sizeof(thunk_copy.t5) && thunk_copy.t5.inst1 == 0xff515859 &&
1415 thunk_copy.t5.inst2 == 0x0460)
1416 {
1417 DWORD func, sp[2];
1418 if (virtual_uninterrupted_read_memory( (DWORD *)context->Esp, sp, sizeof(sp) ) == sizeof(sp) &&
1419 virtual_uninterrupted_read_memory( (DWORD *)sp[1] + 1, &func, sizeof(DWORD) ) == sizeof(DWORD) &&
1420 !virtual_uninterrupted_write_memory( (DWORD *)context->Esp + 1, &sp[0], sizeof(sp[0]) ))
1421 {
1422 ECX_sig(sigcontext) = sp[0];
1423 EAX_sig(sigcontext) = sp[1];
1424 ESP_sig(sigcontext) += sizeof(DWORD);
1425 EIP_sig(sigcontext) = func;
1426 TRACE( "emulating ATL thunk type 5 at %p, func=%08x eax=%08x ecx=%08x esp=%08x\n",
1427 thunk, EIP_sig(sigcontext), EAX_sig(sigcontext),
1428 ECX_sig(sigcontext), ESP_sig(sigcontext) );
1429 return TRUE;
1430 }
1431 }
1432
1433 return FALSE;
1434 }
1435
1436
1437 /***********************************************************************
1438 * setup_exception_record
1439 *
1440 * Setup the exception record and context on the thread stack.
1441 */
1442 static void *setup_exception_record( ucontext_t *sigcontext, EXCEPTION_RECORD *rec, struct xcontext *xcontext )
1443 {
1444 void *stack = init_handler( sigcontext );
1445
1446 rec->ExceptionAddress = (void *)EIP_sig( sigcontext );
1447 save_context( xcontext, sigcontext );
1448 return stack;
1449 }
1450
1451 /***********************************************************************
1452 * setup_raise_exception
1453 *
1454 * Change context to setup a call to a raise exception function.
1455 */
1456 static void setup_raise_exception( ucontext_t *sigcontext, void *stack_ptr,
1457 EXCEPTION_RECORD *rec, struct xcontext *xcontext )
1458 {
1459 CONTEXT *context = &xcontext->c;
1460 size_t stack_size;
1461 XSTATE *src_xs;
1462
1463 struct stack_layout
1464 {
1465 EXCEPTION_RECORD *rec_ptr; /* first arg for KiUserExceptionDispatcher */
1466 CONTEXT *context_ptr; /* second arg for KiUserExceptionDispatcher */
1467 CONTEXT context;
1468 CONTEXT_EX context_ex;
1469 EXCEPTION_RECORD rec;
1470 DWORD ebp;
1471 DWORD eip;
1472 char xstate[0];
1473 } *stack;
1474
1475 C_ASSERT( (offsetof(struct stack_layout, xstate) == sizeof(struct stack_layout)) );
1476
1477 NTSTATUS status = send_debug_event( rec, context, TRUE );
1478
1479 if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
1480 {
1481 restore_context( xcontext, sigcontext );
1482 return;
1483 }
1484
1485 /* fix up instruction pointer in context for EXCEPTION_BREAKPOINT */
1486 if (rec->ExceptionCode == EXCEPTION_BREAKPOINT) context->Eip--;
1487
1488 stack_size = sizeof(*stack);
1489 if ((src_xs = xstate_from_context( context )))
1490 {
1491 stack_size += (ULONG_PTR)stack_ptr - (((ULONG_PTR)stack_ptr
1492 - sizeof(XSTATE)) & ~(ULONG_PTR)63);
1493 }
1494
1495 stack = virtual_setup_exception( stack_ptr, stack_size, rec );
1496 stack->rec = *rec;
1497 stack->context = *context;
1498
1499 if (src_xs)
1500 {
1501 XSTATE *dst_xs = (XSTATE *)stack->xstate;
1502
1503 assert(!((ULONG_PTR)dst_xs & 63));
1504 context_init_xstate( &stack->context, stack->xstate );
1505 memset( dst_xs, 0, offsetof(XSTATE, YmmContext) );
1506 dst_xs->CompactionMask = xstate_compaction_enabled ? 0x8000000000000004 : 0;
1507 if (src_xs->Mask & 4)
1508 {
1509 dst_xs->Mask = 4;
1510 memcpy( &dst_xs->YmmContext, &src_xs->YmmContext, sizeof(dst_xs->YmmContext) );
1511 }
1512 }
1513
1514 stack->rec_ptr = &stack->rec;
1515 stack->context_ptr = &stack->context;
1516 ESP_sig(sigcontext) = (DWORD)stack;
1517 EIP_sig(sigcontext) = (DWORD)pKiUserExceptionDispatcher;
1518 /* clear single-step, direction, and align check flag */
1519 EFL_sig(sigcontext) &= ~(0x100|0x400|0x40000);
1520 CS_sig(sigcontext) = get_cs();
1521 DS_sig(sigcontext) = get_ds();
1522 ES_sig(sigcontext) = get_ds();
1523 FS_sig(sigcontext) = get_fs();
1524 GS_sig(sigcontext) = get_gs();
1525 SS_sig(sigcontext) = get_ds();
1526 }
1527
1528
1529 /***********************************************************************
1530 * setup_exception
1531 *
1532 * Do the full setup to raise an exception from an exception record.
1533 */
1534 static void setup_exception( ucontext_t *sigcontext, EXCEPTION_RECORD *rec )
1535 {
1536 struct xcontext xcontext;
1537 void *stack = setup_exception_record( sigcontext, rec, &xcontext );
1538
1539 setup_raise_exception( sigcontext, stack, rec, &xcontext );
1540 }
1541
1542 /* stack layout when calling an user apc function.
1543 * FIXME: match Windows ABI. */
1544 struct apc_stack_layout
1545 {
1546 void *context_ptr;
1547 void *arg1;
1548 void *arg2;
1549 void *arg3;
1550 void *func;
1551 CONTEXT context;
1552 };
1553
1554 struct apc_stack_layout * WINAPI setup_user_apc_dispatcher_stack( CONTEXT *context, struct apc_stack_layout *stack,
1555 void *arg1, void *arg2, void *arg3,
1556 void *func, NTSTATUS status ) DECLSPEC_HIDDEN;
1557 struct apc_stack_layout * WINAPI setup_user_apc_dispatcher_stack( CONTEXT *context, struct apc_stack_layout *stack,
1558 void *arg1, void *arg2, void *arg3,
1559 void *func, NTSTATUS status )
1560 {
1561 CONTEXT c;
1562
1563 if (!context)
1564 {
1565 c.ContextFlags = CONTEXT_FULL;
1566 NtGetContextThread( GetCurrentThread(), &c );
1567 c.Eax = status;
1568 context = &c;
1569 }
1570 memmove( &stack->context, context, sizeof(stack->context) );
1571 stack->context_ptr = &stack->context;
1572 stack->arg1 = arg1;
1573 stack->arg2 = arg2;
1574 stack->arg3 = arg3;
1575 stack->func = func;
1576 return stack;
1577 }
1578
1579 C_ASSERT( sizeof(struct apc_stack_layout) == 0x2e0 );
1580 C_ASSERT( offsetof(struct apc_stack_layout, context) == 20 );
1581
1582 /***********************************************************************
1583 * call_user_apc_dispatcher
1584 */
1585 __ASM_GLOBAL_FUNC( call_user_apc_dispatcher,
1586 "movl 4(%esp),%esi\n\t" /* context_ptr */
1587 "movl 24(%esp),%edi\n\t" /* dispatcher */
1588 "leal 4(%esp),%ebp\n\t"
1589 "test %esi,%esi\n\t"
1590 "jz 1f\n\t"
1591 "movl 0xc4(%esi),%eax\n\t" /* context_ptr->Esp */
1592 "jmp 2f\n\t"
1593 "1:\tmovl %fs:0x1f8,%eax\n\t" /* x86_thread_data()->syscall_frame */
1594 "leal 0x3c(%eax),%eax\n\t" /* &x86_thread_data()->syscall_frame->ret_addr */
1595 "2:\tsubl $0x2e0,%eax\n\t" /* sizeof(struct apc_stack_layout) */
1596 "movl %ebp,%esp\n\t" /* pop return address */
1597 "cmpl %esp,%eax\n\t"
1598 "cmovbl %eax,%esp\n\t"
1599 "pushl 24(%ebp)\n\t" /* status */
1600 "pushl 16(%ebp)\n\t" /* func */
1601 "pushl 12(%ebp)\n\t" /* arg3 */
1602 "pushl 8(%ebp)\n\t" /* arg2 */
1603 "pushl 4(%ebp)\n\t" /* arg1 */
1604 "pushl %eax\n\t"
1605 "pushl %esi\n\t"
1606 "call " __ASM_STDCALL("setup_user_apc_dispatcher_stack",24) "\n\t"
1607 "movl $0,%fs:0x1f8\n\t" /* x86_thread_data()->syscall_frame = NULL */
1608 "movl %eax,%esp\n\t"
1609 "leal 20(%eax),%esi\n\t"
1610 "movl 0xb4(%esi),%ebp\n\t" /* context.Ebp */
1611 "pushl 0xb8(%esi)\n\t" /* context.Eip */
1612 "jmp *%edi\n" )
1613
1614
1615 /***********************************************************************
1616 * call_raise_user_exception_dispatcher
1617 */
1618 void WINAPI call_raise_user_exception_dispatcher( NTSTATUS (WINAPI *dispatcher)(void) )
1619 {
1620 x86_thread_data()->syscall_frame->eip = (DWORD)dispatcher;
1621 }
1622
1623
1624 /***********************************************************************
1625 * call_user_exception_dispatcher
1626 */
1627 __ASM_GLOBAL_FUNC( call_user_exception_dispatcher,
1628 "movl 4(%esp),%edx\n\t" /* rec */
1629 "movl 8(%esp),%ecx\n\t" /* context */
1630 "cmpl $0x80000003,(%edx)\n\t" /* rec->ExceptionCode */
1631 "jne 1f\n\t"
1632 "decl 0xb8(%ecx)\n" /* context->Eip */
1633 "1:\tmovl %fs:0x1f8,%eax\n\t" /* x86_thread_data()->syscall_frame */
1634 "movl 0x20(%eax),%ebx\n\t" /* frame->ebx */
1635 "movl 0x2c(%eax),%edi\n\t" /* frame->edi */
1636 "movl 0x30(%eax),%esi\n\t" /* frame->esi */
1637 "movl 0x34(%eax),%ebp\n\t" /* frame->ebp */
1638 "movl %edx,0x34(%eax)\n\t"
1639 "movl %ecx,0x38(%eax)\n\t"
1640 "movl 12(%esp),%edx\n\t" /* dispatcher */
1641 "movl $0,%fs:0x1f8\n\t"
1642 "leal 0x34(%eax),%esp\n\t"
1643 "jmp *%edx" )
1644
1645 /**********************************************************************
1646 * get_fpu_code
1647 *
1648 * Get the FPU exception code from the FPU status.
1649 */
1650 static inline DWORD get_fpu_code( const CONTEXT *context )
1651 {
1652 DWORD status = context->FloatSave.StatusWord & ~(context->FloatSave.ControlWord & 0x3f);
1653
1654 if (status & 0x01) /* IE */
1655 {
1656 if (status & 0x40) /* SF */
1657 return EXCEPTION_FLT_STACK_CHECK;
1658 else
1659 return EXCEPTION_FLT_INVALID_OPERATION;
1660 }
1661 if (status & 0x02) return EXCEPTION_FLT_DENORMAL_OPERAND; /* DE flag */
1662 if (status & 0x04) return EXCEPTION_FLT_DIVIDE_BY_ZERO; /* ZE flag */
1663 if (status & 0x08) return EXCEPTION_FLT_OVERFLOW; /* OE flag */
1664 if (status & 0x10) return EXCEPTION_FLT_UNDERFLOW; /* UE flag */
1665 if (status & 0x20) return EXCEPTION_FLT_INEXACT_RESULT; /* PE flag */
1666 return EXCEPTION_FLT_INVALID_OPERATION; /* generic error */
1667 }
1668
1669
1670 /***********************************************************************
1671 * handle_interrupt
1672 *
1673 * Handle an interrupt.
1674 */
1675 static BOOL handle_interrupt( unsigned int interrupt, ucontext_t *sigcontext, void *stack,
1676 EXCEPTION_RECORD *rec, struct xcontext *xcontext )
1677 {
1678 CONTEXT *context = &xcontext->c;
1679
1680 switch(interrupt)
1681 {
1682 case 0x2d:
1683 if (!is_wow64)
1684 {
1685 /* On Wow64, the upper DWORD of Rax contains garbage, and the debug
1686 * service is usually not recognized when called from usermode. */
1687 switch (context->Eax)
1688 {
1689 case 1: /* BREAKPOINT_PRINT */
1690 case 3: /* BREAKPOINT_LOAD_SYMBOLS */
1691 case 4: /* BREAKPOINT_UNLOAD_SYMBOLS */
1692 case 5: /* BREAKPOINT_COMMAND_STRING (>= Win2003) */
1693 EIP_sig(sigcontext) += 3;
1694 return TRUE;
1695 }
1696 }
1697 context->Eip += 3;
1698 rec->ExceptionCode = EXCEPTION_BREAKPOINT;
1699 rec->ExceptionAddress = (void *)context->Eip;
1700 rec->NumberParameters = is_wow64 ? 1 : 3;
1701 rec->ExceptionInformation[0] = context->Eax;
1702 rec->ExceptionInformation[1] = context->Ecx;
1703 rec->ExceptionInformation[2] = context->Edx;
1704 setup_raise_exception( sigcontext, stack, rec, xcontext );
1705 return TRUE;
1706 default:
1707 return FALSE;
1708 }
1709 }
1710
1711
1712 /***********************************************************************
1713 * handle_syscall_fault
1714 *
1715 * Handle a page fault happening during a system call.
1716 */
1717 static BOOL handle_syscall_fault( ucontext_t *sigcontext, void *stack_ptr,
1718 EXCEPTION_RECORD *rec, CONTEXT *context )
1719 {
1720 struct syscall_frame *frame = x86_thread_data()->syscall_frame;
1721 DWORD i;
1722
1723 if (!frame) return FALSE;
1724
1725 TRACE( "code=%x flags=%x addr=%p ip=%08x tid=%04x\n",
1726 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
1727 context->Eip, GetCurrentThreadId() );
1728 for (i = 0; i < rec->NumberParameters; i++)
1729 TRACE( " info[%d]=%08lx\n", i, rec->ExceptionInformation[i] );
1730 TRACE(" eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n",
1731 context->Eax, context->Ebx, context->Ecx,
1732 context->Edx, context->Esi, context->Edi );
1733 TRACE(" ebp=%08x esp=%08x cs=%04x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
1734 context->Ebp, context->Esp, context->SegCs, context->SegDs,
1735 context->SegEs, context->SegFs, context->SegGs, context->EFlags );
1736
1737 if (ntdll_get_thread_data()->jmp_buf)
1738 {
1739 /* stack frame for calling __wine_longjmp */
1740 struct
1741 {
1742 int retval;
1743 __wine_jmp_buf *jmp;
1744 void *retaddr;
1745 } *stack;
1746
1747 TRACE( "returning to handler\n" );
1748 stack = virtual_setup_exception( stack_ptr, sizeof(*stack), rec );
1749 stack->retval = 1;
1750 stack->jmp = ntdll_get_thread_data()->jmp_buf;
1751 stack->retaddr = (void *)0xdeadbabe;
1752 ESP_sig(sigcontext) = (DWORD)stack;
1753 EIP_sig(sigcontext) = (DWORD)__wine_longjmp;
1754 ntdll_get_thread_data()->jmp_buf = NULL;
1755 }
1756 else
1757 {
1758 TRACE( "returning to user mode ip=%08x ret=%08x\n", frame->eip, rec->ExceptionCode );
1759 EAX_sig(sigcontext) = rec->ExceptionCode;
1760 EBX_sig(sigcontext) = frame->ebx;
1761 ESI_sig(sigcontext) = frame->esi;
1762 EDI_sig(sigcontext) = frame->edi;
1763 EBP_sig(sigcontext) = frame->ebp;
1764 ESP_sig(sigcontext) = frame->esp;
1765 EIP_sig(sigcontext) = frame->eip;
1766 x86_thread_data()->syscall_frame = NULL;
1767 }
1768 return TRUE;
1769 }
1770
1771
1772 /**********************************************************************
1773 * segv_handler
1774 *
1775 * Handler for SIGSEGV and related errors.
1776 */
1777 static void segv_handler( int signal, siginfo_t *siginfo, void *sigcontext )
1778 {
1779 EXCEPTION_RECORD rec = { 0 };
1780 struct xcontext xcontext;
1781 ucontext_t *ucontext = sigcontext;
1782 void *stack = setup_exception_record( sigcontext, &rec, &xcontext );
1783
1784 switch (TRAP_sig(ucontext))
1785 {
1786 case TRAP_x86_OFLOW: /* Overflow exception */
1787 rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
1788 break;
1789 case TRAP_x86_BOUND: /* Bound range exception */
1790 rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
1791 break;
1792 case TRAP_x86_PRIVINFLT: /* Invalid opcode exception */
1793 rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
1794 break;
1795 case TRAP_x86_STKFLT: /* Stack fault */
1796 rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
1797 break;
1798 case TRAP_x86_SEGNPFLT: /* Segment not present exception */
1799 case TRAP_x86_PROTFLT: /* General protection fault */
1800 {
1801 WORD err = ERROR_sig(ucontext);
1802 if (!err && (rec.ExceptionCode = is_privileged_instr( &xcontext.c ))) break;
1803 if ((err & 7) == 2 && handle_interrupt( err >> 3, ucontext, stack, &rec, &xcontext )) return;
1804 rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
1805 rec.NumberParameters = 2;
1806 rec.ExceptionInformation[0] = 0;
1807 /* if error contains a LDT selector, use that as fault address */
1808 if ((err & 7) == 4 && !ldt_is_system( err | 7 )) rec.ExceptionInformation[1] = err & ~7;
1809 else
1810 {
1811 rec.ExceptionInformation[1] = 0xffffffff;
1812 if (check_invalid_gs( ucontext, &xcontext.c )) return;
1813 }
1814 }
1815 break;
1816 case TRAP_x86_PAGEFLT: /* Page fault */
1817 rec.NumberParameters = 2;
1818 rec.ExceptionInformation[0] = (ERROR_sig(ucontext) >> 1) & 0x09;
1819 rec.ExceptionInformation[1] = (ULONG_PTR)siginfo->si_addr;
1820 rec.ExceptionCode = virtual_handle_fault( siginfo->si_addr, rec.ExceptionInformation[0], stack );
1821 if (!rec.ExceptionCode) return;
1822 if (rec.ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
1823 rec.ExceptionInformation[0] == EXCEPTION_EXECUTE_FAULT)
1824 {
1825 ULONG flags;
1826 NtQueryInformationProcess( GetCurrentProcess(), ProcessExecuteFlags,
1827 &flags, sizeof(flags), NULL );
1828 if (!(flags & MEM_EXECUTE_OPTION_DISABLE_THUNK_EMULATION) &&
1829 check_atl_thunk( ucontext, &rec, &xcontext.c ))
1830 return;
1831
1832 /* send EXCEPTION_EXECUTE_FAULT only if data execution prevention is enabled */
1833 if (!(flags & MEM_EXECUTE_OPTION_DISABLE)) rec.ExceptionInformation[0] = EXCEPTION_READ_FAULT;
1834 }
1835 break;
1836 case TRAP_x86_ALIGNFLT: /* Alignment check exception */
1837 /* FIXME: pass through exception handler first? */
1838 if (xcontext.c.EFlags & 0x00040000)
1839 {
1840 EFL_sig(ucontext) &= ~0x00040000; /* disable AC flag */
1841 return;
1842 }
1843 rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
1844 break;
1845 default:
1846 WINE_ERR( "Got unexpected trap %d\n", TRAP_sig(ucontext) );
1847 /* fall through */
1848 case TRAP_x86_NMI: /* NMI interrupt */
1849 case TRAP_x86_DNA: /* Device not available exception */
1850 case TRAP_x86_DOUBLEFLT: /* Double fault exception */
1851 case TRAP_x86_TSSFLT: /* Invalid TSS exception */
1852 case TRAP_x86_MCHK: /* Machine check exception */
1853 case TRAP_x86_CACHEFLT: /* Cache flush exception */
1854 rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
1855 break;
1856 }
1857 if (handle_syscall_fault( ucontext, stack, &rec, &xcontext.c )) return;
1858 setup_raise_exception( ucontext, stack, &rec, &xcontext );
1859 }
1860
1861
1862 /**********************************************************************
1863 * trap_handler
1864 *
1865 * Handler for SIGTRAP.
1866 */
1867 static void trap_handler( int signal, siginfo_t *siginfo, void *sigcontext )
1868 {
1869 EXCEPTION_RECORD rec = { 0 };
1870 struct xcontext xcontext;
1871 ucontext_t *ucontext = sigcontext;
1872 void *stack = setup_exception_record( sigcontext, &rec, &xcontext );
1873
1874 switch (TRAP_sig(ucontext))
1875 {
1876 case TRAP_x86_TRCTRAP: /* Single-step exception */
1877 rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
1878 /* when single stepping can't tell whether this is a hw bp or a
1879 * single step interrupt. try to avoid as much overhead as possible
1880 * and only do a server call if there is any hw bp enabled. */
1881 if (!(xcontext.c.EFlags & 0x100) || (xcontext.c.Dr7 & 0xff))
1882 {
1883 /* (possible) hardware breakpoint, fetch the debug registers */
1884 DWORD saved_flags = xcontext.c.ContextFlags;
1885 xcontext.c.ContextFlags = CONTEXT_DEBUG_REGISTERS;
1886 NtGetContextThread( GetCurrentThread(), &xcontext.c );
1887 xcontext.c.ContextFlags |= saved_flags; /* restore flags */
1888 }
1889 xcontext.c.EFlags &= ~0x100; /* clear single-step flag */
1890 break;
1891 case TRAP_x86_BPTFLT: /* Breakpoint exception */
1892 rec.ExceptionAddress = (char *)rec.ExceptionAddress - 1; /* back up over the int3 instruction */
1893 /* fall through */
1894 default:
1895 rec.ExceptionCode = EXCEPTION_BREAKPOINT;
1896 rec.NumberParameters = is_wow64 ? 1 : 3;
1897 rec.ExceptionInformation[0] = 0;
1898 rec.ExceptionInformation[1] = 0; /* FIXME */
1899 rec.ExceptionInformation[2] = 0; /* FIXME */
1900 break;
1901 }
1902 setup_raise_exception( sigcontext, stack, &rec, &xcontext );
1903 }
1904
1905
1906 /**********************************************************************
1907 * fpe_handler
1908 *
1909 * Handler for SIGFPE.
1910 */
1911 static void fpe_handler( int signal, siginfo_t *siginfo, void *sigcontext )
1912 {
1913 EXCEPTION_RECORD rec = { 0 };
1914 struct xcontext xcontext;
1915 ucontext_t *ucontext = sigcontext;
1916 void *stack = setup_exception_record( sigcontext, &rec, &xcontext );
1917
1918 switch (TRAP_sig(ucontext))
1919 {
1920 case TRAP_x86_DIVIDE: /* Division by zero exception */
1921 rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
1922 break;
1923 case TRAP_x86_FPOPFLT: /* Coprocessor segment overrun */
1924 rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
1925 break;
1926 case TRAP_x86_ARITHTRAP: /* Floating point exception */
1927 rec.ExceptionCode = get_fpu_code( &xcontext.c );
1928 rec.ExceptionAddress = (void *)xcontext.c.FloatSave.ErrorOffset;
1929 break;
1930 case TRAP_x86_CACHEFLT: /* SIMD exception */
1931 /* TODO:
1932 * Behaviour only tested for divide-by-zero exceptions
1933 * Check for other SIMD exceptions as well */
1934 if(siginfo->si_code != FPE_FLTDIV && siginfo->si_code != FPE_FLTINV)
1935 FIXME("untested SIMD exception: %#x. Might not work correctly\n",
1936 siginfo->si_code);
1937
1938 rec.ExceptionCode = STATUS_FLOAT_MULTIPLE_TRAPS;
1939 rec.NumberParameters = 1;
1940 /* no idea what meaning is actually behind this but that's what native does */
1941 rec.ExceptionInformation[0] = 0;
1942 break;
1943 default:
1944 WINE_ERR( "Got unexpected trap %d\n", TRAP_sig(ucontext) );
1945 rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
1946 break;
1947 }
1948 setup_raise_exception( sigcontext, stack, &rec, &xcontext );
1949 }
1950
1951
1952 /**********************************************************************
1953 * int_handler
1954 *
1955 * Handler for SIGINT.
1956 */
1957 static void int_handler( int signal, siginfo_t *siginfo, void *sigcontext )
1958 {
1959 HANDLE handle;
1960
1961 init_handler( sigcontext );
1962
1963 if (!p__wine_ctrl_routine) return;
1964 if (!NtCreateThreadEx( &handle, THREAD_ALL_ACCESS, NULL, NtCurrentProcess(),
1965 p__wine_ctrl_routine, 0 /* CTRL_C_EVENT */, 0, 0, 0, 0, NULL ))
1966 NtClose( handle );
1967 }
1968
1969 /**********************************************************************
1970 * abrt_handler
1971 *
1972 * Handler for SIGABRT.
1973 */
1974 static void abrt_handler( int signal, siginfo_t *siginfo, void *sigcontext )
1975 {
1976 EXCEPTION_RECORD rec = { EXCEPTION_WINE_ASSERTION, EH_NONCONTINUABLE };
1977
1978 setup_exception( sigcontext, &rec );
1979 }
1980
1981
1982 /**********************************************************************
1983 * quit_handler
1984 *
1985 * Handler for SIGQUIT.
1986 */
1987 static void quit_handler( int signal, siginfo_t *siginfo, void *sigcontext )
1988 {
1989 init_handler( sigcontext );
1990 abort_thread(0);
1991 }
1992
1993
1994 /**********************************************************************
1995 * usr1_handler
1996 *
1997 * Handler for SIGUSR1, used to signal a thread that it got suspended.
1998 */
1999 static void usr1_handler( int signal, siginfo_t *siginfo, void *sigcontext )
2000 {
2001 struct xcontext xcontext;
2002
2003 init_handler( sigcontext );
2004 if (x86_thread_data()->syscall_frame)
2005 {
2006 DECLSPEC_ALIGN(64) XSTATE xs;
2007 xcontext.c.ContextFlags = CONTEXT_FULL;
2008 context_init_xstate( &xcontext.c, &xs );
2009
2010 NtGetContextThread( GetCurrentThread(), &xcontext.c );
2011 wait_suspend( &xcontext.c );
2012 NtSetContextThread( GetCurrentThread(), &xcontext.c );
2013 }
2014 else
2015 {
2016 save_context( &xcontext, sigcontext );
2017 wait_suspend( &xcontext.c );
2018 restore_context( &xcontext, sigcontext );
2019 }
2020 }
2021
2022
2023 /***********************************************************************
2024 * LDT support
2025 */
2026
2027 #define LDT_SIZE 8192
2028
2029 #define LDT_FLAGS_DATA 0x13 /* Data segment */
2030 #define LDT_FLAGS_CODE 0x1b /* Code segment */
2031 #define LDT_FLAGS_32BIT 0x40 /* Segment is 32-bit (code or stack) */
2032 #define LDT_FLAGS_ALLOCATED 0x80 /* Segment is allocated */
2033
2034 struct ldt_copy
2035 {
2036 void *base[LDT_SIZE];
2037 unsigned int limit[LDT_SIZE];
2038 unsigned char flags[LDT_SIZE];
2039 } __wine_ldt_copy;
2040
2041 static WORD gdt_fs_sel;
2042 static pthread_mutex_t ldt_mutex = PTHREAD_MUTEX_INITIALIZER;
2043 static const LDT_ENTRY null_entry;
2044
2045 static inline void *ldt_get_base( LDT_ENTRY ent )
2046 {
2047 return (void *)(ent.BaseLow |
2048 (ULONG_PTR)ent.HighWord.Bits.BaseMid << 16 |
2049 (ULONG_PTR)ent.HighWord.Bits.BaseHi << 24);
2050 }
2051
2052 static inline unsigned int ldt_get_limit( LDT_ENTRY ent )
2053 {
2054 unsigned int limit = ent.LimitLow | (ent.HighWord.Bits.LimitHi << 16);
2055 if (ent.HighWord.Bits.Granularity) limit = (limit << 12) | 0xfff;
2056 return limit;
2057 }
2058
2059 static LDT_ENTRY ldt_make_entry( void *base, unsigned int limit, unsigned char flags )
2060 {
2061 LDT_ENTRY entry;
2062
2063 entry.BaseLow = (WORD)(ULONG_PTR)base;
2064 entry.HighWord.Bits.BaseMid = (BYTE)((ULONG_PTR)base >> 16);
2065 entry.HighWord.Bits.BaseHi = (BYTE)((ULONG_PTR)base >> 24);
2066 if ((entry.HighWord.Bits.Granularity = (limit >= 0x100000))) limit >>= 12;
2067 entry.LimitLow = (WORD)limit;
2068 entry.HighWord.Bits.LimitHi = limit >> 16;
2069 entry.HighWord.Bits.Dpl = 3;
2070 entry.HighWord.Bits.Pres = 1;
2071 entry.HighWord.Bits.Type = flags;
2072 entry.HighWord.Bits.Sys = 0;
2073 entry.HighWord.Bits.Reserved_0 = 0;
2074 entry.HighWord.Bits.Default_Big = (flags & LDT_FLAGS_32BIT) != 0;
2075 return entry;
2076 }
2077
2078 static void ldt_set_entry( WORD sel, LDT_ENTRY entry )
2079 {
2080 int index = sel >> 3;
2081
2082 #ifdef linux
2083 struct modify_ldt_s ldt_info = { index };
2084
2085 ldt_info.base_addr = ldt_get_base( entry );
2086 ldt_info.limit = entry.LimitLow | (entry.HighWord.Bits.LimitHi << 16);
2087 ldt_info.seg_32bit = entry.HighWord.Bits.Default_Big;
2088 ldt_info.contents = (entry.HighWord.Bits.Type >> 2) & 3;
2089 ldt_info.read_exec_only = !(entry.HighWord.Bits.Type & 2);
2090 ldt_info.limit_in_pages = entry.HighWord.Bits.Granularity;
2091 ldt_info.seg_not_present = !entry.HighWord.Bits.Pres;
2092 ldt_info.usable = entry.HighWord.Bits.Sys;
2093 if (modify_ldt( 0x11, &ldt_info, sizeof(ldt_info) ) < 0) perror( "modify_ldt" );
2094 #elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__) || defined(__DragonFly__)
2095 /* The kernel will only let us set LDTs with user priority level */
2096 if (entry.HighWord.Bits.Pres && entry.HighWord.Bits.Dpl != 3) entry.HighWord.Bits.Dpl = 3;
2097 if (i386_set_ldt(index, (union descriptor *)&entry, 1) < 0)
2098 {
2099 perror("i386_set_ldt");
2100 fprintf( stderr, "Did you reconfigure the kernel with \"options USER_LDT\"?\n" );
2101 exit(1);
2102 }
2103 #elif defined(__svr4__) || defined(_SCO_DS)
2104 struct ssd ldt_mod;
2105
2106 ldt_mod.sel = sel;
2107 ldt_mod.bo = (unsigned long)ldt_get_base( entry );
2108 ldt_mod.ls = entry.LimitLow | (entry.HighWord.Bits.LimitHi << 16);
2109 ldt_mod.acc1 = entry.HighWord.Bytes.Flags1;
2110 ldt_mod.acc2 = entry.HighWord.Bytes.Flags2 >> 4;
2111 if (sysi86(SI86DSCR, &ldt_mod) == -1) perror("sysi86");
2112 #elif defined(__APPLE__)
2113 if (i386_set_ldt(index, (union ldt_entry *)&entry, 1) < 0) perror("i386_set_ldt");
2114 #elif defined(__GNU__)
2115 if (i386_set_ldt(mach_thread_self(), sel, (descriptor_list_t)&entry, 1) != KERN_SUCCESS)
2116 perror("i386_set_ldt");
2117 #else
2118 fprintf( stderr, "No LDT support on this platform\n" );
2119 exit(1);
2120 #endif
2121
2122 __wine_ldt_copy.base[index] = ldt_get_base( entry );
2123 __wine_ldt_copy.limit[index] = ldt_get_limit( entry );
2124 __wine_ldt_copy.flags[index] = (entry.HighWord.Bits.Type |
2125 (entry.HighWord.Bits.Default_Big ? LDT_FLAGS_32BIT : 0) |
2126 LDT_FLAGS_ALLOCATED);
2127 }
2128
2129 static void ldt_set_fs( WORD sel, TEB *teb )
2130 {
2131 if (sel == gdt_fs_sel)
2132 {
2133 #ifdef __linux__
2134 struct modify_ldt_s ldt_info = { sel >> 3 };
2135
2136 ldt_info.base_addr = teb;
2137 ldt_info.limit = page_size - 1;
2138 ldt_info.seg_32bit = 1;
2139 if (set_thread_area( &ldt_info ) < 0) perror( "set_thread_area" );
2140 #elif defined(__FreeBSD__) || defined (__FreeBSD_kernel__) || defined(__DragonFly__)
2141 i386_set_fsbase( teb );
2142 #endif
2143 }
2144 set_fs( sel );
2145 }
2146
2147
2148 /**********************************************************************
2149 * get_thread_ldt_entry
2150 */
2151 NTSTATUS get_thread_ldt_entry( HANDLE handle, void *data, ULONG len, ULONG *ret_len )
2152 {
2153 THREAD_DESCRIPTOR_INFORMATION *info = data;
2154 NTSTATUS status = STATUS_SUCCESS;
2155
2156 if (len < sizeof(*info)) return STATUS_INFO_LENGTH_MISMATCH;
2157 if (info->Selector >> 16) return STATUS_UNSUCCESSFUL;
2158
2159 if (is_gdt_sel( info->Selector ))
2160 {
2161 if (!(info->Selector & ~3))
2162 info->Entry = null_entry;
2163 else if ((info->Selector | 3) == get_cs())
2164 info->Entry = ldt_make_entry( 0, ~0u, LDT_FLAGS_CODE | LDT_FLAGS_32BIT );
2165 else if ((info->Selector | 3) == get_ds())
2166 info->Entry = ldt_make_entry( 0, ~0u, LDT_FLAGS_DATA | LDT_FLAGS_32BIT );
2167 else if ((info->Selector | 3) == get_fs())
2168 info->Entry = ldt_make_entry( NtCurrentTeb(), 0xfff, LDT_FLAGS_DATA | LDT_FLAGS_32BIT );
2169 else
2170 return STATUS_UNSUCCESSFUL;
2171 }
2172 else
2173 {
2174 SERVER_START_REQ( get_selector_entry )
2175 {
2176 req->handle = wine_server_obj_handle( handle );
2177 req->entry = info->Selector >> 3;
2178 status = wine_server_call( req );
2179 if (!status)
2180 {
2181 if (reply->flags)
2182 info->Entry = ldt_make_entry( (void *)reply->base, reply->limit, reply->flags );
2183 else
2184 status = STATUS_UNSUCCESSFUL;
2185 }
2186 }
2187 SERVER_END_REQ;
2188 }
2189 if (status == STATUS_SUCCESS && ret_len)
2190 /* yes, that's a bit strange, but it's the way it is */
2191 *ret_len = sizeof(info->Entry);
2192
2193 return status;
2194 }
2195
2196
2197 /******************************************************************************
2198 * NtSetLdtEntries (NTDLL.@)
2199 * ZwSetLdtEntries (NTDLL.@)
2200 */
2201 NTSTATUS WINAPI NtSetLdtEntries( ULONG sel1, LDT_ENTRY entry1, ULONG sel2, LDT_ENTRY entry2 )
2202 {
2203 sigset_t sigset;
2204
2205 if (sel1 >> 16 || sel2 >> 16) return STATUS_INVALID_LDT_DESCRIPTOR;
2206 if (sel1 && (sel1 >> 3) < first_ldt_entry) return STATUS_INVALID_LDT_DESCRIPTOR;
2207 if (sel2 && (sel2 >> 3) < first_ldt_entry) return STATUS_INVALID_LDT_DESCRIPTOR;
2208
2209 server_enter_uninterrupted_section( &ldt_mutex, &sigset );
2210 if (sel1) ldt_set_entry( sel1, entry1 );
2211 if (sel2) ldt_set_entry( sel2, entry2 );
2212 server_leave_uninterrupted_section( &ldt_mutex, &sigset );
2213 return STATUS_SUCCESS;
2214 }
2215
2216
2217 /**********************************************************************
2218 * signal_init_threading
2219 */
2220 void signal_init_threading(void)
2221 {
2222 #ifdef __linux__
2223 /* the preloader may have allocated it already */
2224 gdt_fs_sel = get_fs();
2225 if (!gdt_fs_sel || !is_gdt_sel( gdt_fs_sel ))
2226 {
2227 struct modify_ldt_s ldt_info = { -1 };
2228
2229 ldt_info.seg_32bit = 1;
2230 ldt_info.usable = 1;
2231 if (set_thread_area( &ldt_info ) >= 0) gdt_fs_sel = (ldt_info.entry_number << 3) | 3;
2232 else gdt_fs_sel = 0;
2233 }
2234 #elif defined(__FreeBSD__) || defined (__FreeBSD_kernel__)
2235 gdt_fs_sel = GSEL( GUFS_SEL, SEL_UPL );
2236 #endif
2237 }
2238
2239
2240 /**********************************************************************
2241 * signal_alloc_thread
2242 */
2243 NTSTATUS signal_alloc_thread( TEB *teb )
2244 {
2245 struct x86_thread_data *thread_data = (struct x86_thread_data *)&teb->GdiTebBatch;
2246
2247 if (!gdt_fs_sel)
2248 {
2249 static int first_thread = 1;
2250 sigset_t sigset;
2251 int idx;
2252 LDT_ENTRY entry = ldt_make_entry( teb, page_size - 1, LDT_FLAGS_DATA | LDT_FLAGS_32BIT );
2253
2254 if (first_thread) /* no locking for first thread */
2255 {
2256 /* leave some space if libc is using the LDT for %gs */
2257 if (!is_gdt_sel( get_gs() )) first_ldt_entry = 512;
2258 idx = first_ldt_entry;
2259 ldt_set_entry( (idx << 3) | 7, entry );
2260 first_thread = 0;
2261 }
2262 else
2263 {
2264 server_enter_uninterrupted_section( &ldt_mutex, &sigset );
2265 for (idx = first_ldt_entry; idx < LDT_SIZE; idx++)
2266 {
2267 if (__wine_ldt_copy.flags[idx]) continue;
2268 ldt_set_entry( (idx << 3) | 7, entry );
2269 break;
2270 }
2271 server_leave_uninterrupted_section( &ldt_mutex, &sigset );
2272 if (idx == LDT_SIZE) return STATUS_TOO_MANY_THREADS;
2273 }
2274 thread_data->fs = (idx << 3) | 7;
2275 }
2276 else thread_data->fs = gdt_fs_sel;
2277
2278 teb->WOW32Reserved = __wine_syscall_dispatcher;
2279 return STATUS_SUCCESS;
2280 }
2281
2282
2283 /**********************************************************************
2284 * signal_free_thread
2285 */
2286 void signal_free_thread( TEB *teb )
2287 {
2288 struct x86_thread_data *thread_data = (struct x86_thread_data *)&teb->GdiTebBatch;
2289 sigset_t sigset;
2290
2291 if (gdt_fs_sel) return;
2292
2293 server_enter_uninterrupted_section( &ldt_mutex, &sigset );
2294 __wine_ldt_copy.flags[thread_data->fs >> 3] = 0;
2295 server_leave_uninterrupted_section( &ldt_mutex, &sigset );
2296 }
2297
2298
2299 /**********************************************************************
2300 * signal_init_thread
2301 */
2302 void signal_init_thread( TEB *teb )
2303 {
2304 const WORD fpu_cw = 0x27f;
2305 struct x86_thread_data *thread_data = (struct x86_thread_data *)&teb->GdiTebBatch;
2306
2307 ldt_set_fs( thread_data->fs, teb );
2308 thread_data->gs = get_gs();
2309
2310 __asm__ volatile ("fninit; fldcw %0" : : "m" (fpu_cw));
2311 }
2312
2313
2314 /**********************************************************************
2315 * signal_init_process
2316 */
2317 void signal_init_process(void)
2318 {
2319 struct sigaction sig_act;
2320
2321 if (cpu_info.ProcessorFeatureBits & CPU_FEATURE_FXSR) __wine_syscall_flags |= SYSCALL_HAVE_FXSAVE;
2322 if (cpu_info.ProcessorFeatureBits & CPU_FEATURE_XSAVE) __wine_syscall_flags |= SYSCALL_HAVE_XSAVE;
2323 if (xstate_compaction_enabled) __wine_syscall_flags |= SYSCALL_HAVE_XSAVEC;
2324
2325 sig_act.sa_mask = server_block_set;
2326 sig_act.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK;
2327 #ifdef __ANDROID__
2328 sig_act.sa_flags |= SA_RESTORER;
2329 sig_act.sa_restorer = rt_sigreturn;
2330 #endif
2331 sig_act.sa_sigaction = int_handler;
2332 if (sigaction( SIGINT, &sig_act, NULL ) == -1) goto error;
2333 sig_act.sa_sigaction = fpe_handler;
2334 if (sigaction( SIGFPE, &sig_act, NULL ) == -1) goto error;
2335 sig_act.sa_sigaction = abrt_handler;
2336 if (sigaction( SIGABRT, &sig_act, NULL ) == -1) goto error;
2337 sig_act.sa_sigaction = quit_handler;
2338 if (sigaction( SIGQUIT, &sig_act, NULL ) == -1) goto error;
2339 sig_act.sa_sigaction = usr1_handler;
2340 if (sigaction( SIGUSR1, &sig_act, NULL ) == -1) goto error;
2341 sig_act.sa_sigaction = trap_handler;
2342 if (sigaction( SIGTRAP, &sig_act, NULL ) == -1) goto error;
2343 sig_act.sa_sigaction = segv_handler;
2344 if (sigaction( SIGSEGV, &sig_act, NULL ) == -1) goto error;
2345 if (sigaction( SIGILL, &sig_act, NULL ) == -1) goto error;
2346 if (sigaction( SIGBUS, &sig_act, NULL ) == -1) goto error;
2347 return;
2348
2349 error:
2350 perror("sigaction");
2351 exit(1);
2352 }
2353
2354
2355 /***********************************************************************
2356 * init_thread_context
2357 */
2358 static void init_thread_context( CONTEXT *context, LPTHREAD_START_ROUTINE entry, void *arg )
2359 {
2360 context->SegCs = get_cs();
2361 context->SegDs = get_ds();
2362 context->SegEs = get_ds();
2363 context->SegFs = get_fs();
2364 context->SegGs = get_gs();
2365 context->SegSs = get_ds();
2366 context->EFlags = 0x202;
2367 context->Eax = (DWORD)entry;
2368 context->Ebx = (DWORD)arg;
2369 context->Esp = (DWORD)NtCurrentTeb()->Tib.StackBase - 16;
2370 context->Eip = (DWORD)pRtlUserThreadStart;
2371 context->FloatSave.ControlWord = 0x27f;
2372 ((XSAVE_FORMAT *)context->ExtendedRegisters)->ControlWord = 0x27f;
2373 ((XSAVE_FORMAT *)context->ExtendedRegisters)->MxCsr = 0x1f80;
2374 if (NtCurrentTeb64())
2375 {
2376 WOW64_CPURESERVED *cpu = ULongToPtr( NtCurrentTeb64()->TlsSlots[WOW64_TLS_CPURESERVED] );
2377 memcpy( cpu + 1, context, sizeof(*context) );
2378 }
2379 }
2380
2381
2382 /***********************************************************************
2383 * get_initial_context
2384 */
2385 PCONTEXT DECLSPEC_HIDDEN get_initial_context( LPTHREAD_START_ROUTINE entry, void *arg, BOOL suspend )
2386 {
2387 CONTEXT *ctx;
2388
2389 if (suspend)
2390 {
2391 CONTEXT context = { CONTEXT_ALL };
2392
2393 init_thread_context( &context, entry, arg );
2394 wait_suspend( &context );
2395 ctx = (CONTEXT *)((ULONG_PTR)context.Esp & ~15) - 1;
2396 *ctx = context;
2397 }
2398 else
2399 {
2400 ctx = (CONTEXT *)((char *)NtCurrentTeb()->Tib.StackBase - 16) - 1;
2401 init_thread_context( ctx, entry, arg );
2402 }
2403 pthread_sigmask( SIG_UNBLOCK, &server_block_set, NULL );
2404 ctx->ContextFlags = CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS;
2405 return ctx;
2406 }
2407
2408
2409 /***********************************************************************
2410 * signal_start_thread
2411 */
2412 __ASM_GLOBAL_FUNC( signal_start_thread,
2413 "pushl %ebp\n\t"
2414 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
2415 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
2416 "movl %esp,%ebp\n\t"
2417 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
2418 "pushl %ebx\n\t"
2419 __ASM_CFI(".cfi_rel_offset %ebx,-4\n\t")
2420 "pushl %esi\n\t"
2421 __ASM_CFI(".cfi_rel_offset %esi,-8\n\t")
2422 "pushl %edi\n\t"
2423 __ASM_CFI(".cfi_rel_offset %edi,-12\n\t")
2424 /* store exit frame */
2425 "movl %ebp,%fs:0x1f4\n\t" /* x86_thread_data()->exit_frame */
2426 /* switch to thread stack */
2427 "movl %fs:4,%eax\n\t" /* NtCurrentTeb()->StackBase */
2428 "leal -0x1004(%eax),%esp\n\t"
2429 /* attach dlls */
2430 "pushl 16(%ebp)\n\t" /* suspend */
2431 "pushl 12(%ebp)\n\t" /* arg */
2432 "pushl 8(%ebp)\n\t" /* entry */
2433 "call " __ASM_NAME("get_initial_context") "\n\t"
2434 "movl %eax,(%esp)\n\t" /* context */
2435 "movl 20(%ebp),%edx\n\t" /* thunk */
2436 "xorl %ebp,%ebp\n\t"
2437 "pushl $0\n\t"
2438 "jmp *%edx" )
2439
2440
2441 /***********************************************************************
2442 * signal_exit_thread
2443 */
2444 __ASM_GLOBAL_FUNC( signal_exit_thread,
2445 "movl 8(%esp),%ecx\n\t"
2446 /* fetch exit frame */
2447 "movl %fs:0x1f4,%edx\n\t" /* x86_thread_data()->exit_frame */
2448 "testl %edx,%edx\n\t"
2449 "jnz 1f\n\t"
2450 "jmp *%ecx\n\t"
2451 /* switch to exit frame stack */
2452 "1:\tmovl 4(%esp),%eax\n\t"
2453 "movl $0,%fs:0x1f4\n\t"
2454 "movl %edx,%ebp\n\t"
2455 __ASM_CFI(".cfi_def_cfa %ebp,4\n\t")
2456 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
2457 __ASM_CFI(".cfi_rel_offset %ebx,-4\n\t")
2458 __ASM_CFI(".cfi_rel_offset %esi,-8\n\t")
2459 __ASM_CFI(".cfi_rel_offset %edi,-12\n\t")
2460 "leal -20(%ebp),%esp\n\t"
2461 "pushl %eax\n\t"
2462 "call *%ecx" )
2463
2464 /**********************************************************************
2465 * NtCurrentTeb (NTDLL.@)
2466 */
2467 __ASM_STDCALL_FUNC( NtCurrentTeb, 0, ".byte 0x64\n\tmovl 0x18,%eax\n\tret" )
2468
2469 #endif /* __i386__ */
Windows API implementation