#endif
#include <mono/utils/mono-threads.h>
-#include <mono/utils/mono-threads-posix-signals.h>
#include <mono/utils/mono-coop-semaphore.h>
#include <mono/metadata/gc-internals.h>
-#include <mono/utils/w32handle.h>
+#include <mono/utils/mono-threads-debug.h>
#include <errno.h>
#include <sys/resource.h>
-#if defined(__native_client__)
-void nacl_shutdown_gc_thread(void);
-#endif
+int
+mono_threads_platform_create_thread (MonoThreadStart thread_fn, gpointer thread_data, gsize* const stack_size, MonoNativeThreadId *out_tid)
+{
+ pthread_attr_t attr;
+ pthread_t thread;
+ int policy;
+ struct sched_param param;
+ gint res;
+ gsize set_stack_size;
+ size_t min_size;
-typedef struct {
- pthread_t id;
- GPtrArray *owned_mutexes;
- gint32 priority;
-} MonoW32HandleThread;
+ res = pthread_attr_init (&attr);
+ g_assert (!res);
-static gpointer
-thread_handle_create (void)
-{
- MonoW32HandleThread thread_data;
- gpointer thread_handle;
+ if (stack_size)
+ set_stack_size = *stack_size;
+ else
+ set_stack_size = 0;
- thread_data.id = pthread_self ();
- thread_data.owned_mutexes = g_ptr_array_new ();
- thread_data.priority = MONO_THREAD_PRIORITY_NORMAL;
+#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
+ if (set_stack_size == 0) {
+#if HAVE_VALGRIND_MEMCHECK_H
+ if (RUNNING_ON_VALGRIND)
+ set_stack_size = 1 << 20;
+ else
+ set_stack_size = (SIZEOF_VOID_P / 4) * 1024 * 1024;
+#else
+ set_stack_size = (SIZEOF_VOID_P / 4) * 1024 * 1024;
+#endif
+ }
- thread_handle = mono_w32handle_new (MONO_W32HANDLE_THREAD, (gpointer) &thread_data);
- if (thread_handle == INVALID_HANDLE_VALUE)
- return NULL;
+#ifdef PTHREAD_STACK_MIN
+ if (set_stack_size < PTHREAD_STACK_MIN)
+ set_stack_size = PTHREAD_STACK_MIN;
+#endif
- /* We need to keep the handle alive, as long as the corresponding managed
- * thread object is alive. The handle is going to be unref when calling
- * the finalizer on the MonoThreadInternal object */
- mono_w32handle_ref (thread_handle);
+ res = pthread_attr_setstacksize (&attr, set_stack_size);
+ g_assert (!res);
+#endif /* HAVE_PTHREAD_ATTR_SETSTACKSIZE */
- return thread_handle;
-}
+ memset (¶m, 0, sizeof (param));
-static int
-win32_priority_to_posix_priority (MonoThreadPriority priority, int policy)
-{
- g_assert (priority >= MONO_THREAD_PRIORITY_LOWEST);
- g_assert (priority <= MONO_THREAD_PRIORITY_HIGHEST);
+ res = pthread_attr_getschedpolicy (&attr, &policy);
+ if (res != 0)
+ g_error ("%s: pthread_attr_getschedpolicy failed, error: \"%s\" (%d)", g_strerror (res), res);
-/* Necessary to get valid priority range */
#ifdef _POSIX_PRIORITY_SCHEDULING
int max, min;
+ /* Necessary to get valid priority range */
+
min = sched_get_priority_min (policy);
max = sched_get_priority_max (policy);
- /* Partition priority range linearly (cross-multiply) */
if (max > 0 && min >= 0 && max > min)
- return (int)((double) priority * (max - min) / (MONO_THREAD_PRIORITY_HIGHEST - MONO_THREAD_PRIORITY_LOWEST));
+ param.sched_priority = (max - min) / 2 + min;
+ else
#endif
-
- switch (policy) {
- case SCHED_FIFO:
- case SCHED_RR:
- return 50;
+ {
+ switch (policy) {
+ case SCHED_FIFO:
+ case SCHED_RR:
+ param.sched_priority = 50;
+ break;
#ifdef SCHED_BATCH
- case SCHED_BATCH:
+ case SCHED_BATCH:
#endif
- case SCHED_OTHER:
- return 0;
- default:
- return -1;
+ case SCHED_OTHER:
+ param.sched_priority = 0;
+ break;
+ default:
+ g_error ("%s: unknown policy %d", __func__, policy);
+ }
}
-}
-void
-mono_threads_platform_register (MonoThreadInfo *info)
-{
- g_assert (!info->handle);
- info->handle = thread_handle_create ();
-}
-
-int
-mono_threads_platform_create_thread (MonoThreadStart thread_fn, gpointer thread_data, gsize stack_size, MonoNativeThreadId *out_tid)
-{
- pthread_attr_t attr;
- pthread_t thread;
- gint res;
-
- res = pthread_attr_init (&attr);
- g_assert (!res);
+ res = pthread_attr_setschedparam (&attr, ¶m);
+ if (res != 0)
+ g_error ("%s: pthread_attr_setschedparam failed, error: \"%s\" (%d)", g_strerror (res), res);
-#ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
- if (stack_size == 0) {
-#if HAVE_VALGRIND_MEMCHECK_H
- if (RUNNING_ON_VALGRIND)
- stack_size = 1 << 20;
+ if (stack_size) {
+ res = pthread_attr_getstacksize (&attr, &min_size);
+ if (res != 0)
+ g_error ("%s: pthread_attr_getstacksize failed, error: \"%s\" (%d)", g_strerror (res), res);
else
- stack_size = (SIZEOF_VOID_P / 4) * 1024 * 1024;
-#else
- stack_size = (SIZEOF_VOID_P / 4) * 1024 * 1024;
-#endif
+ *stack_size = min_size;
}
-#ifdef PTHREAD_STACK_MIN
- if (stack_size < PTHREAD_STACK_MIN)
- stack_size = PTHREAD_STACK_MIN;
-#endif
-
- res = pthread_attr_setstacksize (&attr, stack_size);
- g_assert (!res);
-#endif /* HAVE_PTHREAD_ATTR_SETSTACKSIZE */
-
/* Actually start the thread */
res = mono_gc_pthread_create (&thread, &attr, (gpointer (*)(gpointer)) thread_fn, thread_data);
if (res)
}
void
-mono_threads_platform_exit (int exit_code)
-{
-#if defined(__native_client__)
- nacl_shutdown_gc_thread();
-#endif
-
- mono_thread_info_detach ();
-
- pthread_exit (NULL);
-}
-
-void
-mono_threads_platform_unregister (MonoThreadInfo *info)
+mono_threads_platform_exit (gsize exit_code)
{
- mono_threads_platform_set_exited (info);
+ pthread_exit ((gpointer) exit_code);
}
int
return (int)lim.rlim_max;
}
-HANDLE
-mono_threads_platform_open_thread_handle (HANDLE handle, MonoNativeThreadId tid)
-{
- mono_w32handle_ref (handle);
-
- return handle;
-}
-
-void
-mono_threads_platform_close_thread_handle (HANDLE handle)
-{
- mono_w32handle_unref (handle);
-}
-
int
mono_threads_pthread_kill (MonoThreadInfo *info, int signum)
{
#endif
}
-void
-mono_threads_platform_set_exited (MonoThreadInfo *info)
-{
- MonoW32HandleThread *thread_data;
- gpointer mutex_handle;
- int i, thr_ret;
- pid_t pid;
- pthread_t tid;
-
- g_assert (info->handle);
-
- if (mono_w32handle_issignalled (info->handle) || mono_w32handle_get_type (info->handle) == MONO_W32HANDLE_UNUSED) {
- /* We must have already deliberately finished
- * with this thread, so don't do any more now */
- return;
- }
-
- if (!mono_w32handle_lookup (info->handle, MONO_W32HANDLE_THREAD, (gpointer*) &thread_data))
- g_error ("unknown thread handle %p", info->handle);
-
- pid = wapi_getpid ();
- tid = pthread_self ();
-
- for (i = 0; i < thread_data->owned_mutexes->len; i++) {
- mutex_handle = g_ptr_array_index (thread_data->owned_mutexes, i);
- wapi_mutex_abandon (mutex_handle, pid, tid);
- mono_thread_info_disown_mutex (info, mutex_handle);
- }
-
- g_ptr_array_free (thread_data->owned_mutexes, TRUE);
-
- thr_ret = mono_w32handle_lock_handle (info->handle);
- g_assert (thr_ret == 0);
-
- mono_w32handle_set_signal_state (info->handle, TRUE, TRUE);
-
- thr_ret = mono_w32handle_unlock_handle (info->handle);
- g_assert (thr_ret == 0);
-
- /* The thread is no longer active, so unref it */
- mono_w32handle_unref (info->handle);
-
- info->handle = NULL;
-}
-
-void
-mono_threads_platform_describe (MonoThreadInfo *info, GString *text)
-{
- MonoW32HandleThread *thread_data;
- int i;
-
- g_assert (info->handle);
-
- if (!mono_w32handle_lookup (info->handle, MONO_W32HANDLE_THREAD, (gpointer*) &thread_data))
- g_error ("unknown thread handle %p", info->handle);
-
- g_string_append_printf (text, "thread handle %p state : ", info->handle);
-
- mono_thread_info_describe_interrupt_token (info, text);
-
- g_string_append_printf (text, ", owns (");
- for (i = 0; i < thread_data->owned_mutexes->len; i++)
- g_string_append_printf (text, i > 0 ? ", %p" : "%p", g_ptr_array_index (thread_data->owned_mutexes, i));
- g_string_append_printf (text, ")");
-}
-
-void
-mono_threads_platform_own_mutex (MonoThreadInfo *info, gpointer mutex_handle)
-{
- MonoW32HandleThread *thread_data;
-
- g_assert (info->handle);
-
- if (!mono_w32handle_lookup (info->handle, MONO_W32HANDLE_THREAD, (gpointer*) &thread_data))
- g_error ("unknown thread handle %p", info->handle);
-
- mono_w32handle_ref (mutex_handle);
-
- g_ptr_array_add (thread_data->owned_mutexes, mutex_handle);
-}
-
-void
-mono_threads_platform_disown_mutex (MonoThreadInfo *info, gpointer mutex_handle)
-{
- MonoW32HandleThread *thread_data;
-
- g_assert (info->handle);
-
- if (!mono_w32handle_lookup (info->handle, MONO_W32HANDLE_THREAD, (gpointer*) &thread_data))
- g_error ("unknown thread handle %p", info->handle);
-
- mono_w32handle_unref (mutex_handle);
-
- g_ptr_array_remove (thread_data->owned_mutexes, mutex_handle);
-}
-
-MonoThreadPriority
-mono_threads_platform_get_priority (MonoThreadInfo *info)
-{
- MonoW32HandleThread *thread_data;
-
- g_assert (info->handle);
-
- if (!mono_w32handle_lookup (info->handle, MONO_W32HANDLE_THREAD, (gpointer *)&thread_data))
- return MONO_THREAD_PRIORITY_NORMAL;
-
- return thread_data->priority;
-}
-
gboolean
-mono_threads_platform_set_priority (MonoThreadInfo *info, MonoThreadPriority priority)
+mono_native_thread_join (MonoNativeThreadId tid)
{
- MonoW32HandleThread *thread_data;
- int policy, posix_priority;
- struct sched_param param;
-
- g_assert (info->handle);
-
- if (!mono_w32handle_lookup (info->handle, MONO_W32HANDLE_THREAD, (gpointer*) &thread_data))
- return FALSE;
+ void *res;
- switch (pthread_getschedparam (thread_data->id, &policy, ¶m)) {
- case 0:
- break;
- case ESRCH:
- g_warning ("pthread_getschedparam: error looking up thread id %x", (gsize)thread_data->id);
- return FALSE;
- default:
- return FALSE;
- }
-
- posix_priority = win32_priority_to_posix_priority (priority, policy);
- if (posix_priority < 0)
- return FALSE;
-
- param.sched_priority = posix_priority;
- switch (pthread_setschedparam (thread_data->id, policy, ¶m)) {
- case 0:
- break;
- case ESRCH:
- g_warning ("%s: pthread_setschedprio: error looking up thread id %x", __func__, (gsize)thread_data->id);
- return FALSE;
- case ENOTSUP:
- g_warning ("%s: priority %d not supported", __func__, priority);
- return FALSE;
- case EPERM:
- g_warning ("%s: permission denied", __func__);
- return FALSE;
- default:
- return FALSE;
- }
-
- thread_data->priority = priority;
- return TRUE;
-
-}
-
-static void thread_details (gpointer data)
-{
- MonoW32HandleThread *thread = (MonoW32HandleThread*) data;
- g_print ("id: %p, owned_mutexes: %d, priority: %d",
- thread->id, thread->owned_mutexes->len, thread->priority);
-}
-
-static const gchar* thread_typename (void)
-{
- return "Thread";
-}
-
-static gsize thread_typesize (void)
-{
- return sizeof (MonoW32HandleThread);
-}
-
-static MonoW32HandleOps thread_ops = {
- NULL, /* close */
- NULL, /* signal */
- NULL, /* own */
- NULL, /* is_owned */
- NULL, /* special_wait */
- NULL, /* prewait */
- thread_details, /* details */
- thread_typename, /* typename */
- thread_typesize, /* typesize */
-};
-
-void
-mono_threads_platform_init (void)
-{
- mono_w32handle_register_ops (MONO_W32HANDLE_THREAD, &thread_ops);
-
- mono_w32handle_register_capabilities (MONO_W32HANDLE_THREAD, MONO_W32HANDLE_CAP_WAIT);
+ return !pthread_join (tid, &res);
}
#endif /* defined(_POSIX_VERSION) || defined(__native_client__) */
gboolean
mono_threads_suspend_begin_async_suspend (MonoThreadInfo *info, gboolean interrupt_kernel)
{
- int sig = interrupt_kernel ? mono_threads_posix_get_abort_signal () : mono_threads_posix_get_suspend_signal ();
+ int sig = interrupt_kernel ? mono_threads_suspend_get_abort_signal () : mono_threads_suspend_get_suspend_signal ();
if (!mono_threads_pthread_kill (info, sig)) {
mono_threads_add_to_pending_operation_set (info);
gboolean
mono_threads_suspend_begin_async_resume (MonoThreadInfo *info)
{
- mono_threads_add_to_pending_operation_set (info);
- return mono_threads_pthread_kill (info, mono_threads_posix_get_restart_signal ()) == 0;
+ int sig = mono_threads_suspend_get_restart_signal ();
+
+ if (!mono_threads_pthread_kill (info, sig)) {
+ mono_threads_add_to_pending_operation_set (info);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+void
+mono_threads_suspend_abort_syscall (MonoThreadInfo *info)
+{
+ /* We signal a thread to break it from the current syscall.
+ * This signal should not be interpreted as a suspend request. */
+ info->syscall_break_signal = TRUE;
+ if (mono_threads_pthread_kill (info, mono_threads_suspend_get_abort_signal ()) == 0) {
+ mono_threads_add_to_pending_operation_set (info);
+ }
+}
+
+gboolean
+mono_threads_suspend_needs_abort_syscall (void)
+{
+ return TRUE;
}
void
void
mono_threads_suspend_init (void)
{
- mono_threads_posix_init_signals (MONO_THREADS_POSIX_INIT_SIGNALS_SUSPEND_RESTART);
}
#endif /* defined(USE_POSIX_BACKEND) */