?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
comctl32: Fix a typo in comment.
[wine.git] / dlls / ntdll / signal_arm64.c
bloba04fe93a57507e34361a60f0b29467d730e88fdf
1 /*
2 * ARM64 signal handling routines
3 *
4 * Copyright 2010-2013 André Hentschel
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #ifdef __aarch64__
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <signal.h>
28 #include <stdlib.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #ifdef HAVE_UNISTD_H
32 # include <unistd.h>
33 #endif
34 #ifdef HAVE_SYS_PARAM_H
35 # include <sys/param.h>
36 #endif
37 #ifdef HAVE_SYSCALL_H
38 # include <syscall.h>
39 #else
40 # ifdef HAVE_SYS_SYSCALL_H
41 # include <sys/syscall.h>
42 # endif
43 #endif
44 #ifdef HAVE_SYS_SIGNAL_H
45 # include <sys/signal.h>
46 #endif
47 #ifdef HAVE_SYS_UCONTEXT_H
48 # include <sys/ucontext.h>
49 #endif
50
51 #define NONAMELESSUNION
52 #define NONAMELESSSTRUCT
53 #include "ntstatus.h"
54 #define WIN32_NO_STATUS
55 #include "windef.h"
56 #include "winternl.h"
57 #include "wine/library.h"
58 #include "wine/exception.h"
59 #include "ntdll_misc.h"
60 #include "wine/debug.h"
61 #include "winnt.h"
62
63 WINE_DEFAULT_DEBUG_CHANNEL(seh);
64 WINE_DECLARE_DEBUG_CHANNEL(relay);
65
66 static pthread_key_t teb_key;
67
68 /***********************************************************************
69 * signal context platform-specific definitions
70 */
71 #ifdef linux
72
73 /* All Registers access - only for local access */
74 # define REG_sig(reg_name, context) ((context)->uc_mcontext.reg_name)
75 # define REGn_sig(reg_num, context) ((context)->uc_mcontext.regs[reg_num])
76
77 /* Special Registers access */
78 # define SP_sig(context) REG_sig(sp, context) /* Stack pointer */
79 # define PC_sig(context) REG_sig(pc, context) /* Program counter */
80 # define PSTATE_sig(context) REG_sig(pstate, context) /* Current State Register */
81 # define FP_sig(context) REGn_sig(29, context) /* Frame pointer */
82 # define LR_sig(context) REGn_sig(30, context) /* Link Register */
83
84 /* Exceptions */
85 # define FAULT_sig(context) REG_sig(fault_address, context)
86
87 #endif /* linux */
88
89 static const size_t teb_size = 0x2000; /* we reserve two pages for the TEB */
90 static size_t signal_stack_size;
91
92 typedef void (WINAPI *raise_func)( EXCEPTION_RECORD *rec, CONTEXT *context );
93 typedef int (*wine_signal_handler)(unsigned int sig);
94
95 static wine_signal_handler handlers[256];
96
97 /***********************************************************************
98 * dispatch_signal
99 */
100 static inline int dispatch_signal(unsigned int sig)
101 {
102 if (handlers[sig] == NULL) return 0;
103 return handlers[sig](sig);
104 }
105
106 /*******************************************************************
107 * is_valid_frame
108 */
109 static inline BOOL is_valid_frame( void *frame )
110 {
111 if ((ULONG_PTR)frame & 3) return FALSE;
112 return (frame >= NtCurrentTeb()->Tib.StackLimit &&
113 (void **)frame < (void **)NtCurrentTeb()->Tib.StackBase - 1);
114 }
115
116 /***********************************************************************
117 * save_context
118 *
119 * Set the register values from a sigcontext.
120 */
121 static void save_context( CONTEXT *context, const ucontext_t *sigcontext )
122 {
123 DWORD i;
124
125 context->ContextFlags = CONTEXT_FULL;
126 context->Fp = FP_sig(sigcontext); /* Frame pointer */
127 context->Lr = LR_sig(sigcontext); /* Link register */
128 context->Sp = SP_sig(sigcontext); /* Stack pointer */
129 context->Pc = PC_sig(sigcontext); /* Program Counter */
130 context->Cpsr = PSTATE_sig(sigcontext); /* Current State Register */
131 for (i = 0; i <= 28; i++) context->u.X[i] = REGn_sig( i, sigcontext );
132 }
133
134
135 /***********************************************************************
136 * restore_context
137 *
138 * Build a sigcontext from the register values.
139 */
140 static void restore_context( const CONTEXT *context, ucontext_t *sigcontext )
141 {
142 DWORD i;
143
144 FP_sig(sigcontext) = context->Fp; /* Frame pointer */
145 LR_sig(sigcontext) = context->Lr; /* Link register */
146 SP_sig(sigcontext) = context->Sp; /* Stack pointer */
147 PC_sig(sigcontext) = context->Pc; /* Program Counter */
148 PSTATE_sig(sigcontext) = context->Cpsr; /* Current State Register */
149 for (i = 0; i <= 28; i++) REGn_sig( i, sigcontext ) = context->u.X[i];
150 }
151
152
153 /***********************************************************************
154 * save_fpu
155 *
156 * Set the FPU context from a sigcontext.
157 */
158 static inline void save_fpu( CONTEXT *context, const ucontext_t *sigcontext )
159 {
160 FIXME( "Not implemented on ARM64\n" );
161 }
162
163
164 /***********************************************************************
165 * restore_fpu
166 *
167 * Restore the FPU context to a sigcontext.
168 */
169 static inline void restore_fpu( CONTEXT *context, const ucontext_t *sigcontext )
170 {
171 FIXME( "Not implemented on ARM64\n" );
172 }
173
174 /***********************************************************************
175 * RtlCaptureContext (NTDLL.@)
176 */
177 /* FIXME: Use the Stack instead of the actual register values? */
178 __ASM_STDCALL_FUNC( RtlCaptureContext, 8,
179 "stp x0, x1, [sp, #-32]!\n\t"
180 "mov w1, #0x400000\n\t" /* CONTEXT_ARM64 */
181 "add w1, w1, #0x3\n\t" /* CONTEXT_FULL */
182 "str w1, [x0]\n\t" /* context->ContextFlags */ /* 32-bit, look at cpsr */
183 "mrs x1, NZCV\n\t"
184 "str w1, [x0, #0x4]\n\t" /* context->Cpsr */
185 "ldp x0, x1, [sp], #32\n\t"
186 "str x0, [x0, #0x8]\n\t" /* context->X0 */
187 "str x1, [x0, #0x10]\n\t" /* context->X1 */
188 "str x2, [x0, #0x18]\n\t" /* context->X2 */
189 "str x3, [x0, #0x20]\n\t" /* context->X3 */
190 "str x4, [x0, #0x28]\n\t" /* context->X4 */
191 "str x5, [x0, #0x30]\n\t" /* context->X5 */
192 "str x6, [x0, #0x38]\n\t" /* context->X6 */
193 "str x7, [x0, #0x40]\n\t" /* context->X7 */
194 "str x8, [x0, #0x48]\n\t" /* context->X8 */
195 "str x9, [x0, #0x50]\n\t" /* context->X9 */
196 "str x10, [x0, #0x58]\n\t" /* context->X10 */
197 "str x11, [x0, #0x60]\n\t" /* context->X11 */
198 "str x12, [x0, #0x68]\n\t" /* context->X12 */
199 "str x13, [x0, #0x70]\n\t" /* context->X13 */
200 "str x14, [x0, #0x78]\n\t" /* context->X14 */
201 "str x15, [x0, #0x80]\n\t" /* context->X15 */
202 "str x16, [x0, #0x88]\n\t" /* context->X16 */
203 "str x17, [x0, #0x90]\n\t" /* context->X17 */
204 "str x18, [x0, #0x98]\n\t" /* context->X18 */
205 "str x19, [x0, #0xa0]\n\t" /* context->X19 */
206 "str x20, [x0, #0xa8]\n\t" /* context->X20 */
207 "str x21, [x0, #0xb0]\n\t" /* context->X21 */
208 "str x22, [x0, #0xb8]\n\t" /* context->X22 */
209 "str x23, [x0, #0xc0]\n\t" /* context->X23 */
210 "str x24, [x0, #0xc8]\n\t" /* context->X24 */
211 "str x25, [x0, #0xd0]\n\t" /* context->X25 */
212 "str x26, [x0, #0xd8]\n\t" /* context->X26 */
213 "str x27, [x0, #0xe0]\n\t" /* context->X27 */
214 "str x28, [x0, #0xe8]\n\t" /* context->X28 */
215 "str x29, [x0, #0xf0]\n\t" /* context->Fp */
216 "str x30, [x0, #0xf8]\n\t" /* context->Lr */
217 "mov x1, sp\n\t"
218 "str x1, [x0, #0x100]\n\t" /* context->Sp */
219 "adr x1, 1f\n\t"
220 "1: str x1, [x0, #0x108]\n\t" /* context->Pc */
221 "ret"
222 )
223
224 /***********************************************************************
225 * set_cpu_context
226 *
227 * Set the new CPU context.
228 */
229 static void set_cpu_context( const CONTEXT *context )
230 {
231 FIXME( "Not implemented on ARM64\n" );
232 }
233
234 /***********************************************************************
235 * copy_context
236 *
237 * Copy a register context according to the flags.
238 */
239 static void copy_context( CONTEXT *to, const CONTEXT *from, DWORD flags )
240 {
241 flags &= ~CONTEXT_ARM64; /* get rid of CPU id */
242 if (flags & CONTEXT_CONTROL)
243 {
244 to->Fp = from->Fp;
245 to->Lr = from->Lr;
246 to->Sp = from->Sp;
247 to->Pc = from->Pc;
248 to->Cpsr = from->Cpsr;
249 }
250 if (flags & CONTEXT_INTEGER)
251 {
252 memcpy( to->u.X, from->u.X, sizeof(to->u.X) );
253 }
254 if (flags & CONTEXT_FLOATING_POINT)
255 {
256 memcpy( to->V, from->V, sizeof(to->V) );
257 to->Fpcr = from->Fpcr;
258 to->Fpsr = from->Fpsr;
259 }
260 if (flags & CONTEXT_DEBUG_REGISTERS)
261 {
262 memcpy( to->Bcr, from->Bcr, sizeof(to->Bcr) );
263 memcpy( to->Bvr, from->Bvr, sizeof(to->Bvr) );
264 memcpy( to->Wcr, from->Wcr, sizeof(to->Wcr) );
265 memcpy( to->Wvr, from->Wvr, sizeof(to->Wvr) );
266 }
267 }
268
269 /***********************************************************************
270 * context_to_server
271 *
272 * Convert a register context to the server format.
273 */
274 NTSTATUS context_to_server( context_t *to, const CONTEXT *from )
275 {
276 DWORD i, flags = from->ContextFlags & ~CONTEXT_ARM64; /* get rid of CPU id */
277
278 memset( to, 0, sizeof(*to) );
279 to->cpu = CPU_ARM64;
280
281 if (flags & CONTEXT_CONTROL)
282 {
283 to->flags |= SERVER_CTX_CONTROL;
284 to->integer.arm64_regs.x[29] = from->Fp;
285 to->integer.arm64_regs.x[30] = from->Lr;
286 to->ctl.arm64_regs.sp = from->Sp;
287 to->ctl.arm64_regs.pc = from->Pc;
288 to->ctl.arm64_regs.pstate = from->Cpsr;
289 }
290 if (flags & CONTEXT_INTEGER)
291 {
292 to->flags |= SERVER_CTX_INTEGER;
293 for (i = 0; i <= 28; i++) to->integer.arm64_regs.x[i] = from->u.X[i];
294 }
295 if (flags & CONTEXT_FLOATING_POINT)
296 {
297 to->flags |= SERVER_CTX_FLOATING_POINT;
298 for (i = 0; i < 64; i++) to->fp.arm64_regs.d[i] = from->V[i / 2].D[i % 2];
299 to->fp.arm64_regs.fpcr = from->Fpcr;
300 to->fp.arm64_regs.fpsr = from->Fpsr;
301 }
302 if (flags & CONTEXT_DEBUG_REGISTERS)
303 {
304 to->flags |= SERVER_CTX_DEBUG_REGISTERS;
305 for (i = 0; i < ARM64_MAX_BREAKPOINTS; i++) to->debug.arm64_regs.bcr[i] = from->Bcr[i];
306 for (i = 0; i < ARM64_MAX_BREAKPOINTS; i++) to->debug.arm64_regs.bvr[i] = from->Bvr[i];
307 for (i = 0; i < ARM64_MAX_WATCHPOINTS; i++) to->debug.arm64_regs.wcr[i] = from->Wcr[i];
308 for (i = 0; i < ARM64_MAX_WATCHPOINTS; i++) to->debug.arm64_regs.wvr[i] = from->Wvr[i];
309 }
310 return STATUS_SUCCESS;
311 }
312
313
314 /***********************************************************************
315 * context_from_server
316 *
317 * Convert a register context from the server format.
318 */
319 NTSTATUS context_from_server( CONTEXT *to, const context_t *from )
320 {
321 DWORD i;
322
323 if (from->cpu != CPU_ARM64) return STATUS_INVALID_PARAMETER;
324
325 to->ContextFlags = CONTEXT_ARM64;
326 if (from->flags & SERVER_CTX_CONTROL)
327 {
328 to->ContextFlags |= CONTEXT_CONTROL;
329 to->Fp = from->integer.arm64_regs.x[29];
330 to->Lr = from->integer.arm64_regs.x[30];
331 to->Sp = from->ctl.arm64_regs.sp;
332 to->Pc = from->ctl.arm64_regs.pc;
333 to->Cpsr = from->ctl.arm64_regs.pstate;
334 }
335 if (from->flags & SERVER_CTX_INTEGER)
336 {
337 to->ContextFlags |= CONTEXT_INTEGER;
338 for (i = 0; i <= 28; i++) to->u.X[i] = from->integer.arm64_regs.x[i];
339 }
340 if (from->flags & SERVER_CTX_FLOATING_POINT)
341 {
342 to->ContextFlags |= CONTEXT_FLOATING_POINT;
343 for (i = 0; i < 64; i++) to->V[i / 2].D[i % 2] = from->fp.arm64_regs.d[i];
344 to->Fpcr = from->fp.arm64_regs.fpcr;
345 to->Fpsr = from->fp.arm64_regs.fpsr;
346 }
347 if (from->flags & SERVER_CTX_DEBUG_REGISTERS)
348 {
349 to->ContextFlags |= CONTEXT_DEBUG_REGISTERS;
350 for (i = 0; i < ARM64_MAX_BREAKPOINTS; i++) to->Bcr[i] = from->debug.arm64_regs.bcr[i];
351 for (i = 0; i < ARM64_MAX_BREAKPOINTS; i++) to->Bvr[i] = from->debug.arm64_regs.bvr[i];
352 for (i = 0; i < ARM64_MAX_WATCHPOINTS; i++) to->Wcr[i] = from->debug.arm64_regs.wcr[i];
353 for (i = 0; i < ARM64_MAX_WATCHPOINTS; i++) to->Wvr[i] = from->debug.arm64_regs.wvr[i];
354 }
355 return STATUS_SUCCESS;
356 }
357
358 /***********************************************************************
359 * NtSetContextThread (NTDLL.@)
360 * ZwSetContextThread (NTDLL.@)
361 */
362 NTSTATUS WINAPI NtSetContextThread( HANDLE handle, const CONTEXT *context )
363 {
364 NTSTATUS ret;
365 BOOL self;
366
367 ret = set_thread_context( handle, context, &self );
368 if (self && ret == STATUS_SUCCESS) set_cpu_context( context );
369 return ret;
370 }
371
372
373 /***********************************************************************
374 * NtGetContextThread (NTDLL.@)
375 * ZwGetContextThread (NTDLL.@)
376 */
377 NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context )
378 {
379 NTSTATUS ret;
380 DWORD needed_flags = context->ContextFlags;
381 BOOL self = (handle == GetCurrentThread());
382
383 if (!self)
384 {
385 if ((ret = get_thread_context( handle, context, &self ))) return ret;
386 needed_flags &= ~context->ContextFlags;
387 }
388
389 if (self && needed_flags)
390 {
391 CONTEXT ctx;
392 RtlCaptureContext( &ctx );
393 copy_context( context, &ctx, ctx.ContextFlags & needed_flags );
394 context->ContextFlags |= ctx.ContextFlags & needed_flags;
395 }
396 return STATUS_SUCCESS;
397 }
398
399
400 /***********************************************************************
401 * setup_exception_record
402 *
403 * Setup the exception record and context on the thread stack.
404 */
405 static EXCEPTION_RECORD *setup_exception( ucontext_t *sigcontext, raise_func func )
406 {
407 struct stack_layout
408 {
409 CONTEXT context;
410 EXCEPTION_RECORD rec;
411 } *stack;
412 DWORD exception_code = 0;
413
414 /* push the stack_layout structure */
415 stack = (struct stack_layout *)((SP_sig(sigcontext) - sizeof(*stack)) & ~15);
416
417 stack->rec.ExceptionRecord = NULL;
418 stack->rec.ExceptionCode = exception_code;
419 stack->rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
420 stack->rec.ExceptionAddress = (LPVOID)PC_sig(sigcontext);
421 stack->rec.NumberParameters = 0;
422
423 save_context( &stack->context, sigcontext );
424
425 /* now modify the sigcontext to return to the raise function */
426 SP_sig(sigcontext) = (ULONG_PTR)stack;
427 PC_sig(sigcontext) = (ULONG_PTR)func;
428 REGn_sig(0, sigcontext) = (ULONG_PTR)&stack->rec; /* first arg for raise_func */
429 REGn_sig(1, sigcontext) = (ULONG_PTR)&stack->context; /* second arg for raise_func */
430
431 return &stack->rec;
432 }
433
434 /**********************************************************************
435 * raise_segv_exception
436 */
437 static void WINAPI raise_segv_exception( EXCEPTION_RECORD *rec, CONTEXT *context )
438 {
439 NTSTATUS status;
440
441 switch(rec->ExceptionCode)
442 {
443 case EXCEPTION_ACCESS_VIOLATION:
444 if (rec->NumberParameters == 2)
445 {
446 if (!(rec->ExceptionCode = virtual_handle_fault( (void *)rec->ExceptionInformation[1],
447 rec->ExceptionInformation[0], FALSE )))
448 goto done;
449 }
450 break;
451 }
452 status = NtRaiseException( rec, context, TRUE );
453 if (status) raise_status( status, rec );
454 done:
455 set_cpu_context( context );
456 }
457
458 /**********************************************************************
459 * call_stack_handlers
460 *
461 * Call the stack handlers chain.
462 */
463 static NTSTATUS call_stack_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
464 {
465 EXCEPTION_REGISTRATION_RECORD *frame, *dispatch, *nested_frame;
466 DWORD res;
467
468 frame = NtCurrentTeb()->Tib.ExceptionList;
469 nested_frame = NULL;
470 while (frame != (EXCEPTION_REGISTRATION_RECORD*)~0UL)
471 {
472 /* Check frame address */
473 if (!is_valid_frame( frame ))
474 {
475 rec->ExceptionFlags |= EH_STACK_INVALID;
476 break;
477 }
478
479 /* Call handler */
480 TRACE( "calling handler at %p code=%x flags=%x\n",
481 frame->Handler, rec->ExceptionCode, rec->ExceptionFlags );
482 res = frame->Handler( rec, frame, context, &dispatch );
483 TRACE( "handler at %p returned %x\n", frame->Handler, res );
484
485 if (frame == nested_frame)
486 {
487 /* no longer nested */
488 nested_frame = NULL;
489 rec->ExceptionFlags &= ~EH_NESTED_CALL;
490 }
491
492 switch(res)
493 {
494 case ExceptionContinueExecution:
495 if (!(rec->ExceptionFlags & EH_NONCONTINUABLE)) return STATUS_SUCCESS;
496 return STATUS_NONCONTINUABLE_EXCEPTION;
497 case ExceptionContinueSearch:
498 break;
499 case ExceptionNestedException:
500 if (nested_frame < dispatch) nested_frame = dispatch;
501 rec->ExceptionFlags |= EH_NESTED_CALL;
502 break;
503 default:
504 return STATUS_INVALID_DISPOSITION;
505 }
506 frame = frame->Prev;
507 }
508 return STATUS_UNHANDLED_EXCEPTION;
509 }
510
511
512 /*******************************************************************
513 * raise_exception
514 *
515 * Implementation of NtRaiseException.
516 */
517 static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
518 {
519 NTSTATUS status;
520
521 if (first_chance)
522 {
523 DWORD c;
524
525 for (c = 0; c < rec->NumberParameters; c++)
526 TRACE( " info[%d]=%016lx\n", c, rec->ExceptionInformation[c] );
527 if (rec->ExceptionCode == EXCEPTION_WINE_STUB)
528 {
529 if (rec->ExceptionInformation[1] >> 16)
530 MESSAGE( "wine: Call from %p to unimplemented function %s.%s, aborting\n",
531 rec->ExceptionAddress,
532 (char*)rec->ExceptionInformation[0], (char*)rec->ExceptionInformation[1] );
533 else
534 MESSAGE( "wine: Call from %p to unimplemented function %s.%ld, aborting\n",
535 rec->ExceptionAddress,
536 (char*)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
537 }
538 else
539 {
540 /* FIXME: dump context */
541 }
542
543 status = send_debug_event( rec, TRUE, context );
544 if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
545 return STATUS_SUCCESS;
546
547 if (call_vectored_handlers( rec, context ) == EXCEPTION_CONTINUE_EXECUTION)
548 return STATUS_SUCCESS;
549
550 if ((status = call_stack_handlers( rec, context )) != STATUS_UNHANDLED_EXCEPTION)
551 return status;
552 }
553
554 /* last chance exception */
555
556 status = send_debug_event( rec, FALSE, context );
557 if (status != DBG_CONTINUE)
558 {
559 if (rec->ExceptionFlags & EH_STACK_INVALID)
560 ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
561 else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
562 ERR("Process attempted to continue execution after noncontinuable exception.\n");
563 else
564 ERR("Unhandled exception code %x flags %x addr %p\n",
565 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
566 NtTerminateProcess( NtCurrentProcess(), rec->ExceptionCode );
567 }
568 return STATUS_SUCCESS;
569 }
570
571 /**********************************************************************
572 * segv_handler
573 *
574 * Handler for SIGSEGV and related errors.
575 */
576 static void segv_handler( int signal, siginfo_t *info, void *ucontext )
577 {
578 EXCEPTION_RECORD *rec;
579 ucontext_t *context = ucontext;
580
581 /* check for page fault inside the thread stack */
582 if (signal == SIGSEGV &&
583 (char *)info->si_addr >= (char *)NtCurrentTeb()->DeallocationStack &&
584 (char *)info->si_addr < (char *)NtCurrentTeb()->Tib.StackBase &&
585 virtual_handle_stack_fault( info->si_addr ))
586 {
587 /* check if this was the last guard page */
588 if ((char *)info->si_addr < (char *)NtCurrentTeb()->DeallocationStack + 2*4096)
589 {
590 rec = setup_exception( context, raise_segv_exception );
591 rec->ExceptionCode = EXCEPTION_STACK_OVERFLOW;
592 }
593 return;
594 }
595
596 rec = setup_exception( context, raise_segv_exception );
597 if (rec->ExceptionCode == EXCEPTION_STACK_OVERFLOW) return;
598
599 switch(signal)
600 {
601 case SIGILL: /* Invalid opcode exception */
602 rec->ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
603 break;
604 case SIGSEGV: /* Segmentation fault */
605 rec->ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
606 rec->NumberParameters = 2;
607 /* FIXME: Currently the kernel provides no way to determine if it's read or write */
608 rec->ExceptionInformation[0] = 0;
609 rec->ExceptionInformation[1] = (ULONG_PTR)info->si_addr;
610 break;
611 case SIGBUS: /* Alignment check exception */
612 rec->ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
613 break;
614 default:
615 ERR("Got unexpected signal %i\n", signal);
616 rec->ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
617 break;
618 }
619 }
620
621 /**********************************************************************
622 * trap_handler
623 *
624 * Handler for SIGTRAP.
625 */
626 static void trap_handler( int signal, siginfo_t *info, void *ucontext )
627 {
628 EXCEPTION_RECORD rec;
629 CONTEXT context;
630 NTSTATUS status;
631
632 switch ( info->si_code )
633 {
634 case TRAP_TRACE:
635 rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
636 break;
637 case TRAP_BRKPT:
638 default:
639 rec.ExceptionCode = EXCEPTION_BREAKPOINT;
640 break;
641 }
642
643 save_context( &context, ucontext );
644 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
645 rec.ExceptionRecord = NULL;
646 rec.ExceptionAddress = (LPVOID)context.Pc;
647 rec.NumberParameters = 0;
648 status = raise_exception( &rec, &context, TRUE );
649 if (status) raise_status( status, &rec );
650 restore_context( &context, ucontext );
651 }
652
653 /**********************************************************************
654 * fpe_handler
655 *
656 * Handler for SIGFPE.
657 */
658 static void fpe_handler( int signal, siginfo_t *siginfo, void *sigcontext )
659 {
660 EXCEPTION_RECORD rec;
661 CONTEXT context;
662 NTSTATUS status;
663
664 save_fpu( &context, sigcontext );
665 save_context( &context, sigcontext );
666
667 switch (siginfo->si_code & 0xffff )
668 {
669 #ifdef FPE_FLTSUB
670 case FPE_FLTSUB:
671 rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
672 break;
673 #endif
674 #ifdef FPE_INTDIV
675 case FPE_INTDIV:
676 rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
677 break;
678 #endif
679 #ifdef FPE_INTOVF
680 case FPE_INTOVF:
681 rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
682 break;
683 #endif
684 #ifdef FPE_FLTDIV
685 case FPE_FLTDIV:
686 rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
687 break;
688 #endif
689 #ifdef FPE_FLTOVF
690 case FPE_FLTOVF:
691 rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
692 break;
693 #endif
694 #ifdef FPE_FLTUND
695 case FPE_FLTUND:
696 rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
697 break;
698 #endif
699 #ifdef FPE_FLTRES
700 case FPE_FLTRES:
701 rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
702 break;
703 #endif
704 #ifdef FPE_FLTINV
705 case FPE_FLTINV:
706 #endif
707 default:
708 rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
709 break;
710 }
711 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
712 rec.ExceptionRecord = NULL;
713 rec.ExceptionAddress = (LPVOID)context.Pc;
714 rec.NumberParameters = 0;
715 status = raise_exception( &rec, &context, TRUE );
716 if (status) raise_status( status, &rec );
717
718 restore_context( &context, sigcontext );
719 restore_fpu( &context, sigcontext );
720 }
721
722 /**********************************************************************
723 * int_handler
724 *
725 * Handler for SIGINT.
726 */
727 static void int_handler( int signal, siginfo_t *siginfo, void *sigcontext )
728 {
729 if (!dispatch_signal(SIGINT))
730 {
731 EXCEPTION_RECORD rec;
732 CONTEXT context;
733 NTSTATUS status;
734
735 save_context( &context, sigcontext );
736 rec.ExceptionCode = CONTROL_C_EXIT;
737 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
738 rec.ExceptionRecord = NULL;
739 rec.ExceptionAddress = (LPVOID)context.Pc;
740 rec.NumberParameters = 0;
741 status = raise_exception( &rec, &context, TRUE );
742 if (status) raise_status( status, &rec );
743 restore_context( &context, sigcontext );
744 }
745 }
746
747
748 /**********************************************************************
749 * abrt_handler
750 *
751 * Handler for SIGABRT.
752 */
753 static void abrt_handler( int signal, siginfo_t *siginfo, void *sigcontext )
754 {
755 EXCEPTION_RECORD rec;
756 CONTEXT context;
757 NTSTATUS status;
758
759 save_context( &context, sigcontext );
760 rec.ExceptionCode = EXCEPTION_WINE_ASSERTION;
761 rec.ExceptionFlags = EH_NONCONTINUABLE;
762 rec.ExceptionRecord = NULL;
763 rec.ExceptionAddress = (LPVOID)context.Pc;
764 rec.NumberParameters = 0;
765 status = raise_exception( &rec, &context, TRUE );
766 if (status) raise_status( status, &rec );
767 restore_context( &context, sigcontext );
768 }
769
770
771 /**********************************************************************
772 * quit_handler
773 *
774 * Handler for SIGQUIT.
775 */
776 static void quit_handler( int signal, siginfo_t *siginfo, void *sigcontext )
777 {
778 abort_thread(0);
779 }
780
781
782 /**********************************************************************
783 * usr1_handler
784 *
785 * Handler for SIGUSR1, used to signal a thread that it got suspended.
786 */
787 static void usr1_handler( int signal, siginfo_t *siginfo, void *sigcontext )
788 {
789 CONTEXT context;
790
791 save_context( &context, sigcontext );
792 wait_suspend( &context );
793 restore_context( &context, sigcontext );
794 }
795
796
797 /***********************************************************************
798 * __wine_set_signal_handler (NTDLL.@)
799 */
800 int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
801 {
802 if (sig >= sizeof(handlers) / sizeof(handlers[0])) return -1;
803 if (handlers[sig] != NULL) return -2;
804 handlers[sig] = wsh;
805 return 0;
806 }
807
808
809 /**********************************************************************
810 * signal_alloc_thread
811 */
812 NTSTATUS signal_alloc_thread( TEB **teb )
813 {
814 static size_t sigstack_zero_bits;
815 SIZE_T size;
816 NTSTATUS status;
817
818 if (!sigstack_zero_bits)
819 {
820 size_t min_size = teb_size + max( MINSIGSTKSZ, 8192 );
821 /* find the first power of two not smaller than min_size */
822 sigstack_zero_bits = 12;
823 while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++;
824 signal_stack_size = (1 << sigstack_zero_bits) - teb_size;
825 assert( sizeof(TEB) <= teb_size );
826 }
827
828 size = 1 << sigstack_zero_bits;
829 *teb = NULL;
830 if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)teb, sigstack_zero_bits,
831 &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE )))
832 {
833 (*teb)->Tib.Self = &(*teb)->Tib;
834 (*teb)->Tib.ExceptionList = (void *)~0UL;
835 }
836 return status;
837 }
838
839
840 /**********************************************************************
841 * signal_free_thread
842 */
843 void signal_free_thread( TEB *teb )
844 {
845 SIZE_T size = 0;
846
847 NtFreeVirtualMemory( NtCurrentProcess(), (void **)&teb, &size, MEM_RELEASE );
848 }
849
850
851 /**********************************************************************
852 * signal_init_thread
853 */
854 void signal_init_thread( TEB *teb )
855 {
856 static BOOL init_done;
857
858 if (!init_done)
859 {
860 pthread_key_create( &teb_key, NULL );
861 init_done = TRUE;
862 }
863
864 /* Win64/ARM applications expect the TEB pointer to be in the x18 platform register. */
865 __asm__ __volatile__( "mov x18, %0" : : "r" (teb) );
866
867 pthread_setspecific( teb_key, teb );
868 }
869
870
871 /**********************************************************************
872 * signal_init_process
873 */
874 void signal_init_process(void)
875 {
876 struct sigaction sig_act;
877
878 sig_act.sa_mask = server_block_set;
879 sig_act.sa_flags = SA_RESTART | SA_SIGINFO;
880
881 sig_act.sa_sigaction = int_handler;
882 if (sigaction( SIGINT, &sig_act, NULL ) == -1) goto error;
883 sig_act.sa_sigaction = fpe_handler;
884 if (sigaction( SIGFPE, &sig_act, NULL ) == -1) goto error;
885 sig_act.sa_sigaction = abrt_handler;
886 if (sigaction( SIGABRT, &sig_act, NULL ) == -1) goto error;
887 sig_act.sa_sigaction = quit_handler;
888 if (sigaction( SIGQUIT, &sig_act, NULL ) == -1) goto error;
889 sig_act.sa_sigaction = usr1_handler;
890 if (sigaction( SIGUSR1, &sig_act, NULL ) == -1) goto error;
891
892 sig_act.sa_sigaction = segv_handler;
893 if (sigaction( SIGSEGV, &sig_act, NULL ) == -1) goto error;
894 if (sigaction( SIGILL, &sig_act, NULL ) == -1) goto error;
895 #ifdef SIGBUS
896 if (sigaction( SIGBUS, &sig_act, NULL ) == -1) goto error;
897 #endif
898
899 #ifdef SIGTRAP
900 sig_act.sa_sigaction = trap_handler;
901 if (sigaction( SIGTRAP, &sig_act, NULL ) == -1) goto error;
902 #endif
903 return;
904
905 error:
906 perror("sigaction");
907 exit(1);
908 }
909
910
911 /**********************************************************************
912 * __wine_enter_vm86 (NTDLL.@)
913 */
914 void __wine_enter_vm86( CONTEXT *context )
915 {
916 MESSAGE("vm86 mode not supported on this platform\n");
917 }
918
919 /***********************************************************************
920 * RtlUnwind (NTDLL.@)
921 */
922 void WINAPI RtlUnwind( PVOID pEndFrame, PVOID targetIp, PEXCEPTION_RECORD pRecord, PVOID retval )
923 {
924 FIXME( "Not implemented on ARM64\n" );
925 }
926
927 /*******************************************************************
928 * NtRaiseException (NTDLL.@)
929 */
930 NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
931 {
932 NTSTATUS status = raise_exception( rec, context, first_chance );
933 if (status == STATUS_SUCCESS) NtSetContextThread( GetCurrentThread(), context );
934 return status;
935 }
936
937 /***********************************************************************
938 * RtlRaiseException (NTDLL.@)
939 */
940 void WINAPI RtlRaiseException( EXCEPTION_RECORD *rec )
941 {
942 CONTEXT context;
943 NTSTATUS status;
944
945 RtlCaptureContext( &context );
946 rec->ExceptionAddress = (LPVOID)context.Pc;
947 status = raise_exception( rec, &context, TRUE );
948 if (status) raise_status( status, rec );
949 }
950
951 /*************************************************************************
952 * RtlCaptureStackBackTrace (NTDLL.@)
953 */
954 USHORT WINAPI RtlCaptureStackBackTrace( ULONG skip, ULONG count, PVOID *buffer, ULONG *hash )
955 {
956 FIXME( "(%d, %d, %p, %p) stub!\n", skip, count, buffer, hash );
957 return 0;
958 }
959
960 /***********************************************************************
961 * call_thread_entry_point
962 */
963 static void WINAPI call_thread_entry_point( LPTHREAD_START_ROUTINE entry, void *arg )
964 {
965 __TRY
966 {
967 TRACE_(relay)( "\1Starting thread proc %p (arg=%p)\n", entry, arg );
968 RtlExitUserThread( entry( arg ));
969 }
970 __EXCEPT(unhandled_exception_filter)
971 {
972 NtTerminateThread( GetCurrentThread(), GetExceptionCode() );
973 }
974 __ENDTRY
975 abort(); /* should not be reached */
976 }
977
978 typedef void (WINAPI *thread_start_func)(LPTHREAD_START_ROUTINE,void *);
979
980 struct startup_info
981 {
982 thread_start_func start;
983 LPTHREAD_START_ROUTINE entry;
984 void *arg;
985 BOOL suspend;
986 };
987
988 /***********************************************************************
989 * thread_startup
990 */
991 static void thread_startup( void *param )
992 {
993 CONTEXT context = { 0 };
994 struct startup_info *info = param;
995
996 /* build the initial context */
997 context.ContextFlags = CONTEXT_FULL;
998 context.u.s.X0 = (DWORD_PTR)info->entry;
999 context.u.s.X1 = (DWORD_PTR)info->arg;
1000 context.Sp = (DWORD_PTR)NtCurrentTeb()->Tib.StackBase;
1001 context.Pc = (DWORD_PTR)info->start;
1002
1003 attach_dlls( &context, info->suspend );
1004
1005 ((thread_start_func)context.Pc)( (LPTHREAD_START_ROUTINE)context.u.s.X0, (void *)context.u.s.X1 );
1006 }
1007
1008 /***********************************************************************
1009 * signal_start_thread
1010 *
1011 * Thread startup sequence:
1012 * signal_start_thread()
1013 * -> thread_startup()
1014 * -> call_thread_entry_point()
1015 */
1016 void signal_start_thread( LPTHREAD_START_ROUTINE entry, void *arg, BOOL suspend )
1017 {
1018 struct startup_info info = { call_thread_entry_point, entry, arg, suspend };
1019 wine_switch_to_stack( thread_startup, &info, NtCurrentTeb()->Tib.StackBase );
1020 }
1021
1022 /**********************************************************************
1023 * signal_start_process
1024 *
1025 * Process startup sequence:
1026 * signal_start_process()
1027 * -> thread_startup()
1028 * -> kernel32_start_process()
1029 */
1030 void signal_start_process( LPTHREAD_START_ROUTINE entry, BOOL suspend )
1031 {
1032 struct startup_info info = { kernel32_start_process, entry, NtCurrentTeb()->Peb, suspend };
1033 wine_switch_to_stack( thread_startup, &info, NtCurrentTeb()->Tib.StackBase );
1034 }
1035
1036 /***********************************************************************
1037 * signal_exit_thread
1038 */
1039 void signal_exit_thread( int status )
1040 {
1041 exit_thread( status );
1042 }
1043
1044 /***********************************************************************
1045 * signal_exit_process
1046 */
1047 void signal_exit_process( int status )
1048 {
1049 exit( status );
1050 }
1051
1052 /**********************************************************************
1053 * DbgBreakPoint (NTDLL.@)
1054 */
1055 void WINAPI DbgBreakPoint(void)
1056 {
1057 kill(getpid(), SIGTRAP);
1058 }
1059
1060 /**********************************************************************
1061 * DbgUserBreakPoint (NTDLL.@)
1062 */
1063 void WINAPI DbgUserBreakPoint(void)
1064 {
1065 kill(getpid(), SIGTRAP);
1066 }
1067
1068 /**********************************************************************
1069 * NtCurrentTeb (NTDLL.@)
1070 */
1071 TEB * WINAPI NtCurrentTeb(void)
1072 {
1073 return pthread_getspecific( teb_key );
1074 }
1075
1076 #endif /* __aarch64__ */
Windows API implementation