2 * Win32 exception functions
4 * Copyright (c) 1996 Onno Hovers, (onno@stack.urc.tue.nl)
5 * Copyright (c) 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 * What really happens behind the scenes of those new
23 * __try{...}__except(..){....} and
24 * __try{...}__finally{...}
25 * statements is simply not documented by Microsoft. There could be different
27 * One reason could be that they try to hide the fact that exception
28 * handling in Win32 looks almost the same as in OS/2 2.x.
29 * Another reason could be that Microsoft does not want others to write
30 * binary compatible implementations of the Win32 API (like us).
32 * Whatever the reason, THIS SUCKS!! Ensuring portability or future
33 * compatibility may be valid reasons to keep some things undocumented.
34 * But exception handling is so basic to Win32 that it should be
39 #include "wine/port.h"
44 #define WIN32_NO_STATUS
51 #include "wine/exception.h"
52 #include "wine/library.h"
54 #include "wine/unicode.h"
55 #include "wine/debug.h"
57 WINE_DEFAULT_DEBUG_CHANNEL(seh
);
59 static PTOP_LEVEL_EXCEPTION_FILTER top_filter
;
61 typedef INT (WINAPI
*MessageBoxA_funcptr
)(HWND
,LPCSTR
,LPCSTR
,UINT
);
62 typedef INT (WINAPI
*MessageBoxW_funcptr
)(HWND
,LPCWSTR
,LPCWSTR
,UINT
);
64 /*******************************************************************
65 * RaiseException (KERNEL32.@)
67 void WINAPI
RaiseException( DWORD code
, DWORD flags
, DWORD nbargs
, const ULONG_PTR
*args
)
69 EXCEPTION_RECORD record
;
71 /* Compose an exception record */
73 record
.ExceptionCode
= code
;
74 record
.ExceptionFlags
= flags
& EH_NONCONTINUABLE
;
75 record
.ExceptionRecord
= NULL
;
76 record
.ExceptionAddress
= RaiseException
;
79 if (nbargs
> EXCEPTION_MAXIMUM_PARAMETERS
) nbargs
= EXCEPTION_MAXIMUM_PARAMETERS
;
80 record
.NumberParameters
= nbargs
;
81 memcpy( record
.ExceptionInformation
, args
, nbargs
* sizeof(*args
) );
83 else record
.NumberParameters
= 0;
85 RtlRaiseException( &record
);
89 /*******************************************************************
90 * format_exception_msg
92 static int format_exception_msg( const EXCEPTION_POINTERS
*ptr
, char *buffer
, int size
)
94 const EXCEPTION_RECORD
*rec
= ptr
->ExceptionRecord
;
97 switch(rec
->ExceptionCode
)
99 case EXCEPTION_INT_DIVIDE_BY_ZERO
:
100 len
= snprintf( buffer
, size
, "Unhandled division by zero" );
102 case EXCEPTION_INT_OVERFLOW
:
103 len
= snprintf( buffer
, size
, "Unhandled overflow" );
105 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED
:
106 len
= snprintf( buffer
, size
, "Unhandled array bounds" );
108 case EXCEPTION_ILLEGAL_INSTRUCTION
:
109 len
= snprintf( buffer
, size
, "Unhandled illegal instruction" );
111 case EXCEPTION_STACK_OVERFLOW
:
112 len
= snprintf( buffer
, size
, "Unhandled stack overflow" );
114 case EXCEPTION_PRIV_INSTRUCTION
:
115 len
= snprintf( buffer
, size
, "Unhandled privileged instruction" );
117 case EXCEPTION_ACCESS_VIOLATION
:
118 if (rec
->NumberParameters
== 2)
119 len
= snprintf( buffer
, size
, "Unhandled page fault on %s access to 0x%08lx",
120 rec
->ExceptionInformation
[0] == EXCEPTION_WRITE_FAULT
? "write" :
121 rec
->ExceptionInformation
[0] == EXCEPTION_EXECUTE_FAULT
? "execute" : "read",
122 rec
->ExceptionInformation
[1]);
124 len
= snprintf( buffer
, size
, "Unhandled page fault");
126 case EXCEPTION_DATATYPE_MISALIGNMENT
:
127 len
= snprintf( buffer
, size
, "Unhandled alignment" );
130 len
= snprintf( buffer
, size
, "Unhandled ^C");
132 case STATUS_POSSIBLE_DEADLOCK
:
133 len
= snprintf( buffer
, size
, "Critical section %08lx wait failed",
134 rec
->ExceptionInformation
[0]);
136 case EXCEPTION_WINE_STUB
:
137 if (HIWORD(rec
->ExceptionInformation
[1]))
138 len
= snprintf( buffer
, size
, "Unimplemented function %s.%s called",
139 (char *)rec
->ExceptionInformation
[0], (char *)rec
->ExceptionInformation
[1] );
141 len
= snprintf( buffer
, size
, "Unimplemented function %s.%ld called",
142 (char *)rec
->ExceptionInformation
[0], rec
->ExceptionInformation
[1] );
144 case EXCEPTION_WINE_ASSERTION
:
145 len
= snprintf( buffer
, size
, "Assertion failed" );
147 case EXCEPTION_VM86_INTx
:
148 len
= snprintf( buffer
, size
, "Unhandled interrupt %02lx in vm86 mode",
149 rec
->ExceptionInformation
[0]);
151 case EXCEPTION_VM86_STI
:
152 len
= snprintf( buffer
, size
, "Unhandled sti in vm86 mode");
154 case EXCEPTION_VM86_PICRETURN
:
155 len
= snprintf( buffer
, size
, "Unhandled PIC return in vm86 mode");
158 len
= snprintf( buffer
, size
, "Unhandled exception 0x%08x", rec
->ExceptionCode
);
161 if ((len
<0) || (len
>=size
))
164 if (ptr
->ContextRecord
->SegCs
!= wine_get_cs())
165 len2
= snprintf(buffer
+len
, size
-len
, " at address 0x%04x:0x%08x",
166 ptr
->ContextRecord
->SegCs
,
167 (DWORD
)ptr
->ExceptionRecord
->ExceptionAddress
);
170 len2
= snprintf(buffer
+len
, size
-len
, " at address %p",
171 ptr
->ExceptionRecord
->ExceptionAddress
);
172 if ((len2
<0) || (len
>=size
-len
))
178 /******************************************************************
181 * Does the effective debugger startup according to 'format'
183 static BOOL
start_debugger(PEXCEPTION_POINTERS epointers
, HANDLE hEvent
)
185 OBJECT_ATTRIBUTES attr
;
186 UNICODE_STRING nameW
;
187 char *cmdline
, *env
, *p
;
190 PROCESS_INFORMATION info
;
191 STARTUPINFOA startup
;
196 static const WCHAR AeDebugW
[] = {'M','a','c','h','i','n','e','\\',
197 'S','o','f','t','w','a','r','e','\\',
198 'M','i','c','r','o','s','o','f','t','\\',
199 'W','i','n','d','o','w','s',' ','N','T','\\',
200 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
201 'A','e','D','e','b','u','g',0};
202 static const WCHAR DebuggerW
[] = {'D','e','b','u','g','g','e','r',0};
203 static const WCHAR AutoW
[] = {'A','u','t','o',0};
205 format_exception_msg( epointers
, buffer
, sizeof(buffer
) );
206 MESSAGE("wine: %s (thread %04x), starting debugger...\n", buffer
, GetCurrentThreadId());
208 attr
.Length
= sizeof(attr
);
209 attr
.RootDirectory
= 0;
210 attr
.ObjectName
= &nameW
;
212 attr
.SecurityDescriptor
= NULL
;
213 attr
.SecurityQualityOfService
= NULL
;
214 RtlInitUnicodeString( &nameW
, AeDebugW
);
216 if (!NtOpenKey( &hDbgConf
, KEY_ALL_ACCESS
, &attr
))
219 KEY_VALUE_PARTIAL_INFORMATION
*info
;
220 DWORD format_size
= 0;
222 RtlInitUnicodeString( &nameW
, DebuggerW
);
223 if (NtQueryValueKey( hDbgConf
, &nameW
, KeyValuePartialInformation
,
224 NULL
, 0, &format_size
) == STATUS_BUFFER_OVERFLOW
)
226 char *data
= HeapAlloc(GetProcessHeap(), 0, format_size
);
227 NtQueryValueKey( hDbgConf
, &nameW
, KeyValuePartialInformation
,
228 data
, format_size
, &format_size
);
229 info
= (KEY_VALUE_PARTIAL_INFORMATION
*)data
;
230 RtlUnicodeToMultiByteSize( &format_size
, (WCHAR
*)info
->Data
, info
->DataLength
);
231 format
= HeapAlloc( GetProcessHeap(), 0, format_size
+1 );
232 RtlUnicodeToMultiByteN( format
, format_size
, NULL
,
233 (WCHAR
*)info
->Data
, info
->DataLength
);
234 format
[format_size
] = 0;
236 if (info
->Type
== REG_EXPAND_SZ
)
240 /* Expand environment variable references */
241 format_size
=ExpandEnvironmentStringsA(format
,NULL
,0);
242 tmp
=HeapAlloc(GetProcessHeap(), 0, format_size
);
243 ExpandEnvironmentStringsA(format
,tmp
,format_size
);
244 HeapFree(GetProcessHeap(), 0, format
);
247 HeapFree( GetProcessHeap(), 0, data
);
250 RtlInitUnicodeString( &nameW
, AutoW
);
251 if (!NtQueryValueKey( hDbgConf
, &nameW
, KeyValuePartialInformation
,
252 buffer
, sizeof(buffer
)-sizeof(WCHAR
), &format_size
))
254 info
= (KEY_VALUE_PARTIAL_INFORMATION
*)buffer
;
255 if (info
->Type
== REG_DWORD
) memcpy( &bAuto
, info
->Data
, sizeof(DWORD
) );
256 else if (info
->Type
== REG_SZ
)
258 WCHAR
*str
= (WCHAR
*)info
->Data
;
259 str
[info
->DataLength
/sizeof(WCHAR
)] = 0;
260 bAuto
= atoiW( str
);
269 cmdline
= HeapAlloc(GetProcessHeap(), 0, strlen(format
) + 2*20);
270 sprintf(cmdline
, format
, GetCurrentProcessId(), hEvent
);
271 HeapFree(GetProcessHeap(), 0, format
);
275 cmdline
= HeapAlloc(GetProcessHeap(), 0, 80);
276 sprintf(cmdline
, "winedbg --auto %d %ld",
277 GetCurrentProcessId(), (ULONG_PTR
)hEvent
);
282 HMODULE mod
= GetModuleHandleA( "user32.dll" );
283 MessageBoxA_funcptr pMessageBoxA
= NULL
;
285 if (mod
) pMessageBoxA
= (MessageBoxA_funcptr
)GetProcAddress( mod
, "MessageBoxA" );
288 static const char msg
[] = ".\nDo you wish to debug it?";
291 format_exception_msg( epointers
, buffer
, sizeof(buffer
)-sizeof(msg
) );
292 strcat( buffer
, msg
);
293 if (pMessageBoxA( 0, buffer
, "Exception raised", MB_YESNO
| MB_ICONHAND
) == IDNO
)
295 TRACE("Killing process\n");
301 /* make WINEDEBUG empty in the environment */
302 env
= GetEnvironmentStringsA();
303 for (p
= env
; *p
; p
+= strlen(p
) + 1)
305 if (!memcmp( p
, "WINEDEBUG=", sizeof("WINEDEBUG=")-1 ))
307 char *next
= p
+ strlen(p
);
308 char *end
= next
+ 1;
309 while (*end
) end
+= strlen(end
) + 1;
310 memmove( p
+ sizeof("WINEDEBUG=") - 1, next
, end
+ 1 - next
);
315 TRACE("Starting debugger %s\n", debugstr_a(cmdline
));
316 memset(&startup
, 0, sizeof(startup
));
317 startup
.cb
= sizeof(startup
);
318 startup
.dwFlags
= STARTF_USESHOWWINDOW
;
319 startup
.wShowWindow
= SW_SHOWNORMAL
;
320 ret
= CreateProcessA(NULL
, cmdline
, NULL
, NULL
, TRUE
, 0, env
, NULL
, &startup
, &info
);
321 FreeEnvironmentStringsA( env
);
323 if (ret
) WaitForSingleObject(hEvent
, INFINITE
); /* wait for debugger to come up... */
324 else ERR("Couldn't start debugger (%s) (%d)\n"
325 "Read the Wine Developers Guide on how to set up winedbg or another debugger\n",
326 debugstr_a(cmdline
), GetLastError());
328 HeapFree(GetProcessHeap(), 0, cmdline
);
332 /******************************************************************
333 * start_debugger_atomic
335 * starts the debugger in an atomic way:
336 * - either the debugger is not started and it is started
337 * - or the debugger has already been started by another thread
338 * - or the debugger couldn't be started
340 * returns TRUE for the two first conditions, FALSE for the last
342 static int start_debugger_atomic(PEXCEPTION_POINTERS epointers
)
344 static HANDLE hRunOnce
/* = 0 */;
348 OBJECT_ATTRIBUTES attr
;
351 attr
.Length
= sizeof(attr
);
352 attr
.RootDirectory
= 0;
353 attr
.Attributes
= OBJ_INHERIT
;
354 attr
.ObjectName
= NULL
;
355 attr
.SecurityDescriptor
= NULL
;
356 attr
.SecurityQualityOfService
= NULL
;
358 /* ask for manual reset, so that once the debugger is started,
359 * every thread will know it */
360 NtCreateEvent( &hEvent
, EVENT_ALL_ACCESS
, &attr
, TRUE
, FALSE
);
361 if (InterlockedCompareExchangePointer( (PVOID
)&hRunOnce
, hEvent
, 0 ) == 0)
363 /* ok, our event has been set... we're the winning thread */
364 BOOL ret
= start_debugger( epointers
, hRunOnce
);
369 /* so that the other threads won't be stuck */
370 NtSetEvent( hRunOnce
, &tmp
);
375 /* someone beat us here... */
376 CloseHandle( hEvent
);
379 /* and wait for the winner to have actually created the debugger */
380 WaitForSingleObject( hRunOnce
, INFINITE
);
381 /* in fact, here, we only know that someone has tried to start the debugger,
382 * we'll know by reposting the exception if it has actually attached
383 * to the current process */
388 /*******************************************************************
389 * check_resource_write
391 * Check if the exception is a write attempt to the resource data.
392 * If yes, we unprotect the resources to let broken apps continue
393 * (Windows does this too).
395 static inline BOOL
check_resource_write( void *addr
)
399 MEMORY_BASIC_INFORMATION info
;
401 if (!VirtualQuery( addr
, &info
, sizeof(info
) )) return FALSE
;
402 if (info
.State
== MEM_FREE
|| !(info
.Type
& MEM_IMAGE
)) return FALSE
;
403 if (!(rsrc
= RtlImageDirectoryEntryToData( (HMODULE
)info
.AllocationBase
, TRUE
,
404 IMAGE_DIRECTORY_ENTRY_RESOURCE
, &size
)))
406 if (addr
< rsrc
|| (char *)addr
>= (char *)rsrc
+ size
) return FALSE
;
407 TRACE( "Broken app is writing to the resource data, enabling work-around\n" );
408 VirtualProtect( rsrc
, size
, PAGE_WRITECOPY
, NULL
);
413 /*******************************************************************
416 * Check for executing a protected area.
418 static inline BOOL
check_no_exec( void *addr
)
420 MEMORY_BASIC_INFORMATION info
;
422 if (!VirtualQuery( addr
, &info
, sizeof(info
) )) return FALSE
;
423 if (info
.State
== MEM_FREE
) return FALSE
;
425 /* prot |= PAGE_EXECUTE would be a lot easier, but MS developers
426 * apparently don't grasp the notion of protection bits */
429 case PAGE_READONLY
: info
.Protect
= PAGE_EXECUTE_READ
; break;
430 case PAGE_READWRITE
: info
.Protect
= PAGE_EXECUTE_READWRITE
; break;
431 case PAGE_WRITECOPY
: info
.Protect
= PAGE_EXECUTE_WRITECOPY
; break;
432 default: return FALSE
;
434 /* FIXME: we should probably have a per-app option, and maybe a message box */
435 FIXME( "No-exec fault triggered at %p, enabling work-around\n", addr
);
436 return VirtualProtect( addr
, 1, info
.Protect
, NULL
);
440 /*******************************************************************
441 * UnhandledExceptionFilter (KERNEL32.@)
443 LONG WINAPI
UnhandledExceptionFilter(PEXCEPTION_POINTERS epointers
)
445 const EXCEPTION_RECORD
*rec
= epointers
->ExceptionRecord
;
447 if (rec
->ExceptionCode
== EXCEPTION_ACCESS_VIOLATION
&& rec
->NumberParameters
>= 2)
449 switch(rec
->ExceptionInformation
[0])
451 case EXCEPTION_WRITE_FAULT
:
452 if (check_resource_write( (void *)rec
->ExceptionInformation
[1] ))
453 return EXCEPTION_CONTINUE_EXECUTION
;
455 case EXCEPTION_EXECUTE_FAULT
:
456 if (check_no_exec( (void *)rec
->ExceptionInformation
[1] ))
457 return EXCEPTION_CONTINUE_EXECUTION
;
462 if (!NtCurrentTeb()->Peb
->BeingDebugged
)
464 if (rec
->ExceptionCode
== CONTROL_C_EXIT
)
466 /* do not launch the debugger on ^C, simply terminate the process */
467 TerminateProcess( GetCurrentProcess(), 1 );
472 LONG ret
= top_filter( epointers
);
473 if (ret
!= EXCEPTION_CONTINUE_SEARCH
) return ret
;
476 /* FIXME: Should check the current error mode */
478 if (!start_debugger_atomic( epointers
) || !NtCurrentTeb()->Peb
->BeingDebugged
)
479 return EXCEPTION_EXECUTE_HANDLER
;
481 return EXCEPTION_CONTINUE_SEARCH
;
485 /***********************************************************************
486 * SetUnhandledExceptionFilter (KERNEL32.@)
488 LPTOP_LEVEL_EXCEPTION_FILTER WINAPI
SetUnhandledExceptionFilter(
489 LPTOP_LEVEL_EXCEPTION_FILTER filter
)
491 LPTOP_LEVEL_EXCEPTION_FILTER old
= top_filter
;
497 /**************************************************************************
498 * FatalAppExitA (KERNEL32.@)
500 void WINAPI
FatalAppExitA( UINT action
, LPCSTR str
)
502 HMODULE mod
= GetModuleHandleA( "user32.dll" );
503 MessageBoxA_funcptr pMessageBoxA
= NULL
;
507 if (mod
) pMessageBoxA
= (MessageBoxA_funcptr
)GetProcAddress( mod
, "MessageBoxA" );
508 if (pMessageBoxA
) pMessageBoxA( 0, str
, NULL
, MB_SYSTEMMODAL
| MB_OK
);
509 else ERR( "%s\n", debugstr_a(str
) );
514 /**************************************************************************
515 * FatalAppExitW (KERNEL32.@)
517 void WINAPI
FatalAppExitW( UINT action
, LPCWSTR str
)
519 static const WCHAR User32DllW
[] = {'u','s','e','r','3','2','.','d','l','l',0};
521 HMODULE mod
= GetModuleHandleW( User32DllW
);
522 MessageBoxW_funcptr pMessageBoxW
= NULL
;
526 if (mod
) pMessageBoxW
= (MessageBoxW_funcptr
)GetProcAddress( mod
, "MessageBoxW" );
527 if (pMessageBoxW
) pMessageBoxW( 0, str
, NULL
, MB_SYSTEMMODAL
| MB_OK
);
528 else ERR( "%s\n", debugstr_w(str
) );
533 /**************************************************************************
534 * FatalExit (KERNEL32.@)
536 void WINAPI
FatalExit(int ExitCode
)
539 ExitProcess(ExitCode
);