?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix guard interrupt protection.
[mono-project.git] / mono / mini / mini-exceptions.c
blobca637adbe5e7be82964c1b41e774a009f3c11527
1 /*
2 * mini-exceptions.c: generic exception support
3 *
4 * Authors:
5 * Dietmar Maurer (dietmar@ximian.com)
6 * Mono Team (mono-list@lists.ximian.com)
7 *
8 * Copyright 2001-2003 Ximian, Inc.
9 * Copyright 2003-2008 Ximian, Inc.
10 */
11
12 #include <config.h>
13 #include <glib.h>
14 #include <signal.h>
15 #include <string.h>
16
17 #ifdef HAVE_EXECINFO_H
18 #include <execinfo.h>
19 #endif
20
21 #ifdef HAVE_SYS_TYPES_H
22 #include <sys/types.h>
23 #endif
24
25 #ifdef HAVE_SYS_WAIT_H
26 #include <sys/wait.h>
27 #endif
28
29 #ifdef HAVE_UNISTD_H
30 #include <unistd.h>
31 #endif
32
33 #ifdef HAVE_SYS_SYSCALL_H
34 #include <sys/syscall.h>
35 #endif
36
37 #include <mono/metadata/appdomain.h>
38 #include <mono/metadata/tabledefs.h>
39 #include <mono/metadata/threads.h>
40 #include <mono/metadata/threads-types.h>
41 #include <mono/metadata/debug-helpers.h>
42 #include <mono/metadata/exception.h>
43 #include <mono/metadata/gc-internal.h>
44 #include <mono/metadata/mono-debug.h>
45 #include <mono/metadata/profiler.h>
46 #include <mono/metadata/mono-endian.h>
47 #include <mono/utils/mono-mmap.h>
48
49 #include "mini.h"
50 #include "debug-mini.h"
51 #include "trace.h"
52 #include "debugger-agent.h"
53
54 #ifndef MONO_ARCH_CONTEXT_DEF
55 #define MONO_ARCH_CONTEXT_DEF
56 #endif
57
58 static gpointer restore_context_func, call_filter_func;
59 static gpointer throw_exception_func, rethrow_exception_func;
60 static gpointer throw_corlib_exception_func;
61
62 static gpointer try_more_restore_tramp = NULL;
63 static gpointer restore_stack_protection_tramp = NULL;
64
65 static void try_more_restore (void);
66 static void restore_stack_protection (void);
67
68 void
69 mono_exceptions_init (void)
70 {
71 if (mono_aot_only) {
72 restore_context_func = mono_aot_get_trampoline ("restore_context");
73 call_filter_func = mono_aot_get_trampoline ("call_filter");
74 throw_exception_func = mono_aot_get_trampoline ("throw_exception");
75 rethrow_exception_func = mono_aot_get_trampoline ("rethrow_exception");
76 } else {
77 MonoTrampInfo *info;
78
79 restore_context_func = mono_arch_get_restore_context (&info, FALSE);
80 if (info) {
81 mono_save_trampoline_xdebug_info (info);
82 mono_tramp_info_free (info);
83 }
84 call_filter_func = mono_arch_get_call_filter (&info, FALSE);
85 if (info) {
86 mono_save_trampoline_xdebug_info (info);
87 mono_tramp_info_free (info);
88 }
89 throw_exception_func = mono_arch_get_throw_exception (&info, FALSE);
90 if (info) {
91 mono_save_trampoline_xdebug_info (info);
92 mono_tramp_info_free (info);
93 }
94 rethrow_exception_func = mono_arch_get_rethrow_exception (&info, FALSE);
95 if (info) {
96 mono_save_trampoline_xdebug_info (info);
97 mono_tramp_info_free (info);
98 }
99 }
100 #ifdef MONO_ARCH_HAVE_RESTORE_STACK_SUPPORT
101 try_more_restore_tramp = mono_create_specific_trampoline (try_more_restore, MONO_TRAMPOLINE_RESTORE_STACK_PROT, mono_domain_get (), NULL);
102 restore_stack_protection_tramp = mono_create_specific_trampoline (restore_stack_protection, MONO_TRAMPOLINE_RESTORE_STACK_PROT, mono_domain_get (), NULL);
103 #endif
104
105 #ifdef MONO_ARCH_HAVE_EXCEPTIONS_INIT
106 mono_arch_exceptions_init ();
107 #endif
108 }
109
110 gpointer
111 mono_get_throw_exception (void)
112 {
113 g_assert (throw_exception_func);
114 return throw_exception_func;
115 }
116
117 gpointer
118 mono_get_rethrow_exception (void)
119 {
120 g_assert (rethrow_exception_func);
121 return rethrow_exception_func;
122 }
123
124 gpointer
125 mono_get_call_filter (void)
126 {
127 g_assert (call_filter_func);
128 return call_filter_func;
129 }
130
131 gpointer
132 mono_get_restore_context (void)
133 {
134 g_assert (restore_context_func);
135 return restore_context_func;
136 }
137
138 gpointer
139 mono_get_throw_corlib_exception (void)
140 {
141 gpointer code = NULL;
142 MonoTrampInfo *info;
143
144 /* This depends on corlib classes so cannot be inited in mono_exceptions_init () */
145 if (throw_corlib_exception_func)
146 return throw_corlib_exception_func;
147
148 if (mono_aot_only)
149 code = mono_aot_get_trampoline ("throw_corlib_exception");
150 else {
151 code = mono_arch_get_throw_corlib_exception (&info, FALSE);
152 if (info) {
153 mono_save_trampoline_xdebug_info (info);
154 mono_tramp_info_free (info);
155 }
156 }
157
158 mono_memory_barrier ();
159
160 throw_corlib_exception_func = code;
161
162 return throw_corlib_exception_func;
163 }
164
165 static gboolean
166 is_address_protected (MonoJitInfo *ji, MonoJitExceptionInfo *ei, gpointer ip)
167 {
168 MonoTryBlockHoleTableJitInfo *table;
169 int i;
170 guint32 offset;
171 guint16 clause;
172
173 if (ei->try_start > ip || ip >= ei->try_end)
174 return FALSE;
175
176 if (!ji->has_try_block_holes)
177 return TRUE;
178
179 table = mono_jit_info_get_try_block_hole_table_info (ji);
180 offset = (guint32)((char*)ip - (char*)ji->code_start);
181 clause = (guint16)(ei - ji->clauses);
182 g_assert (clause < ji->num_clauses);
183
184 for (i = 0; i < table->num_holes; ++i) {
185 MonoTryBlockHoleJitInfo *hole = &table->holes [i];
186 if (hole->clause == clause && hole->offset <= offset && hole->offset + hole->length > offset)
187 return FALSE;
188 }
189 return TRUE;
190 }
191
192 /*
193 * find_jit_info:
194 *
195 * Translate between the mono_arch_find_jit_info function and the old API.
196 */
197 static MonoJitInfo *
198 find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
199 MonoContext *new_ctx, MonoLMF **lmf, gboolean *managed)
200 {
201 StackFrameInfo frame;
202 MonoJitInfo *ji;
203 gboolean err;
204 gpointer ip = MONO_CONTEXT_GET_IP (ctx);
205
206 /* Avoid costly table lookup during stack overflow */
207 if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
208 ji = prev_ji;
209 else
210 ji = mini_jit_info_table_find (domain, ip, NULL);
211
212 if (managed)
213 *managed = FALSE;
214
215 err = mono_arch_find_jit_info (domain, jit_tls, ji, ctx, new_ctx, lmf, NULL, &frame);
216 if (!err)
217 return (gpointer)-1;
218
219 /* Convert between the new and the old APIs */
220 switch (frame.type) {
221 case FRAME_TYPE_MANAGED:
222 if (managed)
223 *managed = TRUE;
224 return frame.ji;
225 case FRAME_TYPE_MANAGED_TO_NATIVE:
226 if (frame.ji)
227 return frame.ji;
228 else {
229 memset (res, 0, sizeof (MonoJitInfo));
230 res->method = frame.method;
231 return res;
232 }
233 case FRAME_TYPE_DEBUGGER_INVOKE: {
234 MonoContext tmp_ctx;
235
236 /*
237 * The normal exception handling code can't handle this frame, so just
238 * skip it.
239 */
240 ji = find_jit_info (domain, jit_tls, res, NULL, new_ctx, &tmp_ctx, lmf, managed);
241 memcpy (new_ctx, &tmp_ctx, sizeof (MonoContext));
242 return ji;
243 }
244 default:
245 g_assert_not_reached ();
246 return NULL;
247 }
248 }
249
250 /* mono_find_jit_info:
251 *
252 * This function is used to gather information from @ctx. It return the
253 * MonoJitInfo of the corresponding function, unwinds one stack frame and
254 * stores the resulting context into @new_ctx. It also stores a string
255 * describing the stack location into @trace (if not NULL), and modifies
256 * the @lmf if necessary. @native_offset return the IP offset from the
257 * start of the function or -1 if that info is not available.
258 */
259 MonoJitInfo *
260 mono_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
261 MonoContext *new_ctx, char **trace, MonoLMF **lmf, int *native_offset,
262 gboolean *managed)
263 {
264 gboolean managed2;
265 gpointer ip = MONO_CONTEXT_GET_IP (ctx);
266 MonoJitInfo *ji;
267
268 if (trace)
269 *trace = NULL;
270
271 if (native_offset)
272 *native_offset = -1;
273
274 if (managed)
275 *managed = FALSE;
276
277 ji = find_jit_info (domain, jit_tls, res, prev_ji, ctx, new_ctx, lmf, &managed2);
278
279 if (ji == (gpointer)-1)
280 return ji;
281
282 if (managed2 || (ji && ji->method->wrapper_type)) {
283 const char *real_ip, *start;
284 gint32 offset;
285
286 start = (const char *)ji->code_start;
287 if (!managed2)
288 /* ctx->ip points into native code */
289 real_ip = (const char*)MONO_CONTEXT_GET_IP (new_ctx);
290 else
291 real_ip = (const char*)ip;
292
293 if ((real_ip >= start) && (real_ip <= start + ji->code_size))
294 offset = real_ip - start;
295 else
296 offset = -1;
297
298 if (native_offset)
299 *native_offset = offset;
300
301 if (managed)
302 if (!ji->method->wrapper_type || ji->method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD)
303 *managed = TRUE;
304
305 if (trace)
306 *trace = mono_debug_print_stack_frame (ji->method, offset, domain);
307 } else {
308 if (trace) {
309 char *fname = mono_method_full_name (res->method, TRUE);
310 *trace = g_strdup_printf ("in (unmanaged) %s", fname);
311 g_free (fname);
312 }
313 }
314
315 return ji;
316 }
317
318 /*
319 * mono_find_jit_info_ext:
320 *
321 * A version of mono_find_jit_info which returns all data in the StackFrameInfo
322 * structure.
323 * A note about frames of type FRAME_TYPE_MANAGED_TO_NATIVE:
324 * - These frames are used to mark managed-to-native transitions, so CTX will refer to native
325 * code, and new_ctx will refer to the last managed frame. The caller should unwind once more
326 * to obtain the last managed frame.
327 * If SAVE_LOCATIONS is not NULL, it should point to an array of size MONO_MAX_IREGS.
328 * On return, it will be filled with the locations where callee saved registers are saved
329 * by the current frame. This is returned outside of StackFrameInfo because it can be
330 * quite large on some platforms.
331 */
332 gboolean
333 mono_find_jit_info_ext (MonoDomain *domain, MonoJitTlsData *jit_tls,
334 MonoJitInfo *prev_ji, MonoContext *ctx,
335 MonoContext *new_ctx, char **trace, MonoLMF **lmf,
336 mgreg_t **save_locations,
337 StackFrameInfo *frame)
338 {
339 gboolean err;
340 gpointer ip = MONO_CONTEXT_GET_IP (ctx);
341 MonoJitInfo *ji;
342 MonoDomain *target_domain;
343
344 if (trace)
345 *trace = NULL;
346
347 /* Avoid costly table lookup during stack overflow */
348 if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
349 ji = prev_ji;
350 else
351 ji = mini_jit_info_table_find (domain, ip, &target_domain);
352
353 if (!target_domain)
354 target_domain = domain;
355
356 if (save_locations)
357 memset (save_locations, 0, MONO_MAX_IREGS * sizeof (mgreg_t*));
358
359 err = mono_arch_find_jit_info (target_domain, jit_tls, ji, ctx, new_ctx, lmf, save_locations, frame);
360 if (!err)
361 return FALSE;
362
363 if (frame->type == FRAME_TYPE_MANAGED_TO_NATIVE) {
364 /*
365 * This type of frame is just a marker, the caller should unwind once more to get the
366 * last managed frame.
367 */
368 frame->ji = NULL;
369 frame->method = NULL;
370 }
371
372 frame->native_offset = -1;
373 frame->domain = target_domain;
374
375 ji = frame->ji;
376
377 if (frame->type == FRAME_TYPE_MANAGED)
378 frame->method = ji->method;
379
380 if (ji && (frame->managed || ji->method->wrapper_type)) {
381 const char *real_ip, *start;
382
383 start = (const char *)ji->code_start;
384 if (!frame->managed)
385 /* ctx->ip points into native code */
386 real_ip = (const char*)MONO_CONTEXT_GET_IP (new_ctx);
387 else
388 real_ip = (const char*)ip;
389
390 if ((real_ip >= start) && (real_ip <= start + ji->code_size))
391 frame->native_offset = real_ip - start;
392 else
393 frame->native_offset = -1;
394
395 if (trace)
396 *trace = mono_debug_print_stack_frame (ji->method, frame->native_offset, domain);
397 } else {
398 if (trace && frame->method) {
399 char *fname = mono_method_full_name (frame->method, TRUE);
400 *trace = g_strdup_printf ("in (unmanaged) %s", fname);
401 g_free (fname);
402 }
403 }
404
405 return TRUE;
406 }
407
408 static gpointer
409 get_generic_info_from_stack_frame (MonoJitInfo *ji, MonoContext *ctx)
410 {
411 MonoGenericJitInfo *gi;
412 gpointer info;
413
414 if (!ji->has_generic_jit_info)
415 return NULL;
416 gi = mono_jit_info_get_generic_jit_info (ji);
417 if (!gi->has_this)
418 return NULL;
419
420 if (gi->this_in_reg)
421 info = mono_arch_context_get_int_reg (ctx, gi->this_reg);
422 else
423 info = *(gpointer*)(gpointer)((char*)mono_arch_context_get_int_reg (ctx, gi->this_reg) +
424 gi->this_offset);
425 if (mono_method_get_context (ji->method)->method_inst) {
426 return info;
427 } else if ((ji->method->flags & METHOD_ATTRIBUTE_STATIC) || ji->method->klass->valuetype) {
428 return info;
429 } else {
430 /* Avoid returning a managed object */
431 MonoObject *this_obj = info;
432
433 return this_obj->vtable->klass;
434 }
435 }
436
437 static MonoGenericContext
438 get_generic_context_from_stack_frame (MonoJitInfo *ji, gpointer generic_info)
439 {
440 MonoGenericContext context = { NULL, NULL };
441 MonoClass *class, *method_container_class;
442
443 g_assert (generic_info);
444
445 g_assert (ji->method->is_inflated);
446 if (mono_method_get_context (ji->method)->method_inst) {
447 MonoMethodRuntimeGenericContext *mrgctx = generic_info;
448
449 class = mrgctx->class_vtable->klass;
450 context.method_inst = mrgctx->method_inst;
451 g_assert (context.method_inst);
452 } else if ((ji->method->flags & METHOD_ATTRIBUTE_STATIC) || ji->method->klass->valuetype) {
453 MonoVTable *vtable = generic_info;
454
455 class = vtable->klass;
456 } else {
457 class = generic_info;
458 }
459
460 //g_assert (!ji->method->klass->generic_container);
461 if (ji->method->klass->generic_class)
462 method_container_class = ji->method->klass->generic_class->container_class;
463 else
464 method_container_class = ji->method->klass;
465
466 /* class might refer to a subclass of ji->method's class */
467 while (!(class == ji->method->klass || (class->generic_class && class->generic_class->container_class == method_container_class))) {
468 class = class->parent;
469 g_assert (class);
470 }
471
472 if (class->generic_class || class->generic_container)
473 context.class_inst = mini_class_get_context (class)->class_inst;
474
475 if (class->generic_class)
476 g_assert (mono_class_has_parent_and_ignore_generics (class->generic_class->container_class, method_container_class));
477 else
478 g_assert (mono_class_has_parent_and_ignore_generics (class, method_container_class));
479
480 return context;
481 }
482
483 static MonoMethod*
484 get_method_from_stack_frame (MonoJitInfo *ji, gpointer generic_info)
485 {
486 MonoGenericContext context;
487 MonoMethod *method;
488
489 if (!ji->has_generic_jit_info || !mono_jit_info_get_generic_jit_info (ji)->has_this)
490 return ji->method;
491 context = get_generic_context_from_stack_frame (ji, generic_info);
492
493 method = mono_method_get_declaring_generic_method (ji->method);
494 method = mono_class_inflate_generic_method (method, &context);
495
496 return method;
497 }
498
499 MonoString *
500 ves_icall_System_Exception_get_trace (MonoException *ex)
501 {
502 MonoDomain *domain = mono_domain_get ();
503 MonoString *res;
504 MonoArray *ta = ex->trace_ips;
505 int i, len;
506 GString *trace_str;
507
508 if (ta == NULL)
509 /* Exception is not thrown yet */
510 return NULL;
511
512 len = mono_array_length (ta) >> 1;
513 trace_str = g_string_new ("");
514 for (i = 0; i < len; i++) {
515 MonoJitInfo *ji;
516 gpointer ip = mono_array_get (ta, gpointer, i * 2 + 0);
517 gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
518
519 ji = mono_jit_info_table_find (domain, ip);
520 if (ji == NULL) {
521 /* Unmanaged frame */
522 g_string_append_printf (trace_str, "in (unmanaged) %p\n", ip);
523 } else {
524 gchar *location;
525 gint32 address;
526 MonoMethod *method = get_method_from_stack_frame (ji, generic_info);
527
528 address = (char *)ip - (char *)ji->code_start;
529 location = mono_debug_print_stack_frame (
530 method, address, ex->object.vtable->domain);
531
532 g_string_append_printf (trace_str, "%s\n", location);
533 g_free (location);
534 }
535 }
536
537 res = mono_string_new (ex->object.vtable->domain, trace_str->str);
538 g_string_free (trace_str, TRUE);
539
540 return res;
541 }
542
543 MonoArray *
544 ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info)
545 {
546 MonoDomain *domain = mono_domain_get ();
547 MonoArray *res;
548 MonoArray *ta = exc->trace_ips;
549 MonoDebugSourceLocation *location;
550 int i, len;
551
552 if (ta == NULL) {
553 /* Exception is not thrown yet */
554 return mono_array_new (domain, mono_defaults.stack_frame_class, 0);
555 }
556
557 len = mono_array_length (ta) >> 1;
558
559 res = mono_array_new (domain, mono_defaults.stack_frame_class, len > skip ? len - skip : 0);
560
561 for (i = skip; i < len; i++) {
562 MonoJitInfo *ji;
563 MonoStackFrame *sf = (MonoStackFrame *)mono_object_new (domain, mono_defaults.stack_frame_class);
564 gpointer ip = mono_array_get (ta, gpointer, i * 2 + 0);
565 gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
566 MonoMethod *method;
567
568 ji = mono_jit_info_table_find (domain, ip);
569 if (ji == NULL) {
570 /* Unmanaged frame */
571 mono_array_setref (res, i, sf);
572 continue;
573 }
574
575 g_assert (ji != NULL);
576
577 method = get_method_from_stack_frame (ji, generic_info);
578 if (ji->method->wrapper_type) {
579 char *s;
580
581 sf->method = NULL;
582 s = mono_method_full_name (method, TRUE);
583 MONO_OBJECT_SETREF (sf, internal_method_name, mono_string_new (domain, s));
584 g_free (s);
585 }
586 else
587 MONO_OBJECT_SETREF (sf, method, mono_method_get_object (domain, method, NULL));
588 sf->native_offset = (char *)ip - (char *)ji->code_start;
589
590 /*
591 * mono_debug_lookup_source_location() returns both the file / line number information
592 * and the IL offset. Note that computing the IL offset is already an expensive
593 * operation, so we shouldn't call this method twice.
594 */
595 location = mono_debug_lookup_source_location (ji->method, sf->native_offset, domain);
596 if (location)
597 sf->il_offset = location->il_offset;
598 else
599 sf->il_offset = 0;
600
601 if (need_file_info) {
602 if (location && location->source_file) {
603 MONO_OBJECT_SETREF (sf, filename, mono_string_new (domain, location->source_file));
604 sf->line = location->row;
605 sf->column = location->column;
606 } else {
607 sf->line = sf->column = 0;
608 sf->filename = NULL;
609 }
610 }
611
612 mono_debug_free_source_location (location);
613 mono_array_setref (res, i, sf);
614 }
615
616 return res;
617 }
618
619 typedef struct {
620 MonoStackWalk func;
621 gpointer user_data;
622 } StackWalkUserData;
623
624 static gboolean
625 stack_walk_adapter (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
626 {
627 StackWalkUserData *d = data;
628
629 switch (frame->type) {
630 case FRAME_TYPE_DEBUGGER_INVOKE:
631 case FRAME_TYPE_MANAGED_TO_NATIVE:
632 return FALSE;
633 case FRAME_TYPE_MANAGED:
634 g_assert (frame->ji);
635 return d->func (frame->ji->method, frame->native_offset, frame->il_offset, frame->managed, d->user_data);
636 break;
637 default:
638 g_assert_not_reached ();
639 return FALSE;
640 }
641 }
642
643 void
644 mono_jit_walk_stack_from_ctx (MonoStackWalk func, MonoContext *start_ctx, gboolean do_il_offset, gpointer user_data)
645 {
646 StackWalkUserData d;
647
648 d.func = func;
649 d.user_data = user_data;
650
651 mono_walk_stack (stack_walk_adapter, mono_domain_get (), start_ctx, do_il_offset, mono_thread_internal_current (), mono_get_lmf (), &d);
652 }
653
654 void
655 mono_jit_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data)
656 {
657 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
658
659 if (jit_tls && jit_tls->orig_ex_ctx_set)
660 mono_jit_walk_stack_from_ctx (func, &jit_tls->orig_ex_ctx, do_il_offset, user_data);
661 else
662 mono_jit_walk_stack_from_ctx (func, NULL, do_il_offset, user_data);
663 }
664
665 /**
666 * mono_walk_stack:
667 * @func: callback to call for each stack frame
668 * @domain: starting appdomain, can be NULL to use the current domain
669 * @do_il_offsets: whenever to compute IL offsets
670 * @start_ctx: starting state of the stack walk, can be NULL.
671 * @thread: the thread whose stack to walk, can be NULL to use the current thread
672 * @lmf: the LMF of @thread, can be NULL to use the LMF of the current thread
673 * @user_data: data passed to the callback
674 *
675 * This function walks the stack of a thread, starting from the state
676 * represented by start_ctx. For each frame the callback
677 * function is called with the relevant info. The walk ends when no more
678 * managed stack frames are found or when the callback returns a TRUE value.
679 */
680 void
681 mono_walk_stack (MonoJitStackWalk func, MonoDomain *domain, MonoContext *start_ctx, gboolean do_il_offset, MonoInternalThread *thread, MonoLMF *lmf, gpointer user_data)
682 {
683 MonoJitTlsData *jit_tls;
684 gint il_offset;
685 MonoContext ctx, new_ctx;
686 StackFrameInfo frame;
687 gboolean res;
688
689 MONO_ARCH_CONTEXT_DEF
690
691 mono_arch_flush_register_windows ();
692
693 if (!thread) {
694 thread = mono_thread_internal_current ();
695 lmf = mono_get_lmf ();
696 }
697
698 /* A NULL thread->jit_data can happen in a small window during thread startup: the thread
699 * allocation happens, we do a stack walk (for example with
700 * --profile=log:nocalls and xsp) but the jit is not fully setup for the thread
701 * yet. Of course there are no stack frames, so just returning is ok.
702 * A NULL thread can happen during domain unload with the same test.
703 */
704 if (!thread || !thread->jit_data)
705 return;
706 jit_tls = thread->jit_data;
707
708 if (start_ctx) {
709 memcpy (&ctx, start_ctx, sizeof (MonoContext));
710 } else {
711 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
712 MONO_INIT_CONTEXT_FROM_CURRENT (&ctx);
713 #else
714 MONO_INIT_CONTEXT_FROM_FUNC (&ctx, mono_jit_walk_stack_from_ctx);
715 #endif
716 g_assert (thread == mono_thread_internal_current ());
717 }
718
719 while (MONO_CONTEXT_GET_SP (&ctx) < jit_tls->end_of_stack) {
720 frame.lmf = lmf;
721 res = mono_find_jit_info_ext (domain, jit_tls, NULL, &ctx, &new_ctx, NULL, &lmf, NULL, &frame);
722 if (!res)
723 return;
724
725 if (do_il_offset && frame.ji) {
726 MonoDebugSourceLocation *source;
727
728 source = mono_debug_lookup_source_location (frame.ji->method, frame.native_offset, domain);
729 il_offset = source ? source->il_offset : -1;
730 mono_debug_free_source_location (source);
731 } else
732 il_offset = -1;
733
734 frame.il_offset = il_offset;
735
736 if (frame.ji) {
737 frame.actual_method = get_method_from_stack_frame (frame.ji, get_generic_info_from_stack_frame (frame.ji, &ctx));
738 } else {
739 frame.actual_method = frame.method;
740 }
741
742 if (func (&frame, &ctx, user_data))
743 return;
744
745 ctx = new_ctx;
746 }
747 }
748
749 MonoBoolean
750 ves_icall_get_frame_info (gint32 skip, MonoBoolean need_file_info,
751 MonoReflectionMethod **method,
752 gint32 *iloffset, gint32 *native_offset,
753 MonoString **file, gint32 *line, gint32 *column)
754 {
755 MonoDomain *domain = mono_domain_get ();
756 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
757 MonoLMF *lmf = mono_get_lmf ();
758 MonoJitInfo *ji = NULL;
759 MonoContext ctx, new_ctx;
760 MonoDebugSourceLocation *location;
761 MonoMethod *actual_method;
762 StackFrameInfo frame;
763 gboolean res;
764
765 MONO_ARCH_CONTEXT_DEF;
766
767 mono_arch_flush_register_windows ();
768
769 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
770 MONO_INIT_CONTEXT_FROM_CURRENT (&ctx);
771 #else
772 MONO_INIT_CONTEXT_FROM_FUNC (&ctx, ves_icall_get_frame_info);
773 #endif
774
775 new_ctx = ctx;
776 do {
777 ctx = new_ctx;
778 res = mono_find_jit_info_ext (domain, jit_tls, NULL, &ctx, &new_ctx, NULL, &lmf, NULL, &frame);
779 if (!res)
780 return FALSE;
781
782 if (frame.type == FRAME_TYPE_MANAGED_TO_NATIVE || frame.type == FRAME_TYPE_DEBUGGER_INVOKE)
783 continue;
784
785 ji = frame.ji;
786 *native_offset = frame.native_offset;
787
788 /* skip all wrappers ??*/
789 if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
790 ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
791 ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH ||
792 ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
793 ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE ||
794 ji->method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED)
795 continue;
796
797 skip--;
798 } while (skip >= 0);
799
800 actual_method = get_method_from_stack_frame (ji, get_generic_info_from_stack_frame (ji, &ctx));
801
802 mono_gc_wbarrier_generic_store (method, (MonoObject*) mono_method_get_object (domain, actual_method, NULL));
803
804 location = mono_debug_lookup_source_location (ji->method, *native_offset, domain);
805 if (location)
806 *iloffset = location->il_offset;
807 else
808 *iloffset = 0;
809
810 if (need_file_info) {
811 if (location) {
812 mono_gc_wbarrier_generic_store (file, (MonoObject*) mono_string_new (domain, location->source_file));
813 *line = location->row;
814 *column = location->column;
815 } else {
816 *file = NULL;
817 *line = *column = 0;
818 }
819 }
820
821 mono_debug_free_source_location (location);
822
823 return TRUE;
824 }
825
826 typedef struct {
827 guint32 skips;
828 MonoSecurityFrame *frame;
829 } MonoFrameSecurityInfo;
830
831 static gboolean
832 callback_get_first_frame_security_info (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
833 {
834 MonoFrameSecurityInfo *si = (MonoFrameSecurityInfo*) data;
835 MonoJitInfo *ji = frame->ji;
836
837 if (!ji)
838 return FALSE;
839
840 /* FIXME: skip all wrappers ?? probably not - case by case testing is required */
841 if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
842 ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
843 ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH ||
844 ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
845 ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE) {
846 return FALSE;
847 }
848
849 if (si->skips > 0) {
850 si->skips--;
851 return FALSE;
852 }
853
854 si->frame = mono_declsec_create_frame (frame->domain, ji);
855
856 /* Stop - we only want the first frame (e.g. LinkDemand and InheritanceDemand) */
857 return TRUE;
858 }
859
860 /**
861 * ves_icall_System_Security_SecurityFrame_GetSecurityFrame:
862 * @skip: the number of stack frames to skip
863 *
864 * This function returns a the security informations of a single stack frame
865 * (after the skipped ones). This is required for [NonCas]LinkDemand[Choice]
866 * and [NonCas]InheritanceDemand[Choice] as only the caller security is
867 * evaluated.
868 */
869 MonoSecurityFrame*
870 ves_icall_System_Security_SecurityFrame_GetSecurityFrame (gint32 skip)
871 {
872 MonoDomain *domain = mono_domain_get ();
873 MonoFrameSecurityInfo si;
874
875 si.skips = skip;
876 si.frame = NULL;
877
878 mono_walk_stack (callback_get_first_frame_security_info, domain, NULL, FALSE, NULL, NULL, &si);
879
880 return (si.skips == 0) ? si.frame : NULL;
881 }
882
883
884 typedef struct {
885 guint32 skips;
886 MonoArray *stack;
887 guint32 count;
888 guint32 maximum;
889 } MonoSecurityStack;
890
891 static void
892 grow_array (MonoSecurityStack *stack)
893 {
894 MonoDomain *domain = mono_domain_get ();
895 guint32 newsize = (stack->maximum << 1);
896 MonoArray *newstack = mono_array_new (domain, mono_defaults.runtimesecurityframe_class, newsize);
897 int i;
898 for (i=0; i < stack->maximum; i++) {
899 gpointer frame = mono_array_get (stack->stack, gpointer, i);
900 mono_array_setref (newstack, i, frame);
901 }
902 stack->maximum = newsize;
903 stack->stack = newstack;
904 }
905
906 static gboolean
907 callback_get_stack_frames_security_info (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
908 {
909 MonoSecurityStack *ss = (MonoSecurityStack*) data;
910 MonoJitInfo *ji = frame->ji;
911
912 if (!ji)
913 return FALSE;
914
915 /* FIXME: skip all wrappers ?? probably not - case by case testing is required */
916 if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
917 ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
918 ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH ||
919 ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
920 ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE) {
921 return FALSE;
922 }
923
924 if (ss->skips > 0) {
925 ss->skips--;
926 return FALSE;
927 }
928
929 if (ss->count == ss->maximum)
930 grow_array (ss);
931
932 mono_array_setref (ss->stack, ss->count++, mono_declsec_create_frame (frame->domain, ji));
933
934 /* continue down the stack */
935 return FALSE;
936 }
937
938 static MonoArray *
939 glist_to_array (GList *list, MonoClass *eclass)
940 {
941 MonoDomain *domain = mono_domain_get ();
942 MonoArray *res;
943 int len, i;
944
945 if (!list)
946 return NULL;
947
948 len = g_list_length (list);
949 res = mono_array_new (domain, eclass, len);
950
951 for (i = 0; list; list = list->next, i++)
952 mono_array_set (res, gpointer, i, list->data);
953
954 return res;
955 }
956
957 /**
958 * ves_icall_System_Security_SecurityFrame_GetSecurityStack:
959 * @skip: the number of stack frames to skip
960 *
961 * This function returns an managed array of containing the security
962 * informations for each frame (after the skipped ones). This is used for
963 * [NonCas]Demand[Choice] where the complete evaluation of the stack is
964 * required.
965 */
966 MonoArray*
967 ves_icall_System_Security_SecurityFrame_GetSecurityStack (gint32 skip)
968 {
969 MonoDomain *domain = mono_domain_get ();
970 MonoSecurityStack ss;
971
972 #if defined(__ia64__) || defined(__s390__) || defined(__s390x__)
973 skip--;
974 #endif
975
976 ss.skips = skip;
977 ss.count = 0;
978 ss.maximum = MONO_CAS_INITIAL_STACK_SIZE;
979 ss.stack = mono_array_new (domain, mono_defaults.runtimesecurityframe_class, ss.maximum);
980 mono_walk_stack (callback_get_stack_frames_security_info, domain, NULL, FALSE, NULL, NULL, &ss);
981 /* g_warning ("STACK RESULT: %d out of %d", ss.count, ss.maximum); */
982 return ss.stack;
983 }
984
985 static MonoClass*
986 get_exception_catch_class (MonoJitExceptionInfo *ei, MonoJitInfo *ji, MonoContext *ctx)
987 {
988 MonoClass *catch_class = ei->data.catch_class;
989 MonoType *inflated_type;
990 MonoGenericContext context;
991
992 /*MonoJitExceptionInfo::data is an union used by filter and finally clauses too.*/
993 if (!catch_class || ei->flags != MONO_EXCEPTION_CLAUSE_NONE)
994 return NULL;
995
996 if (!ji->has_generic_jit_info || !mono_jit_info_get_generic_jit_info (ji)->has_this)
997 return catch_class;
998 context = get_generic_context_from_stack_frame (ji, get_generic_info_from_stack_frame (ji, ctx));
999
1000 /* FIXME: we shouldn't inflate but instead put the
1001 type in the rgctx and fetch it from there. It
1002 might be a good idea to do this lazily, i.e. only
1003 when the exception is actually thrown, so as not to
1004 waste space for exception clauses which might never
1005 be encountered. */
1006 inflated_type = mono_class_inflate_generic_type (&catch_class->byval_arg, &context);
1007 catch_class = mono_class_from_mono_type (inflated_type);
1008 mono_metadata_free_type (inflated_type);
1009
1010 return catch_class;
1011 }
1012
1013 /*
1014 * mini_jit_info_table_find:
1015 *
1016 * Same as mono_jit_info_table_find, but search all the domains of the current thread
1017 * if ADDR is not found in DOMAIN. The domain where the method was found is stored into
1018 * OUT_DOMAIN if it is not NULL.
1019 */
1020 MonoJitInfo*
1021 mini_jit_info_table_find (MonoDomain *domain, char *addr, MonoDomain **out_domain)
1022 {
1023 MonoJitInfo *ji;
1024 MonoInternalThread *t = mono_thread_internal_current ();
1025 GSList *l;
1026
1027 if (out_domain)
1028 *out_domain = NULL;
1029
1030 ji = mono_jit_info_table_find (domain, addr);
1031 if (ji) {
1032 if (out_domain)
1033 *out_domain = domain;
1034 return ji;
1035 }
1036
1037 /* maybe it is shared code, so we also search in the root domain */
1038 if (domain != mono_get_root_domain ()) {
1039 ji = mono_jit_info_table_find (mono_get_root_domain (), addr);
1040 if (ji) {
1041 if (out_domain)
1042 *out_domain = mono_get_root_domain ();
1043 return ji;
1044 }
1045 }
1046
1047 for (l = t->appdomain_refs; l; l = l->next) {
1048 if (l->data != domain) {
1049 ji = mono_jit_info_table_find ((MonoDomain*)l->data, addr);
1050 if (ji) {
1051 if (out_domain)
1052 *out_domain = (MonoDomain*)l->data;
1053 return ji;
1054 }
1055 }
1056 }
1057
1058 return NULL;
1059 }
1060
1061 /*
1062 * wrap_non_exception_throws:
1063 *
1064 * Determine whenever M's assembly has a RuntimeCompatibilityAttribute with the
1065 * WrapNonExceptionThrows flag set.
1066 */
1067 static gboolean
1068 wrap_non_exception_throws (MonoMethod *m)
1069 {
1070 MonoAssembly *ass = m->klass->image->assembly;
1071 MonoCustomAttrInfo* attrs;
1072 static MonoClass *klass;
1073 int i;
1074 gboolean val = FALSE;
1075
1076 g_assert (ass);
1077 if (ass->wrap_non_exception_throws_inited)
1078 return ass->wrap_non_exception_throws;
1079
1080 klass = mono_class_from_name_cached (mono_defaults.corlib, "System.Runtime.CompilerServices", "RuntimeCompatibilityAttribute");
1081
1082 attrs = mono_custom_attrs_from_assembly (ass);
1083 if (attrs) {
1084 for (i = 0; i < attrs->num_attrs; ++i) {
1085 MonoCustomAttrEntry *attr = &attrs->attrs [i];
1086 const gchar *p;
1087 int len, num_named, named_type, data_type, name_len;
1088 char *name;
1089
1090 if (!attr->ctor || attr->ctor->klass != klass)
1091 continue;
1092 /* Decode the RuntimeCompatibilityAttribute. See reflection.c */
1093 len = attr->data_size;
1094 p = (const char*)attr->data;
1095 g_assert (read16 (p) == 0x0001);
1096 p += 2;
1097 num_named = read16 (p);
1098 if (num_named != 1)
1099 continue;
1100 p += 2;
1101 named_type = *p;
1102 p ++;
1103 data_type = *p;
1104 p ++;
1105 /* Property */
1106 if (named_type != 0x54)
1107 continue;
1108 name_len = mono_metadata_decode_blob_size (p, &p);
1109 name = g_malloc (name_len + 1);
1110 memcpy (name, p, name_len);
1111 name [name_len] = 0;
1112 p += name_len;
1113 g_assert (!strcmp (name, "WrapNonExceptionThrows"));
1114 g_free (name);
1115 /* The value is a BOOLEAN */
1116 val = *p;
1117 }
1118 mono_custom_attrs_free (attrs);
1119 }
1120
1121 ass->wrap_non_exception_throws = val;
1122 mono_memory_barrier ();
1123 ass->wrap_non_exception_throws_inited = TRUE;
1124
1125 return val;
1126 }
1127
1128 #ifndef MONO_ARCH_STACK_GROWS_UP
1129 #define DOES_STACK_GROWS_UP 1
1130 #else
1131 #define DOES_STACK_GROWS_UP 0
1132 #endif
1133
1134 /*
1135 * mono_handle_exception_internal_first_pass:
1136 *
1137 * The first pass of exception handling. Unwind the stack until a catch clause which can catch
1138 * OBJ is found. Run the index of the filter clause which caught the exception into
1139 * OUT_FILTER_IDX. Return TRUE if the exception is caught, FALSE otherwise.
1140 */
1141 static gboolean
1142 mono_handle_exception_internal_first_pass (MonoContext *ctx, gpointer obj, gpointer original_ip, gint32 *out_filter_idx, MonoJitInfo **out_ji, MonoObject *non_exception)
1143 {
1144 MonoDomain *domain = mono_domain_get ();
1145 MonoJitInfo *ji;
1146 static int (*call_filter) (MonoContext *, gpointer) = NULL;
1147 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1148 MonoLMF *lmf = mono_get_lmf ();
1149 MonoArray *initial_trace_ips = NULL;
1150 GList *trace_ips = NULL;
1151 MonoException *mono_ex;
1152 gboolean stack_overflow = FALSE;
1153 MonoContext initial_ctx;
1154 int frame_count = 0;
1155 gboolean has_dynamic_methods = FALSE;
1156 gint32 filter_idx;
1157 int i;
1158 MonoObject *ex_obj;
1159
1160 g_assert (ctx != NULL);
1161
1162 if (obj == domain->stack_overflow_ex)
1163 stack_overflow = TRUE;
1164
1165 mono_ex = (MonoException*)obj;
1166 initial_trace_ips = mono_ex->trace_ips;
1167
1168 if (mono_object_isinst (obj, mono_defaults.exception_class)) {
1169 mono_ex = (MonoException*)obj;
1170 initial_trace_ips = mono_ex->trace_ips;
1171 } else {
1172 mono_ex = NULL;
1173 }
1174
1175 if (!call_filter)
1176 call_filter = mono_get_call_filter ();
1177
1178 g_assert (jit_tls->end_of_stack);
1179 g_assert (jit_tls->abort_func);
1180
1181 if (out_filter_idx)
1182 *out_filter_idx = -1;
1183 if (out_ji)
1184 *out_ji = NULL;
1185 filter_idx = 0;
1186 initial_ctx = *ctx;
1187
1188 while (1) {
1189 MonoContext new_ctx;
1190 guint32 free_stack;
1191 int clause_index_start = 0;
1192 gboolean unwind_res = TRUE;
1193
1194 StackFrameInfo frame;
1195
1196 unwind_res = mono_find_jit_info_ext (domain, jit_tls, NULL, ctx, &new_ctx, NULL, &lmf, NULL, &frame);
1197 if (unwind_res) {
1198 if (frame.type == FRAME_TYPE_DEBUGGER_INVOKE || frame.type == FRAME_TYPE_MANAGED_TO_NATIVE) {
1199 *ctx = new_ctx;
1200 continue;
1201 }
1202 g_assert (frame.type == FRAME_TYPE_MANAGED);
1203 ji = frame.ji;
1204 }
1205
1206 if (!unwind_res) {
1207 if (mono_ex && !initial_trace_ips) {
1208 trace_ips = g_list_reverse (trace_ips);
1209 MONO_OBJECT_SETREF (mono_ex, trace_ips, glist_to_array (trace_ips, mono_defaults.int_class));
1210 if (has_dynamic_methods)
1211 /* These methods could go away anytime, so compute the stack trace now */
1212 MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
1213 }
1214 g_list_free (trace_ips);
1215 return FALSE;
1216 }
1217
1218 frame_count ++;
1219 //printf ("M: %s %d.\n", mono_method_full_name (ji->method, TRUE), frame_count);
1220
1221 if (mini_get_debug_options ()->reverse_pinvoke_exceptions && ji->method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) {
1222 g_error ("A native frame was found while unwinding the stack after an exception.\n"
1223 "The native frame called the managed method:\n%s\n",
1224 mono_method_full_name (ji->method, TRUE));
1225 }
1226
1227 if (ji->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE && mono_ex) {
1228 /*
1229 * Avoid overwriting the stack trace if the exception is
1230 * rethrown. Also avoid giant stack traces during a stack
1231 * overflow.
1232 */
1233 if (!initial_trace_ips && (frame_count < 1000)) {
1234 trace_ips = g_list_prepend (trace_ips, MONO_CONTEXT_GET_IP (ctx));
1235 trace_ips = g_list_prepend (trace_ips,
1236 get_generic_info_from_stack_frame (ji, ctx));
1237 }
1238 }
1239
1240 if (ji->method->dynamic)
1241 has_dynamic_methods = TRUE;
1242
1243 if (stack_overflow) {
1244 if (DOES_STACK_GROWS_UP)
1245 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx));
1246 else
1247 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (ctx));
1248 } else {
1249 free_stack = 0xffffff;
1250 }
1251
1252 for (i = clause_index_start; i < ji->num_clauses; i++) {
1253 MonoJitExceptionInfo *ei = &ji->clauses [i];
1254 gboolean filtered = FALSE;
1255
1256 /*
1257 * During stack overflow, wait till the unwinding frees some stack
1258 * space before running handlers/finalizers.
1259 */
1260 if (free_stack <= (64 * 1024))
1261 continue;
1262
1263 if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx))) {
1264 /* catch block */
1265 MonoClass *catch_class = get_exception_catch_class (ei, ji, ctx);
1266
1267 /*
1268 * Have to unwrap RuntimeWrappedExceptions if the
1269 * method's assembly doesn't have a RuntimeCompatibilityAttribute.
1270 */
1271 if (non_exception && !wrap_non_exception_throws (ji->method))
1272 ex_obj = non_exception;
1273 else
1274 ex_obj = obj;
1275
1276 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
1277 mono_perfcounters->exceptions_filters++;
1278 mono_debugger_call_exception_handler (ei->data.filter, MONO_CONTEXT_GET_SP (ctx), ex_obj);
1279 if (mono_ex && !initial_trace_ips) {
1280 trace_ips = g_list_reverse (trace_ips);
1281 MONO_OBJECT_SETREF (mono_ex, trace_ips, glist_to_array (trace_ips, mono_defaults.int_class));
1282
1283 if (has_dynamic_methods)
1284 /* These methods could go away anytime, so compute the stack trace now */
1285 MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
1286 }
1287 g_list_free (trace_ips);
1288 trace_ips = NULL;
1289
1290 if (ji->from_llvm) {
1291 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
1292 MONO_CONTEXT_SET_LLVM_EXC_REG (ctx, ex_obj);
1293 #else
1294 g_assert_not_reached ();
1295 #endif
1296 } else {
1297 /* store the exception object in bp + ei->exvar_offset */
1298 *((gpointer *)(gpointer)((char *)MONO_CONTEXT_GET_BP (ctx) + ei->exvar_offset)) = ex_obj;
1299 }
1300
1301 mono_debugger_agent_begin_exception_filter (mono_ex, ctx, &initial_ctx);
1302 filtered = call_filter (ctx, ei->data.filter);
1303 mono_debugger_agent_end_exception_filter (mono_ex, ctx, &initial_ctx);
1304 if (filtered && out_filter_idx)
1305 *out_filter_idx = filter_idx;
1306 if (out_ji)
1307 *out_ji = ji;
1308 filter_idx ++;
1309
1310 if (filtered) {
1311 /* mono_debugger_agent_handle_exception () needs this */
1312 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1313 return TRUE;
1314 }
1315 }
1316
1317 if (ei->flags == MONO_EXCEPTION_CLAUSE_NONE && mono_object_isinst (ex_obj, catch_class)) {
1318 if (mono_ex && !initial_trace_ips) {
1319 trace_ips = g_list_reverse (trace_ips);
1320 MONO_OBJECT_SETREF (mono_ex, trace_ips, glist_to_array (trace_ips, mono_defaults.int_class));
1321 if (has_dynamic_methods)
1322 /* These methods could go away anytime, so compute the stack trace now */
1323 MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
1324 }
1325 g_list_free (trace_ips);
1326
1327 /* mono_debugger_agent_handle_exception () needs this */
1328 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1329 return TRUE;
1330 }
1331 }
1332 }
1333
1334 *ctx = new_ctx;
1335 }
1336
1337 g_assert_not_reached ();
1338 }
1339
1340 /**
1341 * mono_handle_exception_internal:
1342 * @ctx: saved processor state
1343 * @obj: the exception object
1344 * @resume: whenever to resume unwinding based on the state in MonoJitTlsData.
1345 */
1346 static gboolean
1347 mono_handle_exception_internal (MonoContext *ctx, gpointer obj, gpointer original_ip, gboolean resume, MonoJitInfo **out_ji)
1348 {
1349 MonoDomain *domain = mono_domain_get ();
1350 MonoJitInfo *ji;
1351 static int (*call_filter) (MonoContext *, gpointer) = NULL;
1352 static void (*restore_context) (void *);
1353 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1354 MonoLMF *lmf = mono_get_lmf ();
1355 MonoException *mono_ex;
1356 gboolean stack_overflow = FALSE;
1357 MonoContext initial_ctx;
1358 int frame_count = 0;
1359 gint32 filter_idx, first_filter_idx;
1360 int i;
1361 MonoObject *ex_obj;
1362 MonoObject *non_exception = NULL;
1363
1364 g_assert (ctx != NULL);
1365 if (!obj) {
1366 MonoException *ex = mono_get_exception_null_reference ();
1367 MONO_OBJECT_SETREF (ex, message, mono_string_new (domain, "Object reference not set to an instance of an object"));
1368 obj = (MonoObject *)ex;
1369 }
1370
1371 /*
1372 * Allocate a new exception object instead of the preconstructed ones.
1373 */
1374 if (obj == domain->stack_overflow_ex) {
1375 /*
1376 * It is not a good idea to try and put even more pressure on the little stack available.
1377 * obj = mono_get_exception_stack_overflow ();
1378 */
1379 stack_overflow = TRUE;
1380 }
1381 else if (obj == domain->null_reference_ex) {
1382 obj = mono_get_exception_null_reference ();
1383 }
1384
1385 if (!mono_object_isinst (obj, mono_defaults.exception_class)) {
1386 non_exception = obj;
1387 obj = mono_get_exception_runtime_wrapped (obj);
1388 }
1389
1390 mono_ex = (MonoException*)obj;
1391
1392 if (mono_object_isinst (obj, mono_defaults.exception_class)) {
1393 mono_ex = (MonoException*)obj;
1394 } else {
1395 mono_ex = NULL;
1396 }
1397
1398 if (mono_ex && jit_tls->class_cast_from) {
1399 if (!strcmp (mono_ex->object.vtable->klass->name, "InvalidCastException")) {
1400 char *from_name = mono_type_get_full_name (jit_tls->class_cast_from);
1401 char *to_name = mono_type_get_full_name (jit_tls->class_cast_to);
1402 char *msg = g_strdup_printf ("Unable to cast object of type '%s' to type '%s'.", from_name, to_name);
1403 mono_ex->message = mono_string_new (domain, msg);
1404 g_free (from_name);
1405 g_free (to_name);
1406 g_free (msg);
1407 }
1408 if (!strcmp (mono_ex->object.vtable->klass->name, "ArrayTypeMismatchException")) {
1409 char *from_name = mono_type_get_full_name (jit_tls->class_cast_from);
1410 char *to_name = mono_type_get_full_name (jit_tls->class_cast_to);
1411 char *msg = g_strdup_printf ("Source array of type '%s' cannot be cast to destination array type '%s'.", from_name, to_name);
1412 mono_ex->message = mono_string_new (domain, msg);
1413 g_free (from_name);
1414 g_free (to_name);
1415 g_free (msg);
1416 }
1417 }
1418
1419 if (!call_filter)
1420 call_filter = mono_get_call_filter ();
1421
1422 if (!restore_context)
1423 restore_context = mono_get_restore_context ();
1424
1425 g_assert (jit_tls->end_of_stack);
1426 g_assert (jit_tls->abort_func);
1427
1428 /*
1429 * We set orig_ex_ctx_set to TRUE/FALSE around profiler calls to make sure it doesn't
1430 * end up being TRUE on any code path.
1431 */
1432 memcpy (&jit_tls->orig_ex_ctx, ctx, sizeof (MonoContext));
1433
1434 if (!resume) {
1435 gboolean res;
1436
1437 MonoContext ctx_cp = *ctx;
1438 if (mono_trace_is_enabled ()) {
1439 MonoMethod *system_exception_get_message = mono_class_get_method_from_name (mono_defaults.exception_class, "get_Message", 0);
1440 MonoMethod *get_message = system_exception_get_message == NULL ? NULL : mono_object_get_virtual_method (obj, system_exception_get_message);
1441 MonoObject *message;
1442 const char *type_name = mono_class_get_name (mono_object_class (mono_ex));
1443 char *msg = NULL;
1444 MonoObject *exc = NULL;
1445 if (get_message == NULL) {
1446 message = NULL;
1447 } else if (!strcmp (type_name, "OutOfMemoryException") || !strcmp (type_name, "StackOverflowException")) {
1448 message = NULL;
1449 msg = g_strdup_printf ("(No exception message for: %s)\n", type_name);
1450 } else {
1451 message = mono_runtime_invoke (get_message, obj, NULL, &exc);
1452
1453 }
1454 if (msg == NULL) {
1455 msg = message ? mono_string_to_utf8 ((MonoString *) message) : g_strdup ("(System.Exception.Message property not available)");
1456 }
1457 g_print ("[%p:] EXCEPTION handling: %s.%s: %s\n", (void*)GetCurrentThreadId (), mono_object_class (obj)->name_space, mono_object_class (obj)->name, msg);
1458 g_free (msg);
1459 if (mono_ex && mono_trace_eval_exception (mono_object_class (mono_ex)))
1460 mono_print_thread_dump_from_ctx (ctx);
1461 }
1462 jit_tls->orig_ex_ctx_set = TRUE;
1463 mono_profiler_exception_thrown (obj);
1464 jit_tls->orig_ex_ctx_set = FALSE;
1465
1466 res = mono_handle_exception_internal_first_pass (&ctx_cp, obj, original_ip, &first_filter_idx, out_ji, non_exception);
1467
1468 if (!res) {
1469 if (mono_break_on_exc)
1470 G_BREAKPOINT ();
1471 mono_debugger_agent_handle_exception (obj, ctx, NULL);
1472 // FIXME: This runs managed code so it might cause another stack overflow when
1473 // we are handling a stack overflow
1474 mono_unhandled_exception (obj);
1475 } else {
1476 mono_debugger_agent_handle_exception (obj, ctx, &ctx_cp);
1477 }
1478 }
1479
1480 if (out_ji)
1481 *out_ji = NULL;
1482 filter_idx = 0;
1483 initial_ctx = *ctx;
1484
1485 while (1) {
1486 MonoContext new_ctx;
1487 guint32 free_stack;
1488 int clause_index_start = 0;
1489 gboolean unwind_res = TRUE;
1490
1491 if (resume) {
1492 resume = FALSE;
1493 ji = jit_tls->resume_state.ji;
1494 new_ctx = jit_tls->resume_state.new_ctx;
1495 clause_index_start = jit_tls->resume_state.clause_index;
1496 lmf = jit_tls->resume_state.lmf;
1497 first_filter_idx = jit_tls->resume_state.first_filter_idx;
1498 filter_idx = jit_tls->resume_state.filter_idx;
1499 } else {
1500 StackFrameInfo frame;
1501
1502 unwind_res = mono_find_jit_info_ext (domain, jit_tls, NULL, ctx, &new_ctx, NULL, &lmf, NULL, &frame);
1503 if (unwind_res) {
1504 if (frame.type == FRAME_TYPE_DEBUGGER_INVOKE || frame.type == FRAME_TYPE_MANAGED_TO_NATIVE) {
1505 *ctx = new_ctx;
1506 continue;
1507 }
1508 g_assert (frame.type == FRAME_TYPE_MANAGED);
1509 ji = frame.ji;
1510 }
1511 }
1512
1513 if (!unwind_res) {
1514 *(mono_get_lmf_addr ()) = lmf;
1515
1516 jit_tls->abort_func (obj);
1517 g_assert_not_reached ();
1518 }
1519
1520 frame_count ++;
1521 //printf ("M: %s %d.\n", mono_method_full_name (ji->method, TRUE), frame_count);
1522
1523 if (stack_overflow) {
1524 if (DOES_STACK_GROWS_UP)
1525 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx));
1526 else
1527 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (ctx));
1528 } else {
1529 free_stack = 0xffffff;
1530 }
1531
1532 for (i = clause_index_start; i < ji->num_clauses; i++) {
1533 MonoJitExceptionInfo *ei = &ji->clauses [i];
1534 gboolean filtered = FALSE;
1535
1536 /*
1537 * During stack overflow, wait till the unwinding frees some stack
1538 * space before running handlers/finalizers.
1539 */
1540 if (free_stack <= (64 * 1024))
1541 continue;
1542
1543 if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx))) {
1544 /* catch block */
1545 MonoClass *catch_class = get_exception_catch_class (ei, ji, ctx);
1546
1547 /*
1548 * Have to unwrap RuntimeWrappedExceptions if the
1549 * method's assembly doesn't have a RuntimeCompatibilityAttribute.
1550 */
1551 if (non_exception && !wrap_non_exception_throws (ji->method))
1552 ex_obj = non_exception;
1553 else
1554 ex_obj = obj;
1555
1556 if (((ei->flags == MONO_EXCEPTION_CLAUSE_NONE) || (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER))) {
1557 if (ji->from_llvm) {
1558 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
1559 MONO_CONTEXT_SET_LLVM_EXC_REG (ctx, ex_obj);
1560 #else
1561 g_assert_not_reached ();
1562 #endif
1563 } else {
1564 /* store the exception object in bp + ei->exvar_offset */
1565 *((gpointer *)(gpointer)((char *)MONO_CONTEXT_GET_BP (ctx) + ei->exvar_offset)) = ex_obj;
1566 }
1567 }
1568
1569 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
1570 /*
1571 * Filter clauses should only be run in the
1572 * first pass of exception handling.
1573 */
1574 filtered = (filter_idx == first_filter_idx);
1575 filter_idx ++;
1576 }
1577
1578 if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE &&
1579 mono_object_isinst (ex_obj, catch_class)) || filtered) {
1580 /*
1581 * This guards against the situation that we abort a thread that is executing a finally clause
1582 * that was called by the EH machinery. It won't have a guard trampoline installed, so we must
1583 * check for this situation here and resume interruption if we are below the guarded block.
1584 */
1585 if (G_UNLIKELY (jit_tls->handler_block_return_address)) {
1586 gboolean is_outside = FALSE;
1587 gpointer prot_bp = MONO_CONTEXT_GET_BP (&jit_tls->handler_block_context);
1588 gpointer catch_bp = MONO_CONTEXT_GET_BP (ctx);
1589 //FIXME make this stack direction aware
1590 if (catch_bp > prot_bp) {
1591 is_outside = TRUE;
1592 } else if (catch_bp == prot_bp) {
1593 /* Can be either try { try { } catch {} } finally {} or try { try { } finally {} } catch {}
1594 * So we check if the catch handler_start is protected by the guarded handler protected region
1595 *
1596 * Assumptions:
1597 * If there is an outstanding guarded_block return address, it means the current thread must be aborted.
1598 * This is the only way to reach out the guarded block as other cases are handled by the trampoline.
1599 * There aren't any further finally/fault handler blocks down the stack over this exception.
1600 * This must be ensured by the code that installs the guard trampoline.
1601 */
1602 g_assert (ji == mini_jit_info_table_find (domain, MONO_CONTEXT_GET_IP (&jit_tls->handler_block_context), NULL));
1603
1604 if (!is_address_protected (ji, jit_tls->handler_block, ei->handler_start)) {
1605 is_outside = TRUE;
1606 }
1607 }
1608 if (is_outside) {
1609 jit_tls->handler_block_return_address = NULL;
1610 jit_tls->handler_block = NULL;
1611 mono_thread_resume_interruption (); /*We ignore the exception here, it will be raised later*/
1612 }
1613 }
1614
1615 if (mono_trace_is_enabled () && mono_trace_eval (ji->method))
1616 g_print ("EXCEPTION: catch found at clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
1617 jit_tls->orig_ex_ctx_set = TRUE;
1618 mono_profiler_exception_clause_handler (ji->method, ei->flags, i);
1619 jit_tls->orig_ex_ctx_set = FALSE;
1620 mono_debugger_call_exception_handler (ei->handler_start, MONO_CONTEXT_GET_SP (ctx), ex_obj);
1621 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1622 *(mono_get_lmf_addr ()) = lmf;
1623 mono_perfcounters->exceptions_depth += frame_count;
1624 if (obj == domain->stack_overflow_ex)
1625 jit_tls->handling_stack_ovf = FALSE;
1626
1627 return 0;
1628 }
1629 if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx)) &&
1630 (ei->flags == MONO_EXCEPTION_CLAUSE_FAULT)) {
1631 if (mono_trace_is_enabled () && mono_trace_eval (ji->method))
1632 g_print ("EXCEPTION: fault clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
1633 jit_tls->orig_ex_ctx_set = TRUE;
1634 mono_profiler_exception_clause_handler (ji->method, ei->flags, i);
1635 jit_tls->orig_ex_ctx_set = FALSE;
1636 mono_debugger_call_exception_handler (ei->handler_start, MONO_CONTEXT_GET_SP (ctx), ex_obj);
1637 call_filter (ctx, ei->handler_start);
1638 }
1639 if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx)) &&
1640 (ei->flags == MONO_EXCEPTION_CLAUSE_FINALLY)) {
1641 if (mono_trace_is_enabled () && mono_trace_eval (ji->method))
1642 g_print ("EXCEPTION: finally clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
1643 jit_tls->orig_ex_ctx_set = TRUE;
1644 mono_profiler_exception_clause_handler (ji->method, ei->flags, i);
1645 jit_tls->orig_ex_ctx_set = FALSE;
1646 mono_debugger_call_exception_handler (ei->handler_start, MONO_CONTEXT_GET_SP (ctx), ex_obj);
1647 mono_perfcounters->exceptions_finallys++;
1648 *(mono_get_lmf_addr ()) = lmf;
1649 if (ji->from_llvm) {
1650 /*
1651 * LLVM compiled finally handlers follow the design
1652 * of the c++ ehabi, i.e. they call a resume function
1653 * at the end instead of returning to the caller.
1654 * So save the exception handling state,
1655 * mono_resume_unwind () will call us again to continue
1656 * the unwinding.
1657 */
1658 jit_tls->resume_state.ex_obj = obj;
1659 jit_tls->resume_state.ji = ji;
1660 jit_tls->resume_state.clause_index = i + 1;
1661 jit_tls->resume_state.ctx = *ctx;
1662 jit_tls->resume_state.new_ctx = new_ctx;
1663 jit_tls->resume_state.lmf = lmf;
1664 jit_tls->resume_state.first_filter_idx = first_filter_idx;
1665 jit_tls->resume_state.filter_idx = filter_idx;
1666 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1667 return 0;
1668 } else {
1669 call_filter (ctx, ei->handler_start);
1670 }
1671 }
1672 }
1673 }
1674
1675 jit_tls->orig_ex_ctx_set = TRUE;
1676 mono_profiler_exception_method_leave (ji->method);
1677 jit_tls->orig_ex_ctx_set = FALSE;
1678
1679 *ctx = new_ctx;
1680 }
1681
1682 g_assert_not_reached ();
1683 }
1684
1685 /*
1686 * mono_debugger_handle_exception:
1687 *
1688 * Notify the debugger about exceptions. Returns TRUE if the debugger wants us to stop
1689 * at the exception and FALSE to resume with the normal exception handling.
1690 *
1691 * The arch code is responsible to setup @ctx in a way that MONO_CONTEXT_GET_IP () and
1692 * MONO_CONTEXT_GET_SP () point to the throw instruction; ie. before executing the
1693 * `callq throw' instruction.
1694 */
1695 gboolean
1696 mono_debugger_handle_exception (MonoContext *ctx, MonoObject *obj)
1697 {
1698 MonoDebuggerExceptionAction action;
1699
1700 if (!mono_debug_using_mono_debugger ())
1701 return FALSE;
1702
1703 if (!obj) {
1704 MonoException *ex = mono_get_exception_null_reference ();
1705 MONO_OBJECT_SETREF (ex, message, mono_string_new (mono_domain_get (), "Object reference not set to an instance of an object"));
1706 obj = (MonoObject *)ex;
1707 }
1708
1709 action = _mono_debugger_throw_exception (MONO_CONTEXT_GET_IP (ctx), MONO_CONTEXT_GET_SP (ctx), obj);
1710
1711 if (action == MONO_DEBUGGER_EXCEPTION_ACTION_STOP) {
1712 /*
1713 * The debugger wants us to stop on the `throw' instruction.
1714 * By the time we get here, it already inserted a breakpoint there.
1715 */
1716 return TRUE;
1717 } else if (action == MONO_DEBUGGER_EXCEPTION_ACTION_STOP_UNHANDLED) {
1718 MonoContext ctx_cp = *ctx;
1719 MonoJitInfo *ji = NULL;
1720 gboolean ret;
1721
1722 /*
1723 * The debugger wants us to stop only if this exception is user-unhandled.
1724 */
1725
1726 ret = mono_handle_exception_internal_first_pass (&ctx_cp, obj, MONO_CONTEXT_GET_IP (ctx), NULL, &ji, NULL);
1727 if (ret && (ji != NULL) && (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE)) {
1728 /*
1729 * The exception is handled in a runtime-invoke wrapper, that means that it's unhandled
1730 * inside the method being invoked, so we handle it like a user-unhandled exception.
1731 */
1732 ret = FALSE;
1733 }
1734
1735 if (!ret) {
1736 /*
1737 * The exception is user-unhandled - tell the debugger to stop.
1738 */
1739 return _mono_debugger_unhandled_exception (MONO_CONTEXT_GET_IP (ctx), MONO_CONTEXT_GET_SP (ctx), obj);
1740 }
1741
1742 /*
1743 * The exception is catched somewhere - resume with the normal exception handling and don't
1744 * stop in the debugger.
1745 */
1746 }
1747
1748 return FALSE;
1749 }
1750
1751 /**
1752 * mono_debugger_run_finally:
1753 * @start_ctx: saved processor state
1754 *
1755 * This method is called by the Mono Debugger to call all `finally' clauses of the
1756 * current stack frame. It's used when the user issues a `return' command to make
1757 * the current stack frame return. After returning from this method, the debugger
1758 * unwinds the stack one frame and gives control back to the user.
1759 *
1760 * NOTE: This method is only used when running inside the Mono Debugger.
1761 */
1762 void
1763 mono_debugger_run_finally (MonoContext *start_ctx)
1764 {
1765 static int (*call_filter) (MonoContext *, gpointer) = NULL;
1766 MonoDomain *domain = mono_domain_get ();
1767 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1768 MonoLMF *lmf = mono_get_lmf ();
1769 MonoContext ctx, new_ctx;
1770 MonoJitInfo *ji, rji;
1771 int i;
1772
1773 ctx = *start_ctx;
1774
1775 ji = mono_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, NULL, NULL);
1776 if (!ji || ji == (gpointer)-1)
1777 return;
1778
1779 if (!call_filter)
1780 call_filter = mono_get_call_filter ();
1781
1782 for (i = 0; i < ji->num_clauses; i++) {
1783 MonoJitExceptionInfo *ei = &ji->clauses [i];
1784
1785 if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (&ctx)) &&
1786 (ei->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
1787 call_filter (&ctx, ei->handler_start);
1788 }
1789 }
1790 }
1791
1792 /**
1793 * mono_handle_exception:
1794 * @ctx: saved processor state
1795 * @obj: the exception object
1796 * @test_only: only test if the exception is caught, but dont call handlers
1797 */
1798 gboolean
1799 mono_handle_exception (MonoContext *ctx, gpointer obj, gpointer original_ip, gboolean test_only)
1800 {
1801 if (!test_only)
1802 mono_perfcounters->exceptions_thrown++;
1803
1804 g_assert (!test_only);
1805 return mono_handle_exception_internal (ctx, obj, original_ip, FALSE, NULL);
1806 }
1807
1808 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
1809
1810 #ifndef MONO_ARCH_USE_SIGACTION
1811 #error "Can't use sigaltstack without sigaction"
1812 #endif
1813
1814 #define ALIGN_TO(val,align) ((((guint64)val) + ((align) - 1)) & ~((align) - 1))
1815
1816 void
1817 mono_setup_altstack (MonoJitTlsData *tls)
1818 {
1819 size_t stsize = 0;
1820 struct sigaltstack sa;
1821 guint8 *staddr = NULL;
1822
1823 if (mono_running_on_valgrind ())
1824 return;
1825
1826 mono_thread_get_stack_bounds (&staddr, &stsize);
1827
1828 g_assert (staddr);
1829
1830 tls->end_of_stack = staddr + stsize;
1831 tls->stack_size = stsize;
1832
1833 /*g_print ("thread %p, stack_base: %p, stack_size: %d\n", (gpointer)pthread_self (), staddr, stsize);*/
1834
1835 tls->stack_ovf_guard_base = staddr + mono_pagesize ();
1836 tls->stack_ovf_guard_size = ALIGN_TO (8 * 4096, mono_pagesize ());
1837
1838 g_assert ((guint8*)&sa >= (guint8*)tls->stack_ovf_guard_base + tls->stack_ovf_guard_size);
1839
1840 if (mono_mprotect (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_NONE)) {
1841 /* mprotect can fail for the main thread stack */
1842 gpointer gaddr = mono_valloc (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_NONE|MONO_MMAP_PRIVATE|MONO_MMAP_ANON|MONO_MMAP_FIXED);
1843 g_assert (gaddr == tls->stack_ovf_guard_base);
1844 tls->stack_ovf_valloced = TRUE;
1845 }
1846
1847 /* Setup an alternate signal stack */
1848 tls->signal_stack = mono_valloc (0, MONO_ARCH_SIGNAL_STACK_SIZE, MONO_MMAP_READ|MONO_MMAP_WRITE|MONO_MMAP_PRIVATE|MONO_MMAP_ANON);
1849 tls->signal_stack_size = MONO_ARCH_SIGNAL_STACK_SIZE;
1850
1851 g_assert (tls->signal_stack);
1852
1853 sa.ss_sp = tls->signal_stack;
1854 sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
1855 sa.ss_flags = SS_ONSTACK;
1856 sigaltstack (&sa, NULL);
1857 }
1858
1859 void
1860 mono_free_altstack (MonoJitTlsData *tls)
1861 {
1862 struct sigaltstack sa;
1863 int err;
1864
1865 sa.ss_sp = tls->signal_stack;
1866 sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
1867 sa.ss_flags = SS_DISABLE;
1868 err = sigaltstack (&sa, NULL);
1869 g_assert (err == 0);
1870
1871 if (tls->signal_stack)
1872 mono_vfree (tls->signal_stack, MONO_ARCH_SIGNAL_STACK_SIZE);
1873 if (tls->stack_ovf_valloced)
1874 mono_vfree (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size);
1875 else
1876 mono_mprotect (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_READ|MONO_MMAP_WRITE);
1877 }
1878
1879 #else /* !MONO_ARCH_SIGSEGV_ON_ALTSTACK */
1880
1881 void
1882 mono_setup_altstack (MonoJitTlsData *tls)
1883 {
1884 }
1885
1886 void
1887 mono_free_altstack (MonoJitTlsData *tls)
1888 {
1889 }
1890
1891 #endif /* MONO_ARCH_SIGSEGV_ON_ALTSTACK */
1892
1893 static gboolean
1894 try_restore_stack_protection (MonoJitTlsData *jit_tls, int extra_bytes)
1895 {
1896 gint32 unprotect_size = jit_tls->stack_ovf_guard_size;
1897 /* we need to leave some room for throwing the exception */
1898 while (unprotect_size >= 0 && (char*)jit_tls->stack_ovf_guard_base + unprotect_size > ((char*)&unprotect_size - extra_bytes))
1899 unprotect_size -= mono_pagesize ();
1900 /* at this point we could try and build a new domain->stack_overflow_ex, but only if there
1901 * is sufficient stack
1902 */
1903 //fprintf (stderr, "restoring stack protection: %p-%p (%d)\n", jit_tls->stack_ovf_guard_base, (char*)jit_tls->stack_ovf_guard_base + unprotect_size, unprotect_size);
1904 if (unprotect_size)
1905 mono_mprotect (jit_tls->stack_ovf_guard_base, unprotect_size, MONO_MMAP_NONE);
1906 return unprotect_size == jit_tls->stack_ovf_guard_size;
1907 }
1908
1909 static void
1910 try_more_restore (void)
1911 {
1912 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1913 if (try_restore_stack_protection (jit_tls, 500))
1914 jit_tls->restore_stack_prot = NULL;
1915 }
1916
1917 static void
1918 restore_stack_protection (void)
1919 {
1920 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1921 MonoException *ex = mono_domain_get ()->stack_overflow_ex;
1922 /* if we can't restore the stack protection, keep a callback installed so
1923 * we'll try to restore as much stack as we can at each return from unmanaged
1924 * code.
1925 */
1926 if (try_restore_stack_protection (jit_tls, 4096))
1927 jit_tls->restore_stack_prot = NULL;
1928 else
1929 jit_tls->restore_stack_prot = try_more_restore_tramp;
1930 /* here we also throw a stack overflow exception */
1931 ex->trace_ips = NULL;
1932 ex->stack_trace = NULL;
1933 mono_raise_exception (ex);
1934 }
1935
1936 gpointer
1937 mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
1938 {
1939 void (*func)(void) = (gpointer)tramp_data;
1940 func ();
1941 return NULL;
1942 }
1943
1944 gboolean
1945 mono_handle_soft_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, guint8* fault_addr)
1946 {
1947 /* we got a stack overflow in the soft-guard pages
1948 * There are two cases:
1949 * 1) managed code caused the overflow: we unprotect the soft-guard page
1950 * and let the arch-specific code trigger the exception handling mechanism
1951 * in the thread stack. The soft-guard pages will be protected again as the stack is unwound.
1952 * 2) unmanaged code caused the overflow: we unprotect the soft-guard page
1953 * and hope we can continue with those enabled, at least until the hard-guard page
1954 * is hit. The alternative to continuing here is to just print a message and abort.
1955 * We may add in the future the code to protect the pages again in the codepath
1956 * when we return from unmanaged to managed code.
1957 */
1958 if (jit_tls->stack_ovf_guard_size && fault_addr >= (guint8*)jit_tls->stack_ovf_guard_base &&
1959 fault_addr < (guint8*)jit_tls->stack_ovf_guard_base + jit_tls->stack_ovf_guard_size) {
1960 /* we unprotect the minimum amount we can */
1961 guint32 guard_size;
1962 gboolean handled = FALSE;
1963
1964 guard_size = jit_tls->stack_ovf_guard_size - (mono_pagesize () * SIZEOF_VOID_P / 4);
1965 while (guard_size && fault_addr < (guint8*)jit_tls->stack_ovf_guard_base + guard_size) {
1966 guard_size -= mono_pagesize ();
1967 }
1968 guard_size = jit_tls->stack_ovf_guard_size - guard_size;
1969 /*fprintf (stderr, "unprotecting: %d\n", guard_size);*/
1970 mono_mprotect ((char*)jit_tls->stack_ovf_guard_base + jit_tls->stack_ovf_guard_size - guard_size, guard_size, MONO_MMAP_READ|MONO_MMAP_WRITE);
1971 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
1972 if (ji) {
1973 mono_arch_handle_altstack_exception (ctx, fault_addr, TRUE);
1974 handled = TRUE;
1975 }
1976 #endif
1977 if (!handled) {
1978 /* We print a message: after this even managed stack overflows
1979 * may crash the runtime
1980 */
1981 fprintf (stderr, "Stack overflow in unmanaged: IP: %p, fault addr: %p\n", mono_arch_ip_from_context (ctx), fault_addr);
1982 if (!jit_tls->handling_stack_ovf) {
1983 jit_tls->restore_stack_prot = restore_stack_protection_tramp;
1984 jit_tls->handling_stack_ovf = 1;
1985 } else {
1986 /*fprintf (stderr, "Already handling stack overflow\n");*/
1987 }
1988 }
1989 return TRUE;
1990 }
1991 return FALSE;
1992 }
1993
1994 static gboolean
1995 print_stack_frame (MonoMethod *method, gint32 native_offset, gint32 il_offset, gboolean managed, gpointer data)
1996 {
1997 FILE *stream = (FILE*)data;
1998
1999 if (method) {
2000 gchar *location = mono_debug_print_stack_frame (method, native_offset, mono_domain_get ());
2001 fprintf (stream, " %s\n", location);
2002 g_free (location);
2003 } else
2004 fprintf (stream, " at <unknown> <0x%05x>\n", native_offset);
2005
2006 return FALSE;
2007 }
2008
2009 static G_GNUC_UNUSED gboolean
2010 print_stack_frame_to_string (MonoMethod *method, gint32 native_offset, gint32 il_offset, gboolean managed,
2011 gpointer data)
2012 {
2013 GString *p = (GString*)data;
2014
2015 if (method) {
2016 gchar *location = mono_debug_print_stack_frame (method, native_offset, mono_domain_get ());
2017 g_string_append_printf (p, " %s\n", location);
2018 g_free (location);
2019 } else
2020 g_string_append_printf (p, " at <unknown> <0x%05x>\n", native_offset);
2021
2022 return FALSE;
2023 }
2024
2025 static gboolean handling_sigsegv = FALSE;
2026
2027 /*
2028 * mono_handle_native_sigsegv:
2029 *
2030 * Handle a SIGSEGV received while in native code by printing diagnostic
2031 * information and aborting.
2032 */
2033 void
2034 mono_handle_native_sigsegv (int signal, void *ctx)
2035 {
2036 #ifdef MONO_ARCH_USE_SIGACTION
2037 struct sigaction sa;
2038 #endif
2039 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
2040
2041 if (handling_sigsegv)
2042 return;
2043
2044 if (mini_get_debug_options ()->suspend_on_sigsegv) {
2045 fprintf (stderr, "Received SIGSEGV, suspending...");
2046 while (1)
2047 ;
2048 }
2049
2050 /* To prevent infinite loops when the stack walk causes a crash */
2051 handling_sigsegv = TRUE;
2052
2053 /* !jit_tls means the thread was not registered with the runtime */
2054 if (jit_tls && mono_thread_internal_current ()) {
2055 fprintf (stderr, "Stacktrace:\n\n");
2056
2057 mono_jit_walk_stack (print_stack_frame, TRUE, stderr);
2058
2059 fflush (stderr);
2060 }
2061
2062 #ifdef HAVE_BACKTRACE_SYMBOLS
2063 {
2064 void *array [256];
2065 char **names;
2066 int i, size;
2067 const char *signal_str = (signal == SIGSEGV) ? "SIGSEGV" : "SIGABRT";
2068
2069 fprintf (stderr, "\nNative stacktrace:\n\n");
2070
2071 size = backtrace (array, 256);
2072 names = backtrace_symbols (array, size);
2073 for (i =0; i < size; ++i) {
2074 fprintf (stderr, "\t%s\n", names [i]);
2075 }
2076 free (names);
2077
2078 fflush (stderr);
2079
2080 /* Try to get more meaningful information using gdb */
2081
2082 #if !defined(HOST_WIN32) && defined(HAVE_SYS_SYSCALL_H) && defined(SYS_fork)
2083 if (!mini_get_debug_options ()->no_gdb_backtrace && !mono_debug_using_mono_debugger ()) {
2084 /* From g_spawn_command_line_sync () in eglib */
2085 int res;
2086 int stdout_pipe [2] = { -1, -1 };
2087 pid_t pid;
2088 int status;
2089 char buffer [1024];
2090
2091 res = pipe (stdout_pipe);
2092 g_assert (res != -1);
2093
2094 //pid = fork ();
2095 /*
2096 * glibc fork acquires some locks, so if the crash happened inside malloc/free,
2097 * it will deadlock. Call the syscall directly instead.
2098 */
2099 pid = mono_runtime_syscall_fork ();
2100
2101 if (pid == 0) {
2102 close (stdout_pipe [0]);
2103 dup2 (stdout_pipe [1], STDOUT_FILENO);
2104
2105 for (i = getdtablesize () - 1; i >= 3; i--)
2106 close (i);
2107
2108 if (!mono_gdb_render_native_backtraces ())
2109 close (STDOUT_FILENO);
2110
2111 exit (1);
2112 }
2113
2114 close (stdout_pipe [1]);
2115
2116 fprintf (stderr, "\nDebug info from gdb:\n\n");
2117
2118 while (1) {
2119 int nread = read (stdout_pipe [0], buffer, 1024);
2120
2121 if (nread <= 0)
2122 break;
2123 write (STDERR_FILENO, buffer, nread);
2124 }
2125
2126 waitpid (pid, &status, WNOHANG);
2127 }
2128 #endif
2129 /*
2130 * A SIGSEGV indicates something went very wrong so we can no longer depend
2131 * on anything working. So try to print out lots of diagnostics, starting
2132 * with ones which have a greater chance of working.
2133 */
2134 fprintf (stderr,
2135 "\n"
2136 "=================================================================\n"
2137 "Got a %s while executing native code. This usually indicates\n"
2138 "a fatal error in the mono runtime or one of the native libraries \n"
2139 "used by your application.\n"
2140 "=================================================================\n"
2141 "\n", signal_str);
2142
2143 }
2144 #endif
2145
2146 #ifdef MONO_ARCH_USE_SIGACTION
2147
2148 /* Remove our SIGABRT handler */
2149 sa.sa_handler = SIG_DFL;
2150 sigemptyset (&sa.sa_mask);
2151 sa.sa_flags = 0;
2152
2153 g_assert (sigaction (SIGABRT, &sa, NULL) != -1);
2154
2155 #endif
2156
2157 abort ();
2158 }
2159
2160 static void
2161 mono_print_thread_dump_internal (void *sigctx, MonoContext *start_ctx)
2162 {
2163 MonoInternalThread *thread = mono_thread_internal_current ();
2164 #if defined(__i386__) || defined(__x86_64__)
2165 MonoContext ctx;
2166 #endif
2167 GString* text = g_string_new (0);
2168 char *name, *wapi_desc;
2169 GError *error = NULL;
2170
2171 if (thread->name) {
2172 name = g_utf16_to_utf8 (thread->name, thread->name_len, NULL, NULL, &error);
2173 g_assert (!error);
2174 g_string_append_printf (text, "\n\"%s\"", name);
2175 g_free (name);
2176 }
2177 else if (thread->threadpool_thread)
2178 g_string_append (text, "\n\"<threadpool thread>\"");
2179 else
2180 g_string_append (text, "\n\"<unnamed thread>\"");
2181
2182 #ifndef HOST_WIN32
2183 wapi_desc = wapi_current_thread_desc ();
2184 g_string_append_printf (text, " tid=0x%p this=0x%p %s\n", (gpointer)(gsize)thread->tid, thread, wapi_desc);
2185 free (wapi_desc);
2186 #endif
2187
2188 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2189 if (start_ctx) {
2190 memcpy (&ctx, start_ctx, sizeof (MonoContext));
2191 } else if (!sigctx)
2192 MONO_INIT_CONTEXT_FROM_FUNC (&ctx, mono_print_thread_dump);
2193 else
2194 mono_arch_sigctx_to_monoctx (sigctx, &ctx);
2195
2196 mono_jit_walk_stack_from_ctx (print_stack_frame_to_string, &ctx, TRUE, text);
2197 #else
2198 printf ("\t<Stack traces in thread dumps not supported on this platform>\n");
2199 #endif
2200
2201 fprintf (stdout, "%s", text->str);
2202 g_string_free (text, TRUE);
2203 fflush (stdout);
2204 }
2205
2206 /*
2207 * mono_print_thread_dump:
2208 *
2209 * Print information about the current thread to stdout.
2210 * SIGCTX can be NULL, allowing this to be called from gdb.
2211 */
2212 void
2213 mono_print_thread_dump (void *sigctx)
2214 {
2215 mono_print_thread_dump_internal (sigctx, NULL);
2216 }
2217
2218 void
2219 mono_print_thread_dump_from_ctx (MonoContext *ctx)
2220 {
2221 mono_print_thread_dump_internal (NULL, ctx);
2222 }
2223
2224 /*
2225 * mono_resume_unwind:
2226 *
2227 * This is called by a trampoline from LLVM compiled finally clauses to continue
2228 * unwinding.
2229 */
2230 void
2231 mono_resume_unwind (MonoContext *ctx)
2232 {
2233 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
2234 static void (*restore_context) (MonoContext *);
2235 MonoContext new_ctx;
2236
2237 MONO_CONTEXT_SET_IP (ctx, MONO_CONTEXT_GET_IP (&jit_tls->resume_state.ctx));
2238 MONO_CONTEXT_SET_SP (ctx, MONO_CONTEXT_GET_SP (&jit_tls->resume_state.ctx));
2239 new_ctx = *ctx;
2240
2241 mono_handle_exception_internal (&new_ctx, jit_tls->resume_state.ex_obj, NULL, TRUE, NULL);
2242
2243 if (!restore_context)
2244 restore_context = mono_get_restore_context ();
2245
2246 restore_context (&new_ctx);
2247 }
2248
2249 #ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD
2250
2251 typedef struct {
2252 MonoJitInfo *ji;
2253 MonoContext ctx;
2254 MonoJitExceptionInfo *ei;
2255 } FindHandlerBlockData;
2256
2257 static gboolean
2258 find_last_handler_block (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2259 {
2260 int i;
2261 gpointer ip;
2262 FindHandlerBlockData *pdata = data;
2263 MonoJitInfo *ji = frame->ji;
2264
2265 if (!ji)
2266 return FALSE;
2267
2268 if (ji->method->wrapper_type)
2269 return FALSE;
2270
2271 ip = MONO_CONTEXT_GET_IP (ctx);
2272
2273 for (i = 0; i < ji->num_clauses; ++i) {
2274 MonoJitExceptionInfo *ei = ji->clauses + i;
2275 if (ei->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
2276 continue;
2277 /*If ip points to the first instruction it means the handler block didn't start
2278 so we can leave its execution to the EH machinery*/
2279 if (ei->handler_start < ip && ip < ei->data.handler_end) {
2280 pdata->ji = ji;
2281 pdata->ei = ei;
2282 pdata->ctx = *ctx;
2283 break;
2284 }
2285 }
2286 return FALSE;
2287 }
2288
2289
2290 static gpointer
2291 install_handler_block_guard (MonoJitInfo *ji, MonoContext *ctx)
2292 {
2293 int i;
2294 MonoJitExceptionInfo *clause = NULL;
2295 gpointer ip;
2296
2297 ip = MONO_CONTEXT_GET_IP (ctx);
2298
2299 for (i = 0; i < ji->num_clauses; ++i) {
2300 clause = &ji->clauses [i];
2301 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
2302 continue;
2303 if (clause->handler_start < ip && clause->data.handler_end > ip)
2304 break;
2305 }
2306
2307 /*no matching finally */
2308 if (i == ji->num_clauses)
2309 return NULL;
2310
2311 /*If we stopped on the instruction right before the try, we haven't actually started executing it*/
2312 if (ip == clause->handler_start)
2313 return NULL;
2314
2315 return mono_arch_install_handler_block_guard (ji, clause, ctx, mono_create_handler_block_trampoline ());
2316 }
2317
2318 /*
2319 * Finds the bottom handler block running and install a block guard if needed.
2320 */
2321 gboolean
2322 mono_install_handler_block_guard (MonoInternalThread *thread, MonoContext *ctx)
2323 {
2324 FindHandlerBlockData data = { 0 };
2325 MonoDomain *domain = mono_domain_get ();
2326 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
2327 gpointer resume_ip;
2328
2329 /* Guard against a null MonoJitTlsData. This can happens if the thread receives the
2330 * interrupt signal before the JIT has time to initialize its TLS data for the given thread.
2331 */
2332 if (!jit_tls || jit_tls->handler_block_return_address)
2333 return FALSE;
2334
2335 mono_walk_stack (find_last_handler_block, domain, ctx, FALSE, NULL, NULL, &data);
2336
2337 if (!data.ji)
2338 return FALSE;
2339
2340 memcpy (&jit_tls->handler_block_context, &data.ctx, sizeof (MonoContext));
2341
2342 resume_ip = install_handler_block_guard (data.ji, &data.ctx);
2343 if (resume_ip == NULL)
2344 return FALSE;
2345
2346 jit_tls->handler_block_return_address = resume_ip;
2347 jit_tls->handler_block = data.ei;
2348
2349 #ifndef HOST_WIN32
2350 /*Clear current thread from been wapi interrupted otherwise things can go south*/
2351 wapi_clear_interruption ();
2352 #endif
2353 return TRUE;
2354 }
2355
2356 #else
2357 gboolean
2358 mono_install_handler_block_guard (MonoInternalThread *thread, MonoContext *ctx)
2359 {
2360 return FALSE;
2361 }
2362
2363 #endif
2364
Mirror of the official Mono project git repository