X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gthread%2Fgthread-posix.c;h=633dcdbe99a2777ea168e2b6ddc10b87608f58f2;hb=2107d8e3edc9e8414e1d83d45d458a3f205a53e7;hp=95bad4919e691b7a8944386a88273b7d7a27e218;hpb=a3036a5bd2119e53bd90e9daa6182e9d26538879;p=platform%2Fupstream%2Fglib.git diff --git a/gthread/gthread-posix.c b/gthread/gthread-posix.c index 95bad49..633dcdb 100644 --- a/gthread/gthread-posix.c +++ b/gthread/gthread-posix.c @@ -24,13 +24,15 @@ * Modified by the GLib Team and others 1997-2000. See the AUTHORS * file for a list of people on the GLib Team. See the ChangeLog * files for a list of changes. These files are distributed with - * GLib at ftp://ftp.gtk.org/pub/gtk/. + * GLib at ftp://ftp.gtk.org/pub/gtk/. */ -/* +/* * MT safe */ +#include "config.h" + #include #include #include @@ -45,15 +47,6 @@ #include #endif -#ifdef G_THREAD_USE_PID_SURROGATE -# include -# define PID_IN_THREAD(thread) (*(pid_t*)(((gchar*)thread)+sizeof(pthread_t))) -# define SET_PRIO(pid, prio) \ - posix_check_cmd_prio ((setpriority (PRIO_PROCESS, (pid), \ - g_thread_priority_map [prio]) == -1) ? \ - (errno == EACCES ? EPERM : errno ): 0) -#endif /* G_THREAD_USE_PID_SURROGATE */ - #define posix_check_err(err, name) G_STMT_START{ \ int error = (err); \ if (error) \ @@ -97,42 +90,66 @@ static gboolean posix_check_cmd_prio_warned = FALSE; # define pthread_key_create(a, b) pthread_keycreate (a, b) # define pthread_attr_init(a) pthread_attr_create (a) # define pthread_attr_destroy(a) pthread_attr_delete (a) -# define pthread_create(a, b, c, d) pthread_create (a, *b, c, d) +# define pthread_create(a, b, c, d) pthread_create (a, *b, c, d) # define mutexattr_default (pthread_mutexattr_default) # define condattr_default (pthread_condattr_default) #else /* neither G_THREADS_IMPL_POSIX nor G_THREADS_IMPL_DCE are defined */ # error This should not happen. Contact the GLib team. #endif -#ifdef G_THREAD_USE_PID_SURROGATE -# define PRIORITY_LOW_VALUE 15 -# define PRIORITY_NORMAL_VALUE 0 -# define PRIORITY_HIGH_VALUE -15 -# define PRIORITY_URGENT_VALUE -20 -#elif defined (POSIX_MIN_PRIORITY) && defined (POSIX_MAX_PRIORITY) +#if defined (POSIX_MIN_PRIORITY) && defined (POSIX_MAX_PRIORITY) # define HAVE_PRIORITIES 1 -# define PRIORITY_LOW_VALUE POSIX_MIN_PRIORITY -# define PRIORITY_URGENT_VALUE POSIX_MAX_PRIORITY +static gint priority_normal_value; +# ifdef __FreeBSD__ + /* FreeBSD threads use different priority values from the POSIX_ + * defines so we just set them here. The corresponding macros + * PTHREAD_MIN_PRIORITY and PTHREAD_MAX_PRIORITY are implied to be + * exported by the docs, but they aren't. + */ +# define PRIORITY_LOW_VALUE 0 +# define PRIORITY_URGENT_VALUE 31 +# else /* !__FreeBSD__ */ +# define PRIORITY_LOW_VALUE POSIX_MIN_PRIORITY +# define PRIORITY_URGENT_VALUE POSIX_MAX_PRIORITY +# endif /* !__FreeBSD__ */ +# define PRIORITY_NORMAL_VALUE priority_normal_value #endif /* POSIX_MIN_PRIORITY && POSIX_MAX_PRIORITY */ -gulong g_thread_min_stack_size = 0; +static gulong g_thread_min_stack_size = 0; #define G_MUTEX_SIZE (sizeof (pthread_mutex_t)) -#ifdef _SC_THREAD_STACK_MIN +#if defined(_SC_THREAD_STACK_MIN) || defined (HAVE_PRIORITIES) #define HAVE_G_THREAD_IMPL_INIT -static void -g_thread_impl_init() +static void +g_thread_impl_init(void) { +#ifdef _SC_THREAD_STACK_MIN g_thread_min_stack_size = MAX (sysconf (_SC_THREAD_STACK_MIN), 0); -} #endif /* _SC_THREAD_STACK_MIN */ +#ifdef HAVE_PRIORITIES +# ifdef G_THREADS_IMPL_POSIX + { + struct sched_param sched; + int policy; + posix_check_cmd (pthread_getschedparam (pthread_self(), &policy, &sched)); + priority_normal_value = sched.sched_priority; + } +# else /* G_THREADS_IMPL_DCE */ + posix_check_cmd (priority_normal_value = + pthread_getprio (*(pthread_t*)thread, + g_thread_priority_map [priority])); +# endif +#endif /* HAVE_PRIORITIES */ + +} +#endif /* _SC_THREAD_STACK_MIN || HAVE_PRIORITIES */ static GMutex * g_mutex_new_posix_impl (void) { GMutex *result = (GMutex *) g_new (pthread_mutex_t, 1); - posix_check_cmd (pthread_mutex_init ((pthread_mutex_t *) result, + posix_check_cmd (pthread_mutex_init ((pthread_mutex_t *) result, mutexattr_default)); return result; } @@ -174,7 +191,7 @@ static GCond * g_cond_new_posix_impl (void) { GCond *result = (GCond *) g_new (pthread_cond_t, 1); - posix_check_cmd (pthread_cond_init ((pthread_cond_t *) result, + posix_check_cmd (pthread_cond_init ((pthread_cond_t *) result, condattr_default)); return result; } @@ -182,7 +199,7 @@ g_cond_new_posix_impl (void) /* pthread_cond_signal, pthread_cond_broadcast and pthread_cond_wait can be taken directly, as signature and semantic are right, but without error check then!!!!, we might want to change this - therfore. */ + therefore. */ #define G_NSEC_PER_SEC 1000000000 @@ -200,25 +217,30 @@ g_cond_timed_wait_posix_impl (GCond * cond, if (!abs_time) { - g_cond_wait (cond, entered_mutex); - return TRUE; + result = pthread_cond_wait ((pthread_cond_t *)cond, + (pthread_mutex_t *) entered_mutex); + timed_out = FALSE; } + else + { + end_time.tv_sec = abs_time->tv_sec; + end_time.tv_nsec = abs_time->tv_usec * (G_NSEC_PER_SEC / G_USEC_PER_SEC); - end_time.tv_sec = abs_time->tv_sec; - end_time.tv_nsec = abs_time->tv_usec * (G_NSEC_PER_SEC / G_USEC_PER_SEC); - g_assert (end_time.tv_nsec < G_NSEC_PER_SEC); - result = pthread_cond_timedwait ((pthread_cond_t *) cond, - (pthread_mutex_t *) entered_mutex, - &end_time); + g_return_val_if_fail (end_time.tv_nsec < G_NSEC_PER_SEC, TRUE); + result = pthread_cond_timedwait ((pthread_cond_t *) cond, + (pthread_mutex_t *) entered_mutex, + &end_time); #ifdef G_THREADS_IMPL_POSIX - timed_out = (result == ETIMEDOUT); + timed_out = (result == ETIMEDOUT); #else /* G_THREADS_IMPL_DCE */ - timed_out = (result == -1) && (errno = EAGAIN); + timed_out = (result == -1) && (errno == EAGAIN); #endif + } if (!timed_out) posix_check_err (posix_error (result), "pthread_cond_timedwait"); + return !timed_out; } @@ -258,37 +280,16 @@ g_private_get_posix_impl (GPrivate * private_key) #else /* G_THREADS_IMPL_DCE */ { void* data; - posix_check_cmd (pthread_getspecific (*(pthread_key_t *) private_key, + posix_check_cmd (pthread_getspecific (*(pthread_key_t *) private_key, &data)); return data; } #endif } -#ifdef G_THREAD_USE_PID_SURROGATE -struct proxy_data -{ - GThreadFunc thread_func; - gpointer arg; - gpointer thread; - GThreadPriority priority; -}; - -static void -g_thread_create_posix_impl_proxy (struct proxy_data *data) -{ - GThreadFunc thread_func = data->thread_func; - GThreadFunc arg = data->arg; - PID_IN_THREAD (data->thread) = getpid(); - SET_PRIO (PID_IN_THREAD (data->thread), data->priority); - g_free (data); - thread_func (arg); -} -#endif /* G_THREAD_USE_PID_SURROGATE */ - static void -g_thread_create_posix_impl (GThreadFunc thread_func, - gpointer arg, +g_thread_create_posix_impl (GThreadFunc thread_func, + gpointer arg, gulong stack_size, gboolean joinable, gboolean bound, @@ -304,12 +305,14 @@ g_thread_create_posix_impl (GThreadFunc thread_func, g_return_if_fail (priority <= G_THREAD_PRIORITY_URGENT); posix_check_cmd (pthread_attr_init (&attr)); - + #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE if (stack_size) { stack_size = MAX (g_thread_min_stack_size, stack_size); - posix_check_cmd (pthread_attr_setstacksize (&attr, stack_size)); + /* No error check here, because some systems can't do it and + * we simply don't want threads to fail because of that. */ + pthread_attr_setstacksize (&attr, stack_size); } #endif /* HAVE_PTHREAD_ATTR_SETSTACKSIZE */ @@ -324,36 +327,22 @@ g_thread_create_posix_impl (GThreadFunc thread_func, posix_check_cmd (pthread_attr_setdetachstate (&attr, joinable ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED)); #endif /* G_THREADS_IMPL_POSIX */ - -#ifdef G_THREAD_USE_PID_SURROGATE - { - struct proxy_data *data = g_new (struct proxy_data, 1); - data->thread_func = thread_func; - data->arg = arg; - data->thread = thread; - data->priority = priority; - PID_IN_THREAD (thread) = 0; - ret = posix_error (pthread_create (thread, &attr, (void* (*)(void*)) - g_thread_create_posix_impl_proxy, - data)); - } -#else /* G_THREAD_USE_PID_SURROGATE */ -# ifdef HAVE_PRIORITIES -# ifdef G_THREADS_IMPL_POSIX + +#ifdef HAVE_PRIORITIES +# ifdef G_THREADS_IMPL_POSIX { struct sched_param sched; posix_check_cmd (pthread_attr_getschedparam (&attr, &sched)); sched.sched_priority = g_thread_priority_map [priority]; posix_check_cmd_prio (pthread_attr_setschedparam (&attr, &sched)); } -# else /* G_THREADS_IMPL_DCE */ - posix_check_cmd_prio +# else /* G_THREADS_IMPL_DCE */ + posix_check_cmd_prio (pthread_attr_setprio (&attr, g_thread_priority_map [priority])); -# endif /* G_THREADS_IMPL_DCE */ -# endif /* HAVE_PRIORITIES */ - ret = posix_error (pthread_create (thread, &attr, +# endif /* G_THREADS_IMPL_DCE */ +#endif /* HAVE_PRIORITIES */ + ret = posix_error (pthread_create (thread, &attr, (void* (*)(void*))thread_func, arg)); -#endif /* !G_THREAD_USE_PID_SURROGATE */ posix_check_cmd (pthread_attr_destroy (&attr)); @@ -372,7 +361,7 @@ g_thread_create_posix_impl (GThreadFunc thread_func, #endif /* G_THREADS_IMPL_DCE */ } -static void +static void g_thread_yield_posix_impl (void) { POSIX_YIELD_FUNC; @@ -380,13 +369,13 @@ g_thread_yield_posix_impl (void) static void g_thread_join_posix_impl (gpointer thread) -{ +{ gpointer ignore; posix_check_cmd (pthread_join (*(pthread_t*)thread, &ignore)); } -static void -g_thread_exit_posix_impl (void) +static void +g_thread_exit_posix_impl (void) { pthread_exit (NULL); } @@ -401,31 +390,29 @@ g_thread_set_priority_posix_impl (gpointer thread, GThreadPriority priority) { struct sched_param sched; int policy; - posix_check_cmd (pthread_getschedparam (*(pthread_t*)thread, &policy, + posix_check_cmd (pthread_getschedparam (*(pthread_t*)thread, &policy, &sched)); sched.sched_priority = g_thread_priority_map [priority]; - posix_check_cmd_prio (pthread_setschedparam (*(pthread_t*)thread, policy, + posix_check_cmd_prio (pthread_setschedparam (*(pthread_t*)thread, policy, &sched)); } # else /* G_THREADS_IMPL_DCE */ - posix_check_cmd_prio (pthread_setprio (*(pthread_t*)thread, + posix_check_cmd_prio (pthread_setprio (*(pthread_t*)thread, g_thread_priority_map [priority])); # endif -#elif defined (G_THREAD_USE_PID_SURROGATE) - /* If the addressed thread hasn't yet been able to provide it's pid, - * we ignore the request. Should be more than rare */ - if (PID_IN_THREAD (thread) != 0) - SET_PRIO (PID_IN_THREAD (thread), priority); -#endif /* G_THREAD_USE_PID_SURROGATE */ +#endif /* HAVE_PRIORITIES */ } static void g_thread_self_posix_impl (gpointer thread) { *(pthread_t*)thread = pthread_self(); -#ifdef G_THREAD_USE_PID_SURROGATE - PID_IN_THREAD (thread) = getpid(); -#endif /* G_THREAD_USE_PID_SURROGATE */ +} + +static gboolean +g_thread_equal_posix_impl (gpointer thread1, gpointer thread2) +{ + return (pthread_equal (*(pthread_t*)thread1, *(pthread_t*)thread2) != 0); } static GThreadFunctions g_thread_functions_for_glib_use_default = @@ -449,5 +436,6 @@ static GThreadFunctions g_thread_functions_for_glib_use_default = g_thread_join_posix_impl, g_thread_exit_posix_impl, g_thread_set_priority_posix_impl, - g_thread_self_posix_impl + g_thread_self_posix_impl, + g_thread_equal_posix_impl };