2 * NT exception handling routines
4 * Copyright 1999 Turchanov Sergey
5 * Copyright 1999 Alexandre Julliard
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include "wine/port.h"
34 #include "wine/exception.h"
35 #include "wine/server.h"
36 #include "wine/list.h"
37 #include "wine/debug.h"
39 #include "ntdll_misc.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(seh
);
43 /* Exception record for handling exceptions happening inside exception handlers */
46 EXCEPTION_REGISTRATION_RECORD frame
;
47 EXCEPTION_REGISTRATION_RECORD
*prevFrame
;
53 PVECTORED_EXCEPTION_HANDLER func
;
56 static struct list vectored_handlers
= LIST_INIT(vectored_handlers
);
58 static CRITICAL_SECTION vectored_handlers_section
;
59 static CRITICAL_SECTION_DEBUG critsect_debug
=
61 0, 0, &vectored_handlers_section
,
62 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
63 0, 0, { 0, (DWORD
)(__FILE__
": vectored_handlers_section") }
65 static CRITICAL_SECTION vectored_handlers_section
= { &critsect_debug
, -1, 0, 0, 0, 0 };
68 # define GET_IP(context) ((LPVOID)(context)->Eip)
69 #elif defined(__sparc__)
70 # define GET_IP(context) ((LPVOID)(context)->pc)
71 #elif defined(__powerpc__)
72 # define GET_IP(context) ((LPVOID)(context)->Iar)
74 # error You must define GET_IP for this CPU
78 /*******************************************************************
81 * Handler for exceptions happening inside a handler.
83 static DWORD
EXC_RaiseHandler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
84 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
86 if (rec
->ExceptionFlags
& (EH_UNWINDING
| EH_EXIT_UNWIND
))
87 return ExceptionContinueSearch
;
88 /* We shouldn't get here so we store faulty frame in dispatcher */
89 *dispatcher
= ((EXC_NESTED_FRAME
*)frame
)->prevFrame
;
90 return ExceptionNestedException
;
94 /*******************************************************************
97 * Handler for exceptions happening inside an unwind handler.
99 static DWORD
EXC_UnwindHandler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
100 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
102 if (!(rec
->ExceptionFlags
& (EH_UNWINDING
| EH_EXIT_UNWIND
)))
103 return ExceptionContinueSearch
;
104 /* We shouldn't get here so we store faulty frame in dispatcher */
105 *dispatcher
= ((EXC_NESTED_FRAME
*)frame
)->prevFrame
;
106 return ExceptionCollidedUnwind
;
110 /*******************************************************************
113 * Call an exception handler, setting up an exception frame to catch exceptions
114 * happening during the handler execution.
115 * Please do not change the first 4 parameters order in any way - some exceptions handlers
116 * rely on Base Pointer (EBP) to have a fixed position related to the exception frame
118 static DWORD
EXC_CallHandler( EXCEPTION_RECORD
*record
, EXCEPTION_REGISTRATION_RECORD
*frame
,
119 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
,
120 PEXCEPTION_HANDLER handler
, PEXCEPTION_HANDLER nested_handler
)
122 EXC_NESTED_FRAME newframe
;
125 newframe
.frame
.Handler
= nested_handler
;
126 newframe
.prevFrame
= frame
;
127 __wine_push_frame( &newframe
.frame
);
128 TRACE( "calling handler at %p code=%lx flags=%lx\n",
129 handler
, record
->ExceptionCode
, record
->ExceptionFlags
);
130 ret
= handler( record
, frame
, context
, dispatcher
);
131 TRACE( "handler returned %lx\n", ret
);
132 __wine_pop_frame( &newframe
.frame
);
137 /**********************************************************************
140 * Send an EXCEPTION_DEBUG_EVENT event to the debugger.
142 static int send_debug_event( EXCEPTION_RECORD
*rec
, int first_chance
, CONTEXT
*context
)
147 if (!NtCurrentTeb()->Peb
->BeingDebugged
) return 0; /* no debugger present */
149 SERVER_START_REQ( queue_exception_event
)
151 req
->first
= first_chance
;
152 wine_server_add_data( req
, context
, sizeof(*context
) );
153 wine_server_add_data( req
, rec
, sizeof(*rec
) );
154 if (!wine_server_call( req
)) handle
= reply
->handle
;
157 if (!handle
) return 0;
159 /* No need to wait on the handle since the process gets suspended
160 * once the event is passed to the debugger, so when we get back
161 * here the event has been continued already.
163 SERVER_START_REQ( get_exception_status
)
165 req
->handle
= handle
;
166 wine_server_set_reply( req
, context
, sizeof(*context
) );
167 wine_server_call( req
);
176 /**********************************************************************
177 * call_vectored_handlers
179 * Call the vectored handlers chain.
181 static LONG
call_vectored_handlers( EXCEPTION_RECORD
*rec
, CONTEXT
*context
)
184 LONG ret
= EXCEPTION_CONTINUE_SEARCH
;
185 EXCEPTION_POINTERS except_ptrs
;
187 except_ptrs
.ExceptionRecord
= rec
;
188 except_ptrs
.ContextRecord
= context
;
190 RtlEnterCriticalSection( &vectored_handlers_section
);
191 LIST_FOR_EACH( ptr
, &vectored_handlers
)
193 VECTORED_HANDLER
*handler
= LIST_ENTRY( ptr
, VECTORED_HANDLER
, entry
);
194 ret
= handler
->func( &except_ptrs
);
195 if (ret
== EXCEPTION_CONTINUE_EXECUTION
) break;
197 RtlLeaveCriticalSection( &vectored_handlers_section
);
202 /*******************************************************************
203 * EXC_DefaultHandling
205 * Default handling for exceptions. Called when we didn't find a suitable handler.
207 static void EXC_DefaultHandling( EXCEPTION_RECORD
*rec
, CONTEXT
*context
)
209 if (send_debug_event( rec
, FALSE
, context
) == DBG_CONTINUE
) return; /* continue execution */
211 if (rec
->ExceptionFlags
& EH_STACK_INVALID
)
212 ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
213 else if (rec
->ExceptionCode
== EXCEPTION_NONCONTINUABLE_EXCEPTION
)
214 ERR("Process attempted to continue execution after noncontinuable exception.\n");
216 ERR("Unhandled exception code %lx flags %lx addr %p\n",
217 rec
->ExceptionCode
, rec
->ExceptionFlags
, rec
->ExceptionAddress
);
218 NtTerminateProcess( NtCurrentProcess(), 1 );
222 /***********************************************************************
223 * RtlRaiseException (NTDLL.@)
225 void WINAPI
EXC_RtlRaiseException( EXCEPTION_RECORD
*rec
, CONTEXT
*context
)
227 PEXCEPTION_REGISTRATION_RECORD frame
, dispatch
, nested_frame
;
228 EXCEPTION_RECORD newrec
;
231 TRACE( "code=%lx flags=%lx addr=%p\n", rec
->ExceptionCode
, rec
->ExceptionFlags
, rec
->ExceptionAddress
);
232 for (c
=0; c
<rec
->NumberParameters
; c
++) TRACE(" info[%ld]=%08lx\n", c
, rec
->ExceptionInformation
[c
]);
233 if (rec
->ExceptionCode
== EXCEPTION_WINE_STUB
)
234 FIXME( "call to unimplemented function %s.%s\n",
235 (char*)rec
->ExceptionInformation
[0], (char*)rec
->ExceptionInformation
[1] );
239 TRACE(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
240 context
->Eax
, context
->Ebx
, context
->Ecx
,
241 context
->Edx
, context
->Esi
, context
->Edi
);
242 TRACE(" ebp=%08lx esp=%08lx cs=%04lx ds=%04lx es=%04lx fs=%04lx gs=%04lx flags=%08lx\n",
243 context
->Ebp
, context
->Esp
, context
->SegCs
, context
->SegDs
,
244 context
->SegEs
, context
->SegFs
, context
->SegGs
, context
->EFlags
);
248 if (send_debug_event( rec
, TRUE
, context
) == DBG_CONTINUE
) return; /* continue execution */
250 if (call_vectored_handlers( rec
, context
) == EXCEPTION_CONTINUE_EXECUTION
) return;
252 frame
= NtCurrentTeb()->Tib
.ExceptionList
;
254 while (frame
!= (PEXCEPTION_REGISTRATION_RECORD
)~0UL)
256 /* Check frame address */
257 if (((void*)frame
< NtCurrentTeb()->Tib
.StackLimit
) ||
258 ((void*)(frame
+1) > NtCurrentTeb()->Tib
.StackBase
) ||
261 rec
->ExceptionFlags
|= EH_STACK_INVALID
;
266 res
= EXC_CallHandler( rec
, frame
, context
, &dispatch
, frame
->Handler
, EXC_RaiseHandler
);
267 if (frame
== nested_frame
)
269 /* no longer nested */
271 rec
->ExceptionFlags
&= ~EH_NESTED_CALL
;
276 case ExceptionContinueExecution
:
277 if (!(rec
->ExceptionFlags
& EH_NONCONTINUABLE
)) return;
278 newrec
.ExceptionCode
= STATUS_NONCONTINUABLE_EXCEPTION
;
279 newrec
.ExceptionFlags
= EH_NONCONTINUABLE
;
280 newrec
.ExceptionRecord
= rec
;
281 newrec
.NumberParameters
= 0;
282 RtlRaiseException( &newrec
); /* never returns */
284 case ExceptionContinueSearch
:
286 case ExceptionNestedException
:
287 if (nested_frame
< dispatch
) nested_frame
= dispatch
;
288 rec
->ExceptionFlags
|= EH_NESTED_CALL
;
291 newrec
.ExceptionCode
= STATUS_INVALID_DISPOSITION
;
292 newrec
.ExceptionFlags
= EH_NONCONTINUABLE
;
293 newrec
.ExceptionRecord
= rec
;
294 newrec
.NumberParameters
= 0;
295 RtlRaiseException( &newrec
); /* never returns */
300 EXC_DefaultHandling( rec
, context
);
303 #ifdef DEFINE_REGS_ENTRYPOINT
304 DEFINE_REGS_ENTRYPOINT( RtlRaiseException
, EXC_RtlRaiseException
, 4, 4 );
306 void WINAPI
RtlRaiseException( EXCEPTION_RECORD
*rec
)
309 memset( &context
, 0, sizeof(context
) );
310 EXC_RtlRaiseException( rec
, &context
);
315 /*******************************************************************
316 * RtlUnwind (NTDLL.@)
318 void WINAPI
EXC_RtlUnwind( PEXCEPTION_REGISTRATION_RECORD pEndFrame
, PVOID unusedEip
,
319 PEXCEPTION_RECORD pRecord
, PVOID returnEax
, CONTEXT
*context
)
321 EXCEPTION_RECORD record
, newrec
;
322 PEXCEPTION_REGISTRATION_RECORD frame
, dispatch
;
325 context
->Eax
= (DWORD
)returnEax
;
328 /* build an exception record, if we do not have one */
331 record
.ExceptionCode
= STATUS_UNWIND
;
332 record
.ExceptionFlags
= 0;
333 record
.ExceptionRecord
= NULL
;
334 record
.ExceptionAddress
= GET_IP(context
);
335 record
.NumberParameters
= 0;
339 pRecord
->ExceptionFlags
|= EH_UNWINDING
| (pEndFrame
? 0 : EH_EXIT_UNWIND
);
341 TRACE( "code=%lx flags=%lx\n", pRecord
->ExceptionCode
, pRecord
->ExceptionFlags
);
343 /* get chain of exception frames */
344 frame
= NtCurrentTeb()->Tib
.ExceptionList
;
345 while ((frame
!= (PEXCEPTION_REGISTRATION_RECORD
)~0UL) && (frame
!= pEndFrame
))
347 /* Check frame address */
348 if (pEndFrame
&& (frame
> pEndFrame
))
350 newrec
.ExceptionCode
= STATUS_INVALID_UNWIND_TARGET
;
351 newrec
.ExceptionFlags
= EH_NONCONTINUABLE
;
352 newrec
.ExceptionRecord
= pRecord
;
353 newrec
.NumberParameters
= 0;
354 RtlRaiseException( &newrec
); /* never returns */
356 if (((void*)frame
< NtCurrentTeb()->Tib
.StackLimit
) ||
357 ((void*)(frame
+1) > NtCurrentTeb()->Tib
.StackBase
) ||
360 newrec
.ExceptionCode
= STATUS_BAD_STACK
;
361 newrec
.ExceptionFlags
= EH_NONCONTINUABLE
;
362 newrec
.ExceptionRecord
= pRecord
;
363 newrec
.NumberParameters
= 0;
364 RtlRaiseException( &newrec
); /* never returns */
368 switch(EXC_CallHandler( pRecord
, frame
, context
, &dispatch
,
369 frame
->Handler
, EXC_UnwindHandler
))
371 case ExceptionContinueSearch
:
373 case ExceptionCollidedUnwind
:
377 newrec
.ExceptionCode
= STATUS_INVALID_DISPOSITION
;
378 newrec
.ExceptionFlags
= EH_NONCONTINUABLE
;
379 newrec
.ExceptionRecord
= pRecord
;
380 newrec
.NumberParameters
= 0;
381 RtlRaiseException( &newrec
); /* never returns */
384 frame
= __wine_pop_frame( frame
);
388 #ifdef DEFINE_REGS_ENTRYPOINT
389 DEFINE_REGS_ENTRYPOINT( RtlUnwind
, EXC_RtlUnwind
, 16, 16 );
391 void WINAPI
RtlUnwind( PVOID pEndFrame
, PVOID unusedEip
,
392 PEXCEPTION_RECORD pRecord
, PVOID returnEax
)
395 memset( &context
, 0, sizeof(context
) );
396 EXC_RtlUnwind( pEndFrame
, unusedEip
, pRecord
, returnEax
, &context
);
401 /*******************************************************************
402 * NtRaiseException (NTDLL.@)
404 void WINAPI
EXC_NtRaiseException( EXCEPTION_RECORD
*rec
, CONTEXT
*ctx
,
405 BOOL first
, CONTEXT
*context
)
407 EXC_RtlRaiseException( rec
, ctx
);
411 #ifdef DEFINE_REGS_ENTRYPOINT
412 DEFINE_REGS_ENTRYPOINT( NtRaiseException
, EXC_NtRaiseException
, 12, 12 );
414 void WINAPI
NtRaiseException( EXCEPTION_RECORD
*rec
, CONTEXT
*ctx
, BOOL first
)
417 memset( &context
, 0, sizeof(context
) );
418 EXC_NtRaiseException( rec
, ctx
, first
, &context
);
423 /***********************************************************************
424 * RtlRaiseStatus (NTDLL.@)
426 * Raise an exception with ExceptionCode = status
428 void WINAPI
RtlRaiseStatus( NTSTATUS status
)
430 EXCEPTION_RECORD ExceptionRec
;
432 ExceptionRec
.ExceptionCode
= status
;
433 ExceptionRec
.ExceptionFlags
= EH_NONCONTINUABLE
;
434 ExceptionRec
.ExceptionRecord
= NULL
;
435 ExceptionRec
.NumberParameters
= 0;
436 RtlRaiseException( &ExceptionRec
);
440 /*******************************************************************
441 * RtlAddVectoredExceptionHandler (NTDLL.@)
443 PVOID WINAPI
RtlAddVectoredExceptionHandler( ULONG first
, PVECTORED_EXCEPTION_HANDLER func
)
445 VECTORED_HANDLER
*handler
= RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*handler
) );
448 handler
->func
= func
;
449 RtlEnterCriticalSection( &vectored_handlers_section
);
450 if (first
) list_add_head( &vectored_handlers
, &handler
->entry
);
451 else list_add_tail( &vectored_handlers
, &handler
->entry
);
452 RtlLeaveCriticalSection( &vectored_handlers_section
);
458 /*******************************************************************
459 * RtlRemoveVectoredExceptionHandler (NTDLL.@)
461 ULONG WINAPI
RtlRemoveVectoredExceptionHandler( PVOID handler
)
466 RtlEnterCriticalSection( &vectored_handlers_section
);
467 LIST_FOR_EACH( ptr
, &vectored_handlers
)
469 if (ptr
== &((VECTORED_HANDLER
*)handler
)->entry
)
476 RtlLeaveCriticalSection( &vectored_handlers_section
);
477 if (ret
) RtlFreeHeap( GetProcessHeap(), 0, handler
);
482 /*************************************************************
483 * __wine_exception_handler (NTDLL.@)
485 * Exception handler for exception blocks declared in Wine code.
487 DWORD
__wine_exception_handler( EXCEPTION_RECORD
*record
, EXCEPTION_REGISTRATION_RECORD
*frame
,
488 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**pdispatcher
)
490 __WINE_FRAME
*wine_frame
= (__WINE_FRAME
*)frame
;
492 if (record
->ExceptionFlags
& (EH_UNWINDING
| EH_EXIT_UNWIND
| EH_NESTED_CALL
))
493 return ExceptionContinueSearch
;
494 if (wine_frame
->u
.filter
)
496 EXCEPTION_POINTERS ptrs
;
497 ptrs
.ExceptionRecord
= record
;
498 ptrs
.ContextRecord
= context
;
499 switch(wine_frame
->u
.filter( &ptrs
))
501 case EXCEPTION_CONTINUE_SEARCH
:
502 return ExceptionContinueSearch
;
503 case EXCEPTION_CONTINUE_EXECUTION
:
504 return ExceptionContinueExecution
;
505 case EXCEPTION_EXECUTE_HANDLER
:
508 MESSAGE( "Invalid return value from exception filter\n" );
512 /* hack to make GetExceptionCode() work in handler */
513 wine_frame
->ExceptionCode
= record
->ExceptionCode
;
514 wine_frame
->ExceptionRecord
= wine_frame
;
516 RtlUnwind( frame
, 0, record
, 0 );
517 __wine_pop_frame( frame
);
518 siglongjmp( wine_frame
->jmp
, 1 );
522 /*************************************************************
523 * __wine_finally_handler (NTDLL.@)
525 * Exception handler for try/finally blocks declared in Wine code.
527 DWORD
__wine_finally_handler( EXCEPTION_RECORD
*record
, EXCEPTION_REGISTRATION_RECORD
*frame
,
528 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**pdispatcher
)
530 if (record
->ExceptionFlags
& (EH_UNWINDING
| EH_EXIT_UNWIND
))
532 __WINE_FRAME
*wine_frame
= (__WINE_FRAME
*)frame
;
533 wine_frame
->u
.finally_func( FALSE
);
535 return ExceptionContinueSearch
;