mono/mini/mini-posix.c

   1 /*
   2  * mini-posix.c: POSIX signal handling support for Mono.
   3  *
   4  * Authors:
   5  *   Mono Team (mono-list@lists.ximian.com)
   6  *
   7  * Copyright 2001-2003 Ximian, Inc.
   8  * Copyright 2003-2008 Ximian, Inc.
   9  * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
  10  *
  11  * See LICENSE for licensing information.
  12  */
  13 #include <config.h>
  14 #include <signal.h>
  15 #ifdef HAVE_ALLOCA_H
  16 #include <alloca.h>
  17 #endif
  18 #ifdef HAVE_UNISTD_H
  19 #include <unistd.h>
  20 #endif
  21 #include <math.h>
  22 #ifdef HAVE_SYS_TIME_H
  23 #include <sys/time.h>
  24 #endif
  25 #ifdef HAVE_SYS_SYSCALL_H
  26 #include <sys/syscall.h>
  27 #endif
  28 #include <errno.h>
  29
  30
  31 #include <mono/metadata/assembly.h>
  32 #include <mono/metadata/loader.h>
  33 #include <mono/metadata/tabledefs.h>
  34 #include <mono/metadata/class.h>
  35 #include <mono/metadata/object.h>
  36 #include <mono/metadata/tokentype.h>
  37 #include <mono/metadata/tabledefs.h>
  38 #include <mono/metadata/threads.h>
  39 #include <mono/metadata/appdomain.h>
  40 #include <mono/metadata/debug-helpers.h>
  41 #include <mono/io-layer/io-layer.h>
  42 #include "mono/metadata/profiler.h"
  43 #include <mono/metadata/profiler-private.h>
  44 #include <mono/metadata/mono-config.h>
  45 #include <mono/metadata/environment.h>
  46 #include <mono/metadata/mono-debug.h>
  47 #include <mono/metadata/gc-internal.h>
  48 #include <mono/metadata/threads-types.h>
  49 #include <mono/metadata/verify.h>
  50 #include <mono/metadata/verify-internals.h>
  51 #include <mono/metadata/mempool-internals.h>
  52 #include <mono/metadata/attach.h>
  53 #include <mono/utils/mono-math.h>
  54 #include <mono/utils/mono-compiler.h>
  55 #include <mono/utils/mono-counters.h>
  56 #include <mono/utils/mono-logger-internal.h>
  57 #include <mono/utils/mono-mmap.h>
  58 #include <mono/utils/dtrace.h>
  59 #include <mono/utils/mono-signal-handler.h>
  60 #include <mono/utils/mono-threads.h>
  61
  62 #include "mini.h"
  63 #include <string.h>
  64 #include <ctype.h>
  65 #include "trace.h"
  66 #include "version.h"
  67 #include "debugger-agent.h"
  68
  69 #include "jit-icalls.h"
  70
  71 #if defined(__native_client__)
  72
  73 void
  74 mono_runtime_setup_stat_profiler (void)
  75 {
  76         printf("WARNING: mono_runtime_setup_stat_profiler() called!\n");
  77 }
  78
  79
  80 void
  81 mono_runtime_shutdown_stat_profiler (void)
  82 {
  83 }
  84
  85
  86 gboolean
  87 MONO_SIG_HANDLER_SIGNATURE (mono_chain_signal)
  88 {
  89         return FALSE;
  90 }
  91
  92 void
  93 mono_runtime_install_handlers (void)
  94 {
  95 }
  96
  97 void
  98 mono_runtime_shutdown_handlers (void)
  99 {
 100 }
 101
 102 void
 103 mono_runtime_cleanup_handlers (void)
 104 {
 105 }
 106
 107 pid_t
 108 mono_runtime_syscall_fork (void)
 109 {
 110         g_assert_not_reached();
 111         return 0;
 112 }
 113
 114 void
 115 mono_gdb_render_native_backtraces (pid_t crashed_pid)
 116 {
 117 }
 118
 119 #else
 120
 121 static GHashTable *mono_saved_signal_handlers = NULL;
 122
 123 static gpointer
 124 get_saved_signal_handler (int signo)
 125 {
 126         if (mono_saved_signal_handlers)
 127                 /* The hash is only modified during startup, so no need for locking */
 128                 return g_hash_table_lookup (mono_saved_signal_handlers, GINT_TO_POINTER (signo));
 129         return NULL;
 130 }
 131
 132 static void
 133 save_old_signal_handler (int signo, struct sigaction *old_action)
 134 {
 135         struct sigaction *handler_to_save = g_malloc (sizeof (struct sigaction));
 136
 137         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_CONFIG,
 138                                 "Saving old signal handler for signal %d.", signo);
 139
 140         if (! (old_action->sa_flags & SA_SIGINFO)) {
 141                 handler_to_save->sa_handler = old_action->sa_handler;
 142         } else {
 143 #ifdef MONO_ARCH_USE_SIGACTION
 144                 handler_to_save->sa_sigaction = old_action->sa_sigaction;
 145 #endif /* MONO_ARCH_USE_SIGACTION */
 146         }
 147         handler_to_save->sa_mask = old_action->sa_mask;
 148         handler_to_save->sa_flags = old_action->sa_flags;
 149
 150         if (!mono_saved_signal_handlers)
 151                 mono_saved_signal_handlers = g_hash_table_new (NULL, NULL);
 152         g_hash_table_insert (mono_saved_signal_handlers, GINT_TO_POINTER (signo), handler_to_save);
 153 }
 154
 155 static void
 156 free_saved_sig_handler_func (gpointer key, gpointer value, gpointer user_data)
 157 {
 158         g_free (value);
 159 }
 160
 161 static void
 162 free_saved_signal_handlers (void)
 163 {
 164         if (mono_saved_signal_handlers) {
 165                 g_hash_table_foreach (mono_saved_signal_handlers, free_saved_sig_handler_func, NULL);
 166                 g_hash_table_destroy (mono_saved_signal_handlers);
 167                 mono_saved_signal_handlers = NULL;
 168         }
 169 }
 170
 171 /*
 172  * mono_chain_signal:
 173  *
 174  *   Call the original signal handler for the signal given by the arguments, which
 175  * should be the same as for a signal handler. Returns TRUE if the original handler
 176  * was called, false otherwise.
 177  */
 178 gboolean
 179 MONO_SIG_HANDLER_SIGNATURE (mono_chain_signal)
 180 {
 181         int signal = MONO_SIG_HANDLER_GET_SIGNO ();
 182         struct sigaction *saved_handler = get_saved_signal_handler (signal);
 183
 184         if (saved_handler && saved_handler->sa_handler) {
 185                 if (!(saved_handler->sa_flags & SA_SIGINFO)) {
 186                         saved_handler->sa_handler (signal);
 187                 } else {
 188 #ifdef MONO_ARCH_USE_SIGACTION
 189                         saved_handler->sa_sigaction (MONO_SIG_HANDLER_PARAMS);
 190 #endif /* MONO_ARCH_USE_SIGACTION */
 191                 }
 192                 return TRUE;
 193         }
 194         return FALSE;
 195 }
 196
 197 MONO_SIG_HANDLER_FUNC (static, sigabrt_signal_handler)
 198 {
 199         MonoJitInfo *ji = NULL;
 200         MONO_SIG_HANDLER_GET_CONTEXT;
 201
 202         if (mono_thread_internal_current ())
 203                 ji = mono_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (ctx));
 204         if (!ji) {
 205         if (mono_chain_signal (MONO_SIG_HANDLER_PARAMS))
 206                         return;
 207                 mono_handle_native_sigsegv (SIGABRT, ctx);
 208         }
 209 }
 210
 211 MONO_SIG_HANDLER_FUNC (static, sigusr1_signal_handler)
 212 {
 213         gboolean running_managed;
 214         MonoException *exc;
 215         MonoInternalThread *thread = mono_thread_internal_current ();
 216         MonoDomain *domain = mono_domain_get ();
 217         void *ji;
 218         MONO_SIG_HANDLER_GET_CONTEXT;
 219
 220         if (!thread || !domain) {
 221                 /* The thread might not have started up yet */
 222                 /* FIXME: Specify the synchronization with start_wrapper () in threads.c */
 223                 mono_debugger_agent_thread_interrupt (ctx, NULL);
 224                 return;
 225         }
 226
 227         if (thread->ignore_next_signal) {
 228                 thread->ignore_next_signal = FALSE;
 229                 return;
 230         }
 231
 232         if (thread->thread_dump_requested) {
 233                 thread->thread_dump_requested = FALSE;
 234
 235                 mono_print_thread_dump (ctx);
 236         }
 237
 238         /*
 239          * This is an async signal, so the code below must not call anything which
 240          * is not async safe. That includes the pthread locking functions. If we
 241          * know that we interrupted managed code, then locking is safe.
 242          */
 243         /*
 244          * On OpenBSD, ctx can be NULL if we are interrupting poll ().
 245          */
 246         if (ctx) {
 247                 ji = mono_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context(ctx));
 248                 running_managed = ji != NULL;
 249
 250                 if (mono_debugger_agent_thread_interrupt (ctx, ji))
 251                         return;
 252         } else {
 253                 running_managed = FALSE;
 254         }
 255
 256         /* We can't do handler block checking from metadata since it requires doing
 257          * a stack walk with context.
 258          *
 259          * FIXME add full-aot support.
 260          */
 261 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
 262         if (!mono_aot_only && ctx) {
 263                 MonoThreadUnwindState unwind_state;
 264                 if (mono_thread_state_init_from_sigctx (&unwind_state, ctx)) {
 265                         if (mono_install_handler_block_guard (&unwind_state)) {
 266 #ifndef HOST_WIN32
 267                                 /*Clear current thread from been wapi interrupted otherwise things can go south*/
 268                                 wapi_clear_interruption ();
 269 #endif
 270                                 return;
 271                         }
 272                 }
 273         }
 274 #endif
 275
 276         exc = mono_thread_request_interruption (running_managed);
 277         if (!exc)
 278                 return;
 279
 280         mono_arch_handle_exception (ctx, exc);
 281 }
 282
 283
 284 #if defined(__i386__) || defined(__x86_64__)
 285 #define FULL_STAT_PROFILER_BACKTRACE 1
 286 #define CURRENT_FRAME_GET_BASE_POINTER(f) (* (gpointer*)(f))
 287 #define CURRENT_FRAME_GET_RETURN_ADDRESS(f) (* (((gpointer*)(f)) + 1))
 288 #if MONO_ARCH_STACK_GROWS_UP
 289 #define IS_BEFORE_ON_STACK <
 290 #define IS_AFTER_ON_STACK >
 291 #else
 292 #define IS_BEFORE_ON_STACK >
 293 #define IS_AFTER_ON_STACK <
 294 #endif
 295 #else
 296 #define FULL_STAT_PROFILER_BACKTRACE 0
 297 #endif
 298
 299 #ifdef SIGPROF
 300 #if defined(__ia64__) || defined(__sparc__) || defined(sparc) || defined(__s390__) || defined(s390)
 301
 302 MONO_SIG_HANDLER_FUNC (static, sigprof_signal_handler)
 303 {
 304         if (mono_chain_signal (MONO_SIG_HANDLER_PARAMS))
 305                 return;
 306
 307         NOT_IMPLEMENTED;
 308 }
 309
 310 #else
 311
 312 static int
 313 get_stage2_signal_handler (void)
 314 {
 315 #if defined(PLATFORM_ANDROID)
 316         return SIGINFO;
 317 #elif !defined (SIGRTMIN)
 318 #ifdef SIGUSR2
 319         return SIGUSR2;
 320 #else
 321         return -1;
 322 #endif /* SIGUSR2 */
 323 #else
 324         static int prof2_signum = -1;
 325         int i;
 326         if (prof2_signum != -1)
 327                 return prof2_signum;
 328         /* we try to avoid SIGRTMIN and any one that might have been set already */
 329         for (i = SIGRTMIN + 2; i < SIGRTMAX; ++i) {
 330                 struct sigaction sinfo;
 331                 sigaction (i, NULL, &sinfo);
 332                 if (sinfo.sa_handler == SIG_DFL && (void*)sinfo.sa_sigaction == (void*)SIG_DFL) {
 333                         prof2_signum = i;
 334                         return i;
 335                 }
 336         }
 337         /* fallback to the old way */
 338         return SIGRTMIN + 2;
 339 #endif
 340 }
 341
 342
 343 static void
 344 per_thread_profiler_hit (void *ctx)
 345 {
 346         int call_chain_depth = mono_profiler_stat_get_call_chain_depth ();
 347         MonoProfilerCallChainStrategy call_chain_strategy = mono_profiler_stat_get_call_chain_strategy ();
 348
 349         if (call_chain_depth == 0) {
 350                 mono_profiler_stat_hit (mono_arch_ip_from_context (ctx), ctx);
 351         } else {
 352                 MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
 353                 int current_frame_index = 1;
 354                 MonoContext mono_context;
 355                 guchar *ips [call_chain_depth + 1];
 356
 357                 mono_arch_sigctx_to_monoctx (ctx, &mono_context);
 358                 ips [0] = MONO_CONTEXT_GET_IP (&mono_context);
 359
 360                 if (jit_tls != NULL) {
 361                         if (call_chain_strategy == MONO_PROFILER_CALL_CHAIN_NATIVE) {
 362 #if FULL_STAT_PROFILER_BACKTRACE
 363                         guchar *current_frame;
 364                         guchar *stack_bottom;
 365                         guchar *stack_top;
 366
 367                         stack_bottom = jit_tls->end_of_stack;
 368                         stack_top = MONO_CONTEXT_GET_SP (&mono_context);
 369                         current_frame = MONO_CONTEXT_GET_BP (&mono_context);
 370
 371                         while ((current_frame_index <= call_chain_depth) &&
 372                                         (stack_bottom IS_BEFORE_ON_STACK (guchar*) current_frame) &&
 373                                         ((guchar*) current_frame IS_BEFORE_ON_STACK stack_top)) {
 374                                 ips [current_frame_index] = CURRENT_FRAME_GET_RETURN_ADDRESS (current_frame);
 375                                 current_frame_index ++;
 376                                 stack_top = current_frame;
 377                                 current_frame = CURRENT_FRAME_GET_BASE_POINTER (current_frame);
 378                         }
 379 #else
 380                                 call_chain_strategy = MONO_PROFILER_CALL_CHAIN_GLIBC;
 381 #endif
 382                         }
 383
 384                         if (call_chain_strategy == MONO_PROFILER_CALL_CHAIN_GLIBC) {
 385 #if GLIBC_PROFILER_BACKTRACE
 386                                 current_frame_index = backtrace ((void**) & ips [1], call_chain_depth);
 387 #else
 388                                 call_chain_strategy = MONO_PROFILER_CALL_CHAIN_MANAGED;
 389 #endif
 390                         }
 391
 392                         if (call_chain_strategy == MONO_PROFILER_CALL_CHAIN_MANAGED) {
 393                                 MonoDomain *domain = mono_domain_get ();
 394                                 if (domain != NULL) {
 395                                         MonoLMF *lmf = NULL;
 396                                         MonoJitInfo *ji;
 397                                         MonoJitInfo res;
 398                                         MonoContext new_mono_context;
 399                                         int native_offset;
 400                                         ji = mono_find_jit_info (domain, jit_tls, &res, NULL, &mono_context,
 401                                                         &new_mono_context, NULL, &lmf, &native_offset, NULL);
 402                                         while ((ji != NULL) && (current_frame_index <= call_chain_depth)) {
 403                                                 ips [current_frame_index] = MONO_CONTEXT_GET_IP (&new_mono_context);
 404                                                 current_frame_index ++;
 405                                                 mono_context = new_mono_context;
 406                                                 ji = mono_find_jit_info (domain, jit_tls, &res, NULL, &mono_context,
 407                                                                 &new_mono_context, NULL, &lmf, &native_offset, NULL);
 408                                         }
 409                                 }
 410                         }
 411                 }
 412
 413                 mono_profiler_stat_call_chain (current_frame_index, & ips [0], ctx);
 414         }
 415 }
 416
 417 MONO_SIG_HANDLER_FUNC (static, sigprof_stage2_signal_handler)
 418 {
 419         MONO_SIG_HANDLER_GET_CONTEXT;
 420
 421         per_thread_profiler_hit (ctx);
 422
 423         mono_chain_signal (MONO_SIG_HANDLER_PARAMS);
 424 }
 425
 426 MONO_SIG_HANDLER_FUNC (static, sigprof_signal_handler)
 427 {
 428         MonoThreadInfo *info;
 429         int old_errno = errno;
 430         int hp_save_index = mono_hazard_pointer_save_for_signal_handler ();
 431         MONO_SIG_HANDLER_GET_CONTEXT;
 432
 433         FOREACH_THREAD_SAFE (info) {
 434                 if (mono_thread_info_get_tid (info) == mono_native_thread_id_get ())
 435                         continue;
 436                 mono_threads_pthread_kill (info, get_stage2_signal_handler ());
 437         } END_FOREACH_THREAD_SAFE;
 438
 439         per_thread_profiler_hit (ctx);
 440
 441         mono_hazard_pointer_restore_for_signal_handler (hp_save_index);
 442         errno = old_errno;
 443
 444         mono_chain_signal (MONO_SIG_HANDLER_PARAMS);
 445 }
 446
 447 #endif
 448 #endif
 449
 450 MONO_SIG_HANDLER_FUNC (static, sigquit_signal_handler)
 451 {
 452         gboolean res;
 453         MONO_SIG_HANDLER_GET_CONTEXT;
 454
 455         /* We use this signal to start the attach agent too */
 456         res = mono_attach_start ();
 457         if (res)
 458                 return;
 459
 460         if (mono_thread_info_new_interrupt_enabled ()) {
 461                 mono_threads_request_thread_dump ();
 462         } else {
 463                 printf ("Full thread dump:\n");
 464
 465                 mono_threads_request_thread_dump ();
 466
 467                 /*
 468                  * print_thread_dump () skips the current thread, since sending a signal
 469                  * to it would invoke the signal handler below the sigquit signal handler,
 470                  * and signal handlers don't create an lmf, so the stack walk could not
 471                  * be performed.
 472                  */
 473                 mono_print_thread_dump (ctx);
 474         }
 475
 476         mono_chain_signal (MONO_SIG_HANDLER_PARAMS);
 477 }
 478
 479 MONO_SIG_HANDLER_FUNC (static, sigusr2_signal_handler)
 480 {
 481         gboolean enabled = mono_trace_is_enabled ();
 482
 483         mono_trace_enable (!enabled);
 484
 485         mono_chain_signal (MONO_SIG_HANDLER_PARAMS);
 486 }
 487
 488 static void
 489 add_signal_handler (int signo, gpointer handler)
 490 {
 491         struct sigaction sa;
 492         struct sigaction previous_sa;
 493
 494 #ifdef MONO_ARCH_USE_SIGACTION
 495         sa.sa_sigaction = handler;
 496         sigemptyset (&sa.sa_mask);
 497         sa.sa_flags = SA_SIGINFO;
 498 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
 499
 500 /*Apple likes to deliver SIGBUS for *0 */
 501 #ifdef __APPLE__
 502         if (signo == SIGSEGV || signo == SIGBUS) {
 503 #else
 504         if (signo == SIGSEGV) {
 505 #endif
 506                 sa.sa_flags |= SA_ONSTACK;
 507
 508                 /*
 509                  * libgc will crash when trying to do stack marking for threads which are on
 510                  * an altstack, so delay the suspend signal after the signal handler has
 511                  * executed.
 512                  */
 513                 if (mono_gc_get_suspend_signal () != -1)
 514                         sigaddset (&sa.sa_mask, mono_gc_get_suspend_signal ());
 515         }
 516 #endif
 517         if (signo == SIGSEGV) {
 518                 /*
 519                  * Delay abort signals while handling SIGSEGVs since they could go unnoticed.
 520                  */
 521                 sigset_t block_mask;
 522
 523                 sigemptyset (&block_mask);
 524                 sigaddset (&sa.sa_mask, mono_thread_get_abort_signal ());
 525         }
 526 #else
 527         sa.sa_handler = handler;
 528         sigemptyset (&sa.sa_mask);
 529         sa.sa_flags = 0;
 530 #endif
 531         g_assert (sigaction (signo, &sa, &previous_sa) != -1);
 532
 533         /* if there was already a handler in place for this signal, store it */
 534         if (! (previous_sa.sa_flags & SA_SIGINFO) &&
 535                         (SIG_DFL == previous_sa.sa_handler)) {
 536                 /* it there is no sa_sigaction function and the sa_handler is default, we can safely ignore this */
 537         } else {
 538                 if (mono_do_signal_chaining)
 539                         save_old_signal_handler (signo, &previous_sa);
 540         }
 541 }
 542
 543 static void
 544 remove_signal_handler (int signo)
 545 {
 546         struct sigaction sa;
 547         struct sigaction *saved_action = get_saved_signal_handler (signo);
 548
 549         if (!saved_action) {
 550                 sa.sa_handler = SIG_DFL;
 551                 sigemptyset (&sa.sa_mask);
 552                 sa.sa_flags = 0;
 553
 554                 sigaction (signo, &sa, NULL);
 555         } else {
 556                 g_assert (sigaction (signo, saved_action, NULL) != -1);
 557         }
 558 }
 559
 560 void
 561 mono_runtime_posix_install_handlers (void)
 562 {
 563
 564         sigset_t signal_set;
 565
 566         if (mini_get_debug_options ()->handle_sigint)
 567                 add_signal_handler (SIGINT, mono_sigint_signal_handler);
 568
 569         add_signal_handler (SIGFPE, mono_sigfpe_signal_handler);
 570         add_signal_handler (SIGQUIT, sigquit_signal_handler);
 571         add_signal_handler (SIGILL, mono_sigill_signal_handler);
 572         add_signal_handler (SIGBUS, mono_sigsegv_signal_handler);
 573         if (mono_jit_trace_calls != NULL)
 574                 add_signal_handler (SIGUSR2, sigusr2_signal_handler);
 575
 576         if (!mono_thread_info_new_interrupt_enabled ())
 577                 add_signal_handler (mono_thread_get_abort_signal (), sigusr1_signal_handler);
 578         /* it seems to have become a common bug for some programs that run as parents
 579          * of many processes to block signal delivery for real time signals.
 580          * We try to detect and work around their breakage here.
 581          */
 582         sigemptyset (&signal_set);
 583         sigaddset (&signal_set, mono_thread_get_abort_signal ());
 584         if (mono_gc_get_suspend_signal () != -1)
 585                 sigaddset (&signal_set, mono_gc_get_suspend_signal ());
 586         if (mono_gc_get_restart_signal () != -1)
 587                 sigaddset (&signal_set, mono_gc_get_restart_signal ());
 588         sigaddset (&signal_set, SIGCHLD);
 589         sigprocmask (SIG_UNBLOCK, &signal_set, NULL);
 590
 591         signal (SIGPIPE, SIG_IGN);
 592
 593         add_signal_handler (SIGABRT, sigabrt_signal_handler);
 594
 595         /* catch SIGSEGV */
 596         add_signal_handler (SIGSEGV, mono_sigsegv_signal_handler);
 597 }
 598
 599 #ifndef PLATFORM_MACOSX
 600 void
 601 mono_runtime_install_handlers (void)
 602 {
 603         mono_runtime_posix_install_handlers ();
 604 }
 605 #endif
 606
 607 void
 608 mono_runtime_cleanup_handlers (void)
 609 {
 610         if (mini_get_debug_options ()->handle_sigint)
 611                 remove_signal_handler (SIGINT);
 612
 613         remove_signal_handler (SIGFPE);
 614         remove_signal_handler (SIGQUIT);
 615         remove_signal_handler (SIGILL);
 616         remove_signal_handler (SIGBUS);
 617         if (mono_jit_trace_calls != NULL)
 618                 remove_signal_handler (SIGUSR2);
 619
 620         remove_signal_handler (mono_thread_get_abort_signal ());
 621
 622         remove_signal_handler (SIGABRT);
 623
 624         remove_signal_handler (SIGSEGV);
 625
 626         free_saved_signal_handlers ();
 627 }
 628
 629 #ifdef HAVE_LINUX_RTC_H
 630 #include <linux/rtc.h>
 631 #include <sys/ioctl.h>
 632 #include <fcntl.h>
 633 static int rtc_fd = -1;
 634
 635 static int
 636 enable_rtc_timer (gboolean enable)
 637 {
 638         int flags;
 639         flags = fcntl (rtc_fd, F_GETFL);
 640         if (flags < 0) {
 641                 perror ("getflags");
 642                 return 0;
 643         }
 644         if (enable)
 645                 flags |= FASYNC;
 646         else
 647                 flags &= ~FASYNC;
 648         if (fcntl (rtc_fd, F_SETFL, flags) == -1) {
 649                 perror ("setflags");
 650                 return 0;
 651         }
 652         return 1;
 653 }
 654 #endif
 655
 656 void
 657 mono_runtime_shutdown_stat_profiler (void)
 658 {
 659 #ifdef HAVE_LINUX_RTC_H
 660         if (rtc_fd >= 0)
 661                 enable_rtc_timer (FALSE);
 662 #endif
 663 }
 664
 665 #ifdef ITIMER_PROF
 666 static int
 667 get_itimer_mode (void)
 668 {
 669         switch (mono_profiler_get_sampling_mode ()) {
 670         case MONO_PROFILER_STAT_MODE_PROCESS: return ITIMER_PROF;
 671         case MONO_PROFILER_STAT_MODE_REAL: return ITIMER_REAL;
 672         }
 673         g_assert_not_reached ();
 674         return 0;
 675 }
 676
 677 static int
 678 get_itimer_signal (void)
 679 {
 680         switch (mono_profiler_get_sampling_mode ()) {
 681         case MONO_PROFILER_STAT_MODE_PROCESS: return SIGPROF;
 682         case MONO_PROFILER_STAT_MODE_REAL: return SIGALRM;
 683         }
 684         g_assert_not_reached ();
 685         return 0;
 686 }
 687 #endif
 688
 689 void
 690 mono_runtime_setup_stat_profiler (void)
 691 {
 692 #ifdef ITIMER_PROF
 693         struct itimerval itval;
 694         static int inited = 0;
 695 #ifdef HAVE_LINUX_RTC_H
 696         const char *rtc_freq;
 697         if (!inited && (rtc_freq = g_getenv ("MONO_RTC"))) {
 698                 int freq = 0;
 699                 inited = 1;
 700                 if (*rtc_freq)
 701                         freq = atoi (rtc_freq);
 702                 if (!freq)
 703                         freq = 1024;
 704                 rtc_fd = open ("/dev/rtc", O_RDONLY);
 705                 if (rtc_fd == -1) {
 706                         perror ("open /dev/rtc");
 707                         return;
 708                 }
 709                 add_signal_handler (SIGPROF, sigprof_signal_handler);
 710                 if (ioctl (rtc_fd, RTC_IRQP_SET, freq) == -1) {
 711                         perror ("set rtc freq");
 712                         return;
 713                 }
 714                 if (ioctl (rtc_fd, RTC_PIE_ON, 0) == -1) {
 715                         perror ("start rtc");
 716                         return;
 717                 }
 718                 if (fcntl (rtc_fd, F_SETSIG, SIGPROF) == -1) {
 719                         perror ("setsig");
 720                         return;
 721                 }
 722                 if (fcntl (rtc_fd, F_SETOWN, getpid ()) == -1) {
 723                         perror ("setown");
 724                         return;
 725                 }
 726                 enable_rtc_timer (TRUE);
 727                 return;
 728         }
 729         if (rtc_fd >= 0)
 730                 return;
 731 #endif
 732
 733         itval.it_interval.tv_usec = (1000000 / mono_profiler_get_sampling_rate ()) - 1;
 734         itval.it_interval.tv_sec = 0;
 735         itval.it_value = itval.it_interval;
 736         if (inited)
 737                 return;
 738         inited = 1;
 739         add_signal_handler (get_itimer_signal (), sigprof_signal_handler);
 740         add_signal_handler (get_stage2_signal_handler (), sigprof_stage2_signal_handler);
 741         setitimer (get_itimer_mode (), &itval, NULL);
 742 #endif
 743 }
 744
 745 #if !defined(__APPLE__)
 746 pid_t
 747 mono_runtime_syscall_fork ()
 748 {
 749 #if defined(SYS_fork)
 750         return (pid_t) syscall (SYS_fork);
 751 #else
 752         g_assert_not_reached ();
 753         return 0;
 754 #endif
 755 }
 756
 757 void
 758 mono_gdb_render_native_backtraces (pid_t crashed_pid)
 759 {
 760         const char *argv [9];
 761         char template [] = "/tmp/mono-lldb-commands.XXXXXX";
 762         char buf1 [128];
 763         FILE *commands;
 764         gboolean using_lldb = FALSE;
 765
 766         argv [0] = g_find_program_in_path ("gdb");
 767         if (argv [0] == NULL) {
 768                 argv [0] = g_find_program_in_path ("lldb");
 769                 using_lldb = TRUE;
 770         }
 771
 772         if (argv [0] == NULL)
 773                 return;
 774
 775         if (using_lldb) {
 776                 if (mkstemp (template) == -1)
 777                         return;
 778
 779                 commands = fopen (template, "w");
 780
 781                 fprintf (commands, "process attach --pid %ld\n", (long) crashed_pid);
 782                 fprintf (commands, "thread list\n");
 783                 fprintf (commands, "thread backtrace all\n");
 784                 fprintf (commands, "detach\n");
 785                 fprintf (commands, "quit\n");
 786
 787                 fflush (commands);
 788                 fclose (commands);
 789
 790                 argv [1] = "--source";
 791                 argv [2] = template;
 792                 argv [3] = 0;
 793         } else {
 794                 argv [1] = "-ex";
 795                 sprintf (buf1, "attach %ld", (long) crashed_pid);
 796                 argv [2] = buf1;
 797                 argv [3] = "--ex";
 798                 argv [4] = "info threads";
 799                 argv [5] = "--ex";
 800                 argv [6] = "thread apply all bt";
 801                 argv [7] = "--batch";
 802                 argv [8] = 0;
 803         }
 804
 805         execv (argv [0], (char**)argv);
 806
 807         if (using_lldb)
 808                 unlink (template);
 809 }
 810 #endif
 811 #endif /* __native_client__ */
 812
 813 #if !defined (__MACH__)
 814
 815 gboolean
 816 mono_thread_state_init_from_handle (MonoThreadUnwindState *tctx, MonoThreadInfo *info)
 817 {
 818         g_error ("Posix systems don't support mono_thread_state_init_from_handle");
 819         return FALSE;
 820 }
 821
 822 #endif