dlls/ntdll/exception.c

   1 /*
   2  * NT exception handling routines
   3  *
   4  * Copyright 1999 Turchanov Sergey
   5  * Copyright 1999 Alexandre Julliard
   6  *
   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.
  11  *
  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.
  16  *
  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
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <assert.h>
  26 #include <errno.h>
  27 #include <signal.h>
  28 #include <stdarg.h>
  29
  30 #include "ntstatus.h"
  31 #define WIN32_NO_STATUS
  32 #include "windef.h"
  33 #include "winternl.h"
  34 #include "wine/exception.h"
  35 #include "wine/server.h"
  36 #include "wine/list.h"
  37 #include "wine/debug.h"
  38 #include "excpt.h"
  39 #include "ntdll_misc.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(seh);
  42
  43 typedef struct
  44 {
  45     struct list                 entry;
  46     PVECTORED_EXCEPTION_HANDLER func;
  47     ULONG                       count;
  48 } VECTORED_HANDLER;
  49
  50 static struct list vectored_exception_handlers = LIST_INIT(vectored_exception_handlers);
  51 static struct list vectored_continue_handlers  = LIST_INIT(vectored_continue_handlers);
  52
  53 static RTL_CRITICAL_SECTION vectored_handlers_section;
  54 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
  55 {
  56     0, 0, &vectored_handlers_section,
  57     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  58       0, 0, { (DWORD_PTR)(__FILE__ ": vectored_handlers_section") }
  59 };
  60 static RTL_CRITICAL_SECTION vectored_handlers_section = { &critsect_debug, -1, 0, 0, 0, 0 };
  61
  62 static PRTL_EXCEPTION_FILTER unhandled_exception_filter;
  63
  64
  65 static VECTORED_HANDLER *add_vectored_handler( struct list *handler_list, ULONG first,
  66                                                PVECTORED_EXCEPTION_HANDLER func )
  67 {
  68     VECTORED_HANDLER *handler = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*handler) );
  69     if (handler)
  70     {
  71         handler->func = RtlEncodePointer( func );
  72         handler->count = 1;
  73         RtlEnterCriticalSection( &vectored_handlers_section );
  74         if (first) list_add_head( handler_list, &handler->entry );
  75         else list_add_tail( handler_list, &handler->entry );
  76         RtlLeaveCriticalSection( &vectored_handlers_section );
  77     }
  78     return handler;
  79 }
  80
  81
  82 static ULONG remove_vectored_handler( struct list *handler_list, VECTORED_HANDLER *handler )
  83 {
  84     struct list *ptr;
  85     ULONG ret = FALSE;
  86
  87     RtlEnterCriticalSection( &vectored_handlers_section );
  88     LIST_FOR_EACH( ptr, handler_list )
  89     {
  90         VECTORED_HANDLER *curr_handler = LIST_ENTRY( ptr, VECTORED_HANDLER, entry );
  91         if (curr_handler == handler)
  92         {
  93             if (!--curr_handler->count) list_remove( ptr );
  94             else handler = NULL;  /* don't free it yet */
  95             ret = TRUE;
  96             break;
  97         }
  98     }
  99     RtlLeaveCriticalSection( &vectored_handlers_section );
 100     if (ret) RtlFreeHeap( GetProcessHeap(), 0, handler );
 101     return ret;
 102 }
 103
 104
 105 /**********************************************************************
 106  *           wait_suspend
 107  *
 108  * Wait until the thread is no longer suspended.
 109  */
 110 void wait_suspend( CONTEXT *context )
 111 {
 112     LARGE_INTEGER timeout;
 113     int saved_errno = errno;
 114     context_t server_context;
 115     DWORD flags = context->ContextFlags;
 116
 117     context_to_server( &server_context, context );
 118
 119     /* store the context we got at suspend time */
 120     SERVER_START_REQ( set_suspend_context )
 121     {
 122         wine_server_add_data( req, &server_context, sizeof(server_context) );
 123         wine_server_call( req );
 124     }
 125     SERVER_END_REQ;
 126
 127     /* wait with 0 timeout, will only return once the thread is no longer suspended */
 128     timeout.QuadPart = 0;
 129     server_select( NULL, 0, SELECT_INTERRUPTIBLE, &timeout );
 130
 131     /* retrieve the new context */
 132     SERVER_START_REQ( get_suspend_context )
 133     {
 134         wine_server_set_reply( req, &server_context, sizeof(server_context) );
 135         wine_server_call( req );
 136         if (wine_server_reply_size( reply ))
 137         {
 138             context_from_server( context, &server_context );
 139             context->ContextFlags |= flags;  /* unchanged registers are still available */
 140         }
 141     }
 142     SERVER_END_REQ;
 143
 144     errno = saved_errno;
 145 }
 146
 147
 148 /**********************************************************************
 149  *           send_debug_event
 150  *
 151  * Send an EXCEPTION_DEBUG_EVENT event to the debugger.
 152  */
 153 NTSTATUS send_debug_event( EXCEPTION_RECORD *rec, int first_chance, CONTEXT *context )
 154 {
 155     NTSTATUS ret;
 156     DWORD i;
 157     obj_handle_t handle = 0;
 158     client_ptr_t params[EXCEPTION_MAXIMUM_PARAMETERS];
 159     context_t server_context;
 160     select_op_t select_op;
 161
 162     if (!NtCurrentTeb()->Peb->BeingDebugged) return 0;  /* no debugger present */
 163
 164     for (i = 0; i < min( rec->NumberParameters, EXCEPTION_MAXIMUM_PARAMETERS ); i++)
 165         params[i] = rec->ExceptionInformation[i];
 166
 167     context_to_server( &server_context, context );
 168
 169     SERVER_START_REQ( queue_exception_event )
 170     {
 171         req->first   = first_chance;
 172         req->code    = rec->ExceptionCode;
 173         req->flags   = rec->ExceptionFlags;
 174         req->record  = wine_server_client_ptr( rec->ExceptionRecord );
 175         req->address = wine_server_client_ptr( rec->ExceptionAddress );
 176         req->len     = i * sizeof(params[0]);
 177         wine_server_add_data( req, params, req->len );
 178         wine_server_add_data( req, &server_context, sizeof(server_context) );
 179         if (!wine_server_call( req )) handle = reply->handle;
 180     }
 181     SERVER_END_REQ;
 182     if (!handle) return 0;
 183
 184     select_op.wait.op = SELECT_WAIT;
 185     select_op.wait.handles[0] = handle;
 186     server_select( &select_op, offsetof( select_op_t, wait.handles[1] ), SELECT_INTERRUPTIBLE, NULL );
 187
 188     SERVER_START_REQ( get_exception_status )
 189     {
 190         req->handle = handle;
 191         wine_server_set_reply( req, &server_context, sizeof(server_context) );
 192         ret = wine_server_call( req );
 193     }
 194     SERVER_END_REQ;
 195     if (ret >= 0) context_from_server( context, &server_context );
 196     return ret;
 197 }
 198
 199
 200 /**********************************************************************
 201  *           call_vectored_handlers
 202  *
 203  * Call the vectored handlers chain.
 204  */
 205 LONG call_vectored_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
 206 {
 207     struct list *ptr;
 208     LONG ret = EXCEPTION_CONTINUE_SEARCH;
 209     EXCEPTION_POINTERS except_ptrs;
 210     PVECTORED_EXCEPTION_HANDLER func;
 211     VECTORED_HANDLER *handler, *to_free = NULL;
 212
 213     except_ptrs.ExceptionRecord = rec;
 214     except_ptrs.ContextRecord = context;
 215
 216     RtlEnterCriticalSection( &vectored_handlers_section );
 217     ptr = list_head( &vectored_exception_handlers );
 218     while (ptr)
 219     {
 220         handler = LIST_ENTRY( ptr, VECTORED_HANDLER, entry );
 221         handler->count++;
 222         func = RtlDecodePointer( handler->func );
 223         RtlLeaveCriticalSection( &vectored_handlers_section );
 224         RtlFreeHeap( GetProcessHeap(), 0, to_free );
 225         to_free = NULL;
 226
 227         TRACE( "calling handler at %p code=%x flags=%x\n",
 228                func, rec->ExceptionCode, rec->ExceptionFlags );
 229         ret = func( &except_ptrs );
 230         TRACE( "handler at %p returned %x\n", func, ret );
 231
 232         RtlEnterCriticalSection( &vectored_handlers_section );
 233         ptr = list_next( &vectored_exception_handlers, ptr );
 234         if (!--handler->count)  /* removed during execution */
 235         {
 236             list_remove( &handler->entry );
 237             to_free = handler;
 238         }
 239         if (ret == EXCEPTION_CONTINUE_EXECUTION) break;
 240     }
 241     RtlLeaveCriticalSection( &vectored_handlers_section );
 242     RtlFreeHeap( GetProcessHeap(), 0, to_free );
 243     return ret;
 244 }
 245
 246
 247 /*******************************************************************
 248  *              raise_status
 249  *
 250  * Implementation of RtlRaiseStatus with a specific exception record.
 251  */
 252 void raise_status( NTSTATUS status, EXCEPTION_RECORD *rec )
 253 {
 254     EXCEPTION_RECORD ExceptionRec;
 255
 256     ExceptionRec.ExceptionCode    = status;
 257     ExceptionRec.ExceptionFlags   = EH_NONCONTINUABLE;
 258     ExceptionRec.ExceptionRecord  = rec;
 259     ExceptionRec.NumberParameters = 0;
 260     for (;;) RtlRaiseException( &ExceptionRec );  /* never returns */
 261 }
 262
 263
 264 /***********************************************************************
 265  *            RtlRaiseStatus  (NTDLL.@)
 266  *
 267  * Raise an exception with ExceptionCode = status
 268  */
 269 void WINAPI RtlRaiseStatus( NTSTATUS status )
 270 {
 271     raise_status( status, NULL );
 272 }
 273
 274
 275 /*******************************************************************
 276  *         RtlAddVectoredContinueHandler   (NTDLL.@)
 277  */
 278 PVOID WINAPI RtlAddVectoredContinueHandler( ULONG first, PVECTORED_EXCEPTION_HANDLER func )
 279 {
 280     return add_vectored_handler( &vectored_continue_handlers, first, func );
 281 }
 282
 283
 284 /*******************************************************************
 285  *         RtlRemoveVectoredContinueHandler   (NTDLL.@)
 286  */
 287 ULONG WINAPI RtlRemoveVectoredContinueHandler( PVOID handler )
 288 {
 289     return remove_vectored_handler( &vectored_continue_handlers, handler );
 290 }
 291
 292
 293 /*******************************************************************
 294  *         RtlAddVectoredExceptionHandler   (NTDLL.@)
 295  */
 296 PVOID WINAPI DECLSPEC_HOTPATCH RtlAddVectoredExceptionHandler( ULONG first, PVECTORED_EXCEPTION_HANDLER func )
 297 {
 298     return add_vectored_handler( &vectored_exception_handlers, first, func );
 299 }
 300
 301
 302 /*******************************************************************
 303  *         RtlRemoveVectoredExceptionHandler   (NTDLL.@)
 304  */
 305 ULONG WINAPI RtlRemoveVectoredExceptionHandler( PVOID handler )
 306 {
 307     return remove_vectored_handler( &vectored_exception_handlers, handler );
 308 }
 309
 310
 311 /*******************************************************************
 312  *         RtlSetUnhandledExceptionFilter   (NTDLL.@)
 313  */
 314 void WINAPI RtlSetUnhandledExceptionFilter( PRTL_EXCEPTION_FILTER filter )
 315 {
 316     unhandled_exception_filter = filter;
 317 }
 318
 319
 320 /*******************************************************************
 321  *         call_unhandled_exception_filter
 322  */
 323 LONG WINAPI call_unhandled_exception_filter( PEXCEPTION_POINTERS eptr )
 324 {
 325     if (!unhandled_exception_filter) return EXCEPTION_CONTINUE_SEARCH;
 326     return unhandled_exception_filter( eptr );
 327 }
 328
 329
 330 /*************************************************************
 331  *            __wine_spec_unimplemented_stub
 332  *
 333  * ntdll-specific implementation to avoid depending on kernel functions.
 334  * Can be removed once ntdll.spec no longer contains stubs.
 335  */
 336 void __cdecl __wine_spec_unimplemented_stub( const char *module, const char *function )
 337 {
 338     EXCEPTION_RECORD record;
 339
 340     record.ExceptionCode    = EXCEPTION_WINE_STUB;
 341     record.ExceptionFlags   = EH_NONCONTINUABLE;
 342     record.ExceptionRecord  = NULL;
 343     record.ExceptionAddress = __wine_spec_unimplemented_stub;
 344     record.NumberParameters = 2;
 345     record.ExceptionInformation[0] = (ULONG_PTR)module;
 346     record.ExceptionInformation[1] = (ULONG_PTR)function;
 347     for (;;) RtlRaiseException( &record );
 348 }
 349
 350
 351 /*************************************************************
 352  *            IsBadStringPtrA
 353  *
 354  * IsBadStringPtrA replacement for ntdll, to catch exception in debug traces.
 355  */
 356 BOOL WINAPI IsBadStringPtrA( LPCSTR str, UINT_PTR max )
 357 {
 358     if (!str) return TRUE;
 359     __TRY
 360     {
 361         volatile const char *p = str;
 362         while (p != str + max) if (!*p++) break;
 363     }
 364     __EXCEPT_PAGE_FAULT
 365     {
 366         return TRUE;
 367     }
 368     __ENDTRY
 369     return FALSE;
 370 }
 371
 372
 373 /*************************************************************
 374  *            IsBadStringPtrW
 375  *
 376  * IsBadStringPtrW replacement for ntdll, to catch exception in debug traces.
 377  */
 378 BOOL WINAPI IsBadStringPtrW( LPCWSTR str, UINT_PTR max )
 379 {
 380     if (!str) return TRUE;
 381     __TRY
 382     {
 383         volatile const WCHAR *p = str;
 384         while (p != str + max) if (!*p++) break;
 385     }
 386     __EXCEPT_PAGE_FAULT
 387     {
 388         return TRUE;
 389     }
 390     __ENDTRY
 391     return FALSE;
 392 }