X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Futils%2Fmono-threads-posix.c;h=be440711fb3bfcbdf3be365bd25876045dfe8bf5;hb=86c24e94279f56d0426924fbb533f14d2c9b41a0;hp=1a6b06fe0452fca72d97e2eb9bff4ffd3d22698d;hpb=012e17697981de381089fd4e051c0a56d04f4076;p=mono.git diff --git a/mono/utils/mono-threads-posix.c b/mono/utils/mono-threads-posix.c index 1a6b06fe045..be440711fb3 100644 --- a/mono/utils/mono-threads-posix.c +++ b/mono/utils/mono-threads-posix.c @@ -15,10 +15,10 @@ #endif #include -#include #include #include #include +#include #include @@ -40,104 +40,106 @@ extern int tkill (pid_t tid, int signal); void nacl_shutdown_gc_thread(void); #endif -typedef struct { - pthread_t id; - GPtrArray *owned_mutexes; - gint32 priority; -} MonoW32HandleThread; - -static gpointer -thread_handle_create (void) +void +mono_threads_platform_register (MonoThreadInfo *info) { - MonoW32HandleThread thread_data; gpointer thread_handle; - thread_data.id = pthread_self (); - thread_data.owned_mutexes = g_ptr_array_new (); - thread_data.priority = MONO_THREAD_PRIORITY_NORMAL; - - thread_handle = mono_w32handle_new (MONO_W32HANDLE_THREAD, (gpointer) &thread_data); + thread_handle = mono_w32handle_new (MONO_W32HANDLE_THREAD, NULL); if (thread_handle == INVALID_HANDLE_VALUE) - return NULL; - - /* 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); - - return thread_handle; -} - -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); - -/* Necessary to get valid priority range */ -#ifdef _POSIX_PRIORITY_SCHEDULING - int max, min; - - 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)); -#endif + g_error ("%s: failed to create handle", __func__); - switch (policy) { - case SCHED_FIFO: - case SCHED_RR: - return 50; -#ifdef SCHED_BATCH - case SCHED_BATCH: -#endif - case SCHED_OTHER: - return 0; - default: - return -1; - } -} - -void -mono_threads_platform_register (MonoThreadInfo *info) -{ g_assert (!info->handle); - info->handle = thread_handle_create (); + info->handle = thread_handle; } int -mono_threads_platform_create_thread (MonoThreadStart thread_fn, gpointer thread_data, gsize stack_size, MonoNativeThreadId *out_tid) +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; res = pthread_attr_init (&attr); g_assert (!res); + if (stack_size) + set_stack_size = *stack_size; + else + set_stack_size = 0; + #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE - if (stack_size == 0) { + if (set_stack_size == 0) { #if HAVE_VALGRIND_MEMCHECK_H if (RUNNING_ON_VALGRIND) - stack_size = 1 << 20; + set_stack_size = 1 << 20; else - stack_size = (SIZEOF_VOID_P / 4) * 1024 * 1024; + set_stack_size = (SIZEOF_VOID_P / 4) * 1024 * 1024; #else - stack_size = (SIZEOF_VOID_P / 4) * 1024 * 1024; + set_stack_size = (SIZEOF_VOID_P / 4) * 1024 * 1024; #endif } #ifdef PTHREAD_STACK_MIN - if (stack_size < PTHREAD_STACK_MIN) - stack_size = PTHREAD_STACK_MIN; + if (set_stack_size < PTHREAD_STACK_MIN) + set_stack_size = PTHREAD_STACK_MIN; #endif - res = pthread_attr_setstacksize (&attr, stack_size); + res = pthread_attr_setstacksize (&attr, set_stack_size); g_assert (!res); #endif /* HAVE_PTHREAD_ATTR_SETSTACKSIZE */ + memset (¶m, 0, sizeof (param)); + + res = pthread_attr_getschedpolicy (&attr, &policy); + if (res != 0) + g_error ("%s: pthread_attr_getschedpolicy failed, error: \"%s\" (%d)", g_strerror (res), res); + +#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); + + if (max > 0 && min >= 0 && max > min) + param.sched_priority = (max - min) / 2 + min; + else +#endif + { + switch (policy) { + case SCHED_FIFO: + case SCHED_RR: + param.sched_priority = 50; + break; +#ifdef SCHED_BATCH + case SCHED_BATCH: +#endif + case SCHED_OTHER: + param.sched_priority = 0; + break; + default: + g_error ("%s: unknown policy %d", __func__, policy); + } + } + + res = pthread_attr_setschedparam (&attr, ¶m); + if (res != 0) + g_error ("%s: pthread_attr_setschedparam failed, error: \"%s\" (%d)", g_strerror (res), res); + + 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 = min_size; + } + /* Actually start the thread */ res = mono_gc_pthread_create (&thread, &attr, (gpointer (*)(gpointer)) thread_fn, thread_data); if (res) @@ -170,7 +172,11 @@ mono_threads_platform_exit (int exit_code) void mono_threads_platform_unregister (MonoThreadInfo *info) { - mono_threads_platform_set_exited (info); + g_assert (info->handle); + + /* The thread is no longer active, so unref it */ + mono_w32handle_unref (info->handle); + info->handle = NULL; } int @@ -187,6 +193,14 @@ mono_threads_get_max_stack_size (void) return (int)lim.rlim_max; } +gpointer +mono_threads_platform_duplicate_handle (MonoThreadInfo *info) +{ + g_assert (info->handle); + mono_w32handle_ref (info->handle); + return info->handle; +} + HANDLE mono_threads_platform_open_thread_handle (HANDLE handle, MonoNativeThreadId tid) { @@ -289,168 +303,32 @@ mono_native_thread_set_name (MonoNativeThreadId tid, const char *name) #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) +gboolean +mono_native_thread_join (MonoNativeThreadId tid) { - MonoW32HandleThread *thread_data; + void *res; - 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); + return !pthread_join (tid, &res); } 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) +mono_threads_platform_set_exited (gpointer handle) { - MonoW32HandleThread *thread_data; - - g_assert (info->handle); + int thr_ret; - 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) -{ - 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; - - 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; - } + g_assert (handle); + if (mono_w32handle_issignalled (handle)) + g_error ("%s: handle %p thread %p has already exited, it's handle is signalled", __func__, handle, mono_native_thread_id_get ()); + if (mono_w32handle_get_type (handle) == MONO_W32HANDLE_UNUSED) + g_error ("%s: handle %p thread %p has already exited, it's handle type is 'unused'", __func__, handle, mono_native_thread_id_get ()); - thread_data->priority = priority; - return TRUE; + thr_ret = mono_w32handle_lock_handle (handle); + g_assert (thr_ret == 0); -} + mono_w32handle_set_signal_state (handle, TRUE, 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); + thr_ret = mono_w32handle_unlock_handle (handle); + g_assert (thr_ret == 0); } static const gchar* thread_typename (void) @@ -460,7 +338,7 @@ static const gchar* thread_typename (void) static gsize thread_typesize (void) { - return sizeof (MonoW32HandleThread); + return 0; } static MonoW32HandleOps thread_ops = { @@ -470,7 +348,7 @@ static MonoW32HandleOps thread_ops = { NULL, /* is_owned */ NULL, /* special_wait */ NULL, /* prewait */ - thread_details, /* details */ + NULL, /* details */ thread_typename, /* typename */ thread_typesize, /* typesize */ }; @@ -490,7 +368,7 @@ mono_threads_platform_init (void) 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); @@ -515,7 +393,24 @@ 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; + return mono_threads_pthread_kill (info, mono_threads_suspend_get_restart_signal ()) == 0; +} + +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 @@ -534,7 +429,6 @@ mono_threads_suspend_free (MonoThreadInfo *info) void mono_threads_suspend_init (void) { - mono_threads_posix_init_signals (MONO_THREADS_POSIX_INIT_SIGNALS_SUSPEND_RESTART); } #endif /* defined(USE_POSIX_BACKEND) */