/* GLIB - Library of useful routines for C programming

  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

  *

  * gthread.c: posix thread system implementation

  * Copyright 1998 Sebastian Wilhelmi; University of Karlsruhe

  * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

  *

  * This library is free software; you can redistribute it and/or

  * modify it under the terms of the GNU Lesser General Public

  * License as published by the Free Software Foundation; either

  * version 2 of the License, or (at your option) any later version.

  *

  * This library is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  * Lesser General Public License for more details.

  *

  * You should have received a copy of the GNU Lesser General Public

  * License along with this library; if not, write to the

  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

  * Boston, MA 02111-1307, USA.

  */

 /*

  * 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/.

  */

 /*

  * MT safe

  */

 #include "config.h"

 #include <pthread.h>

 #include <errno.h>

 #include <stdlib.h>

 #ifdef HAVE_SYS_TIME_H

 # include <sys/time.h>

 #endif

 #ifdef HAVE_UNISTD_H

 # include <unistd.h>

 #endif

 #ifdef HAVE_SCHED_H

 #include <sched.h>

 #endif

 #define posix_check_err(err, name) G_STMT_START{			\

   int error = (err); 							\

   if (error)	 		 		 			\

     g_error ("file %s: line %d (%s): error '%s' during '%s'",		\

            __FILE__, __LINE__, G_STRFUNC,				\

            g_strerror (error), name);					\

   }G_STMT_END

 #define posix_check_cmd(cmd) posix_check_err (posix_error (cmd), #cmd)

 #ifdef G_ENABLE_DEBUG

 #if EMULATOR

 PLS(posix_check_cmd_prio_warned,gthread_posix,gboolean)

 #define posix_check_cmd_prio_warned (*FUNCTION_NAME(posix_check_cmd_prio_warned,gthread_posix)())

 #else

 static gboolean posix_check_cmd_prio_warned = FALSE;

 #endif /* EMULATOR */

 # define posix_check_cmd_prio(cmd) G_STMT_START{			\

     int err = posix_error (cmd);					\

     if (err == EPERM)		 		 			\

       { 	 			 				\

         if (!posix_check_cmd_prio_warned) 		 		\

           { 	 				 			\

             posix_check_cmd_prio_warned = TRUE;		 		\

             g_warning ("Priorities can only be changed " 		\

                         "(resp. increased) by root."); 			\

           }			 					\

       }			 						\

     else  		 						\

       posix_check_err (err, #cmd);					\

      }G_STMT_END

 #else /* G_ENABLE_DEBUG */

 # define posix_check_cmd_prio(cmd) G_STMT_START{			\

     int err = posix_error (cmd);					\

     if (err != EPERM)		 		 			\

       posix_check_err (err, #cmd);					\

      }G_STMT_END

 #endif /* G_ENABLE_DEBUG */

 #if defined(G_THREADS_IMPL_POSIX)

 # define posix_error(what) (what)

 # define mutexattr_default NULL

 # define condattr_default NULL

 #elif defined(G_THREADS_IMPL_DCE)

 # define posix_error(what) ((what) == -1 ? errno : 0)

 # 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 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

 #if defined (POSIX_MIN_PRIORITY) && defined (POSIX_MAX_PRIORITY)

 # define HAVE_PRIORITIES 1

 #if EMULATOR

 PLS(priority_normal_value,gthread_posix,gint)

 #define priority_normal_value (*FUNCTION_NAME(priority_normal_value,gthread_posix)())

 #else

 static gint priority_normal_value;

 #endif /* EMULATOR */

 # 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 */

 #if EMULATOR

 PLS(g_thread_min_stack_size ,gthread_posix,gulong)

 #define g_thread_min_stack_size  (*FUNCTION_NAME(g_thread_min_stack_size ,gthread_posix)())

 #else

 static gulong g_thread_min_stack_size = 0;

 #endif /* EMULATOR */

 #define G_MUTEX_SIZE (sizeof (pthread_mutex_t))

 #if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_MONOTONIC_CLOCK) 

 #define USE_CLOCK_GETTIME 1

 static gint posix_clock = 0;

 #endif

 #if defined(_SC_THREAD_STACK_MIN) || defined (HAVE_PRIORITIES) || defined (USE_CLOCK_GETTIME)

 #define HAVE_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 */

 #ifdef USE_CLOCK_GETTIME

  if (sysconf (_SC_MONOTONIC_CLOCK) >= 0)

    posix_clock = CLOCK_MONOTONIC;

  else

    posix_clock = CLOCK_REALTIME;

 #endif

 }

 #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,

 				       mutexattr_default));

   return result;

 }

 static void

 g_mutex_free_posix_impl (GMutex * mutex)

 {

   posix_check_cmd (pthread_mutex_destroy ((pthread_mutex_t *) mutex));

   g_free (mutex);

 }

 /* NOTE: the functions g_mutex_lock and g_mutex_unlock may not use

    functions from gmem.c and gmessages.c; */

 /* pthread_mutex_lock, pthread_mutex_unlock can be taken directly, as

    signature and semantic are right, but without error check then!!!!,

    we might want to change this therefore. */

 static gboolean

 g_mutex_trylock_posix_impl (GMutex * mutex)

 {

   int result;

   result = pthread_mutex_trylock ((pthread_mutex_t *) mutex);

 #ifdef G_THREADS_IMPL_POSIX

   if (result == EBUSY)

     return FALSE;

 #else /* G_THREADS_IMPL_DCE */

   if (result == 0)

     return FALSE;

 #endif

   posix_check_err (posix_error (result), "pthread_mutex_trylock");

   return TRUE;

 }

 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,

 				      condattr_default));

   return result;

 }

 /* 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

    therefore. */

 #define G_NSEC_PER_SEC 1000000000

 static gboolean

 g_cond_timed_wait_posix_impl (GCond * cond,

 			      GMutex * entered_mutex,

 			      GTimeVal * abs_time)

 {

   int result;

   struct timespec end_time;

   gboolean timed_out;

   g_return_val_if_fail (cond != NULL, FALSE);

   g_return_val_if_fail (entered_mutex != NULL, FALSE);

   if (!abs_time)

     {

       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);

       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);

 #else /* G_THREADS_IMPL_DCE */

       timed_out = (result == -1) && (errno == EAGAIN);

 #endif

     }

   if (!timed_out)

     posix_check_err (posix_error (result), "pthread_cond_timedwait");

   return !timed_out;

 }

 static void

 g_cond_free_posix_impl (GCond * cond)

 {

   posix_check_cmd (pthread_cond_destroy ((pthread_cond_t *) cond));

   g_free (cond);

 }

 static GPrivate *

 g_private_new_posix_impl (GDestroyNotify destructor)

 {

   GPrivate *result = (GPrivate *) g_new (pthread_key_t, 1);

   posix_check_cmd (pthread_key_create ((pthread_key_t *) result, destructor));

   return result;

 }

 /* NOTE: the functions g_private_get and g_private_set may not use

    functions from gmem.c and gmessages.c */

 static void

 g_private_set_posix_impl (GPrivate * private_key, gpointer value)

 {

   if (!private_key)

     return;

   pthread_setspecific (*(pthread_key_t *) private_key, value);

 }

 static gpointer

 g_private_get_posix_impl (GPrivate * private_key)

 {

   if (!private_key)

     return NULL;

 #ifdef G_THREADS_IMPL_POSIX

   return pthread_getspecific (*(pthread_key_t *) private_key);

 #else /* G_THREADS_IMPL_DCE */

   {

     void* data;

     posix_check_cmd (pthread_getspecific (*(pthread_key_t *) private_key,

 					  &data));

     return data;

   }

 #endif

 }

 static void

 g_thread_create_posix_impl (GThreadFunc thread_func,

 			    gpointer arg,

 			    gulong stack_size,

 			    gboolean joinable,

 			    gboolean bound,

 			    GThreadPriority priority,

 			    gpointer thread,

 			    GError **error)

 {

   pthread_attr_t attr;

   gint ret;

   g_return_if_fail (thread_func);

   g_return_if_fail (priority >= G_THREAD_PRIORITY_LOW);

   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);

       /* 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 */

 #ifdef PTHREAD_SCOPE_SYSTEM

   if (bound)

     /* 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_setscope (&attr, PTHREAD_SCOPE_SYSTEM);

 #endif /* PTHREAD_SCOPE_SYSTEM */

 #ifdef G_THREADS_IMPL_POSIX

   posix_check_cmd (pthread_attr_setdetachstate (&attr,

           joinable ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED));

 #endif /* 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

     (pthread_attr_setprio (&attr, g_thread_priority_map [priority]));

 # endif /* G_THREADS_IMPL_DCE */

 #endif /* HAVE_PRIORITIES */

   ret = posix_error (pthread_create (thread, &attr,

 				     (void* (*)(void*))thread_func, arg));

   posix_check_cmd (pthread_attr_destroy (&attr));

   if (ret == EAGAIN)

     {

       g_set_error (error, G_THREAD_ERROR, G_THREAD_ERROR_AGAIN, 

 		   "Error creating thread: %s", g_strerror (ret));

       return;

     }

   posix_check_err (ret, "pthread_create");

 #ifdef G_THREADS_IMPL_DCE

   if (!joinable)

     posix_check_cmd (pthread_detach (thread));

 #endif /* G_THREADS_IMPL_DCE */

 }

 static void

 g_thread_yield_posix_impl (void)

 {

   POSIX_YIELD_FUNC;

 }

 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)

 {

   pthread_exit (NULL);

 }

 static void

 g_thread_set_priority_posix_impl (gpointer thread, GThreadPriority priority)

 {

   g_return_if_fail (priority >= G_THREAD_PRIORITY_LOW);

   g_return_if_fail (priority <= G_THREAD_PRIORITY_URGENT);

 #ifdef HAVE_PRIORITIES

 # ifdef G_THREADS_IMPL_POSIX

   {

     struct sched_param sched;

     int 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,

 						 &sched));

   }

 # else /* G_THREADS_IMPL_DCE */

   posix_check_cmd_prio (pthread_setprio (*(pthread_t*)thread,

 					 g_thread_priority_map [priority]));

 # endif

 #endif /* HAVE_PRIORITIES */

 }

 static void

 g_thread_self_posix_impl (gpointer thread)

 {

   *(pthread_t*)thread = pthread_self();

 }

 static gboolean

 g_thread_equal_posix_impl (gpointer thread1, gpointer thread2)

 {

   return (pthread_equal (*(pthread_t*)thread1, *(pthread_t*)thread2) != 0);

 }

 #ifdef USE_CLOCK_GETTIME 

 static guint64

 gettime (void)

 {

   struct timespec tv;

   clock_gettime (posix_clock, &tv);

   return (guint64) tv.tv_sec * G_NSEC_PER_SEC + tv.tv_nsec;

 }

 static guint64 (*g_thread_gettime_impl)(void) = gettime;

 #else

 static guint64 (*g_thread_gettime_impl)(void) = 0;

 #endif

 #if EMULATOR

 PLS(g_thread_functions_for_glib_use_default ,gthread_posix,GThreadFunctions)

 #define g_thread_functions_for_glib_use_default   (*FUNCTION_NAME(g_thread_functions_for_glib_use_default ,gthread_posix)())

 #else

 static GThreadFunctions g_thread_functions_for_glib_use_default =

 {

   NULL,//g_mutex_new_posix_impl,

   NULL,//(void (*)(GMutex *)) pthread_mutex_lock,

   NULL,//g_mutex_trylock_posix_impl,

   NULL,//(void (*)(GMutex *)) pthread_mutex_unlock,

   NULL,//g_mutex_free_posix_impl,

   NULL,//g_cond_new_posix_impl,

   NULL,//(void (*)(GCond *)) pthread_cond_signal,

   NULL,//(void (*)(GCond *)) pthread_cond_broadcast,

   NULL,//(void (*)(GCond *, GMutex *)) pthread_cond_wait,

   NULL,//g_cond_timed_wait_posix_impl,

   NULL,//g_cond_free_posix_impl,

   NULL,//g_private_new_posix_impl,

   NULL,//g_private_get_posix_impl,

   NULL,//g_private_set_posix_impl,

   NULL,//g_thread_create_posix_impl,

   NULL,//g_thread_yield_posix_impl,

   NULL,//g_thread_join_posix_impl,

   NULL,//g_thread_exit_posix_impl,

   NULL,//g_thread_set_priority_posix_impl,

   NULL,//g_thread_self_posix_impl,

   NULL,//g_thread_equal_posix_impl

 };

 #endif//EMULATOR

 #ifdef __SYMBIAN32__

 const GThreadFunctions g_thread_functions_for_glib_use_default_temp =

 {

   g_mutex_new_posix_impl,

   (void (*)(GMutex *)) pthread_mutex_lock,

   g_mutex_trylock_posix_impl,

   (void (*)(GMutex *)) pthread_mutex_unlock,

   g_mutex_free_posix_impl,

   g_cond_new_posix_impl,

   (void (*)(GCond *)) pthread_cond_signal,

   (void (*)(GCond *)) pthread_cond_broadcast,

   (void (*)(GCond *, GMutex *)) pthread_cond_wait,

   g_cond_timed_wait_posix_impl,

   g_cond_free_posix_impl,

   g_private_new_posix_impl,

   g_private_get_posix_impl,

   g_private_set_posix_impl,

   g_thread_create_posix_impl,

   g_thread_yield_posix_impl,

   g_thread_join_posix_impl,

   g_thread_exit_posix_impl,

   g_thread_set_priority_posix_impl,

   g_thread_self_posix_impl,

   g_thread_equal_posix_impl

 };

 #endif//__SYMBIAN32__