libjava/posix-threads.cc

   1 // posix-threads.cc - interface between libjava and POSIX threads.
   2
   3 /* Copyright (C) 1998, 1999  Cygnus Solutions
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 // TO DO:
  12 // * Document signal handling limitations
  13
  14 #include <config.h>
  15
  16 // If we're using the Boehm GC, then we need to override some of the
  17 // thread primitives.  This is fairly gross.
  18 #ifdef HAVE_BOEHM_GC
  19 extern "C"
  20 {
  21 #include <boehm-config.h>
  22 #include <gc.h>
  23 };
  24 #endif /* HAVE_BOEHM_GC */
  25
  26 #include <stdlib.h>
  27 #include <time.h>
  28 #include <signal.h>
  29 #include <errno.h>
  30
  31 #include <gcj/cni.h>
  32 #include <jvm.h>
  33 #include <java/lang/Thread.h>
  34 #include <java/lang/System.h>
  35
  36 // This is used to implement thread startup.
  37 struct starter
  38 {
  39   _Jv_ThreadStartFunc *method;
  40   java::lang::Thread *object;
  41   _Jv_Thread_t *data;
  42 };
  43
  44 // This is the key used to map from the POSIX thread value back to the
  45 // Java object representing the thread.  The key is global to all
  46 // threads, so it is ok to make it a global here.
  47 pthread_key_t _Jv_ThreadKey;
  48
  49 // This is the key used to map from the POSIX thread value back to the
  50 // _Jv_Thread_t* representing the thread.
  51 pthread_key_t _Jv_ThreadDataKey;
  52
  53 // We keep a count of all non-daemon threads which are running.  When
  54 // this reaches zero, _Jv_ThreadWait returns.
  55 static pthread_mutex_t daemon_mutex;
  56 static pthread_cond_t daemon_cond;
  57 static int non_daemon_count;
  58
  59 // The signal to use when interrupting a thread.
  60 #ifdef LINUX_THREADS
  61   // LinuxThreads usurps both SIGUSR1 and SIGUSR2.
  62 #  define INTR SIGHUP
  63 #else /* LINUX_THREADS */
  64 #  define INTR SIGUSR2
  65 #endif /* LINUX_THREADS */
  66
  67 //
  68 // These are the flags that can appear in _Jv_Thread_t.
  69 //
  70
  71 // Thread started.
  72 #define FLAG_START   0x01
  73 // Thread is daemon.
  74 #define FLAG_DAEMON  0x02
  75 // Thread was interrupted by _Jv_ThreadInterrupt.
  76 #define FLAG_INTERRUPTED  0x04
  77
  78 \f
  79
  80 int
  81 _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
  82               jlong millis, jint nanos)
  83 {
  84   if (_Jv_PthreadCheckMonitor (mu))
  85     return 1;
  86
  87   int r;
  88   pthread_mutex_t *pmu = _Jv_PthreadGetMutex (mu);
  89   struct timespec ts;
  90   jlong m, m2, startTime;
  91   bool done_sleeping = false;
  92
  93   if (millis == 0 && nanos == 0)
  94     r = pthread_cond_wait (cv, pmu);
  95   else
  96     {
  97       startTime = java::lang::System::currentTimeMillis();
  98       m = millis + startTime;
  99
 100       do
 101         {
 102           ts.tv_sec = m / 1000;
 103           ts.tv_nsec = ((m % 1000) * 1000000) + nanos;
 104
 105           r = pthread_cond_timedwait (cv, pmu, &ts);
 106
 107           if (r == EINTR)
 108             {
 109               /* We were interrupted by a signal.  Either this is
 110                  because we were interrupted intentionally (i.e. by
 111                  Thread.interrupt()) or by the GC if it is
 112                  signal-based.  */
 113               _Jv_Thread_t *current = _Jv_ThreadCurrentData();
 114               if (current->flags & FLAG_INTERRUPTED)
 115                 {
 116                   current->flags &= ~(FLAG_INTERRUPTED);
 117                   done_sleeping = true;
 118                 }
 119               else
 120                 {
 121                   /* We were woken up by the GC or another signal.  */
 122                   m2 = java::lang::System::currentTimeMillis ();
 123                   if (m2 >= m)
 124                     {
 125                       r = 0;
 126                       done_sleeping = true;
 127                     }
 128                 }
 129             }
 130           else if (r == ETIMEDOUT)
 131             {
 132               /* A timeout is a normal result.  */
 133               r = 0;
 134               done_sleeping = true;
 135             }
 136           else
 137             done_sleeping = true;
 138         }
 139       while (! done_sleeping);
 140     }
 141
 142   return r != 0;
 143 }
 144
 145 #ifndef RECURSIVE_MUTEX_IS_DEFAULT
 146
 147 void
 148 _Jv_MutexInit (_Jv_Mutex_t *mu)
 149 {
 150 #ifdef HAVE_RECURSIVE_MUTEX
 151   pthread_mutexattr_t *val = NULL;
 152
 153 #if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE)
 154   pthread_mutexattr_t attr;
 155
 156   // If this is slow, then allocate it statically and only initialize
 157   // it once.
 158   pthread_mutexattr_init (&attr);
 159   pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
 160   val = &attr;
 161 #elif defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP)
 162   pthread_mutexattr_t attr;
 163   pthread_mutexattr_init (&attr);
 164   pthread_mutexattr_setkind_np (&attr, PTHREAD_MUTEX_RECURSIVE_NP);
 165   val = &attr;
 166 #endif
 167
 168   pthread_mutex_init (mu, val);
 169
 170 #if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE) || defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP)
 171   pthread_mutexattr_destroy (&attr);
 172 #endif
 173
 174 #else /* HAVE_RECURSIVE_MUTEX */
 175
 176   // No recursive mutex, so simulate one.
 177   pthread_mutex_init (&mu->mutex, NULL);
 178   pthread_mutex_init (&mu->mutex2, NULL);
 179   pthread_cond_init (&mu->cond, 0);
 180   mu->count = 0;
 181
 182 #endif /* HAVE_RECURSIVE_MUTEX */
 183 }
 184
 185 #endif /* not RECURSIVE_MUTEX_IS_DEFAULT */
 186
 187 #if ! defined (LINUX_THREADS) && ! defined (HAVE_RECURSIVE_MUTEX)
 188
 189 void
 190 _Jv_MutexDestroy (_Jv_Mutex_t *mu)
 191 {
 192   pthread_mutex_destroy (&mu->mutex);
 193   pthread_mutex_destroy (&mu->mutex2);
 194   pthread_cond_destroy (&mu->cond);
 195 }
 196
 197 int
 198 _Jv_MutexLock (_Jv_Mutex_t *mu)
 199 {
 200   if (pthread_mutex_lock (&mu->mutex))
 201     return -1;
 202   while (1)
 203     {
 204       if (mu->count == 0)
 205         {
 206           // Grab the lock.
 207           mu->thread = pthread_self ();
 208           mu->count = 1;
 209           pthread_mutex_lock (&mu->mutex2);
 210           break;
 211         }
 212       else if (pthread_self () == mu->thread)
 213         {
 214           // Already have the lock.
 215           mu->count += 1;
 216           break;
 217         }
 218       else
 219         {
 220           // Try to acquire the lock.
 221           pthread_cond_wait (&mu->cond, &mu->mutex);
 222         }
 223     }
 224   pthread_mutex_unlock (&mu->mutex);
 225   return 0;
 226 }
 227
 228 int
 229 _Jv_MutexUnlock (_Jv_Mutex_t *mu)
 230 {
 231   if (pthread_mutex_lock (&mu->mutex))
 232     return -1;
 233   int r = 0;
 234   if (mu->count == 0 || pthread_self () != mu->thread)
 235     r = -1;
 236   else
 237     {
 238       mu->count -= 1;
 239       if (! mu->count)
 240         {
 241           pthread_mutex_unlock (&mu->mutex2);
 242           pthread_cond_signal (&mu->cond);
 243         }
 244     }
 245   pthread_mutex_unlock (&mu->mutex);
 246   return r;
 247 }
 248
 249 #endif /* not LINUX_THREADS and not HAVE_RECURSIVE_MUTEX */
 250
 251 static void
 252 handle_intr (int)
 253 {
 254   // Do nothing.
 255 }
 256
 257 void
 258 _Jv_InitThreads (void)
 259 {
 260   pthread_key_create (&_Jv_ThreadKey, NULL);
 261   pthread_key_create (&_Jv_ThreadDataKey, NULL);
 262   pthread_mutex_init (&daemon_mutex, NULL);
 263   pthread_cond_init (&daemon_cond, 0);
 264   non_daemon_count = 0;
 265
 266   // Arrange for the interrupt signal to interrupt system calls.
 267   struct sigaction act;
 268   act.sa_handler = handle_intr;
 269   sigemptyset (&act.sa_mask);
 270   act.sa_flags = 0;
 271   sigaction (INTR, &act, NULL);
 272
 273   // Arrange for SIGINT to be blocked to all threads.  It is only
 274   // deliverable to the master thread.
 275   sigset_t mask;
 276   sigemptyset (&mask);
 277   sigaddset (&mask, SIGINT);
 278   pthread_sigmask (SIG_BLOCK, &mask, NULL);
 279 }
 280
 281 void
 282 _Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *)
 283 {
 284   _Jv_Thread_t *info = new _Jv_Thread_t;
 285
 286   info->flags = 0;
 287   info->exception = NULL;
 288
 289   // FIXME register a finalizer for INFO here.
 290   // FIXME also must mark INFO somehow.
 291
 292   *data = info;
 293 }
 294
 295 void
 296 _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
 297 {
 298   if (data->flags & FLAG_START)
 299     {
 300       struct sched_param param;
 301
 302       param.sched_priority = prio;
 303       pthread_setschedparam (data->thread, SCHED_RR, &param);
 304     }
 305 }
 306
 307
 308 // This is called as a cleanup handler when a thread is exiting.  We
 309 // use it to throw the requested exception.  It's entirely possible
 310 // that this approach is doomed to failure, in which case we'll need
 311 // to adopt some alternate.  For instance, use a signal to implement
 312 // _Jv_ThreadCancel.
 313 static void
 314 throw_cleanup (void *data)
 315 {
 316   _Jv_Thread_t *td = (_Jv_Thread_t *) data;
 317   _Jv_Throw ((java::lang::Throwable *) td->exception);
 318 }
 319
 320 void
 321 _Jv_ThreadCancel (_Jv_Thread_t *data, void *error)
 322 {
 323   data->exception = error;
 324   pthread_cancel (data->thread);
 325 }
 326
 327 // This function is called when a thread is started.  We don't arrange
 328 // to call the `run' method directly, because this function must
 329 // return a value.
 330 static void *
 331 really_start (void *x)
 332 {
 333   struct starter *info = (struct starter *) x;
 334
 335   pthread_cleanup_push (throw_cleanup, info->data);
 336   pthread_setspecific (_Jv_ThreadKey, info->object);
 337   pthread_setspecific (_Jv_ThreadDataKey, info->data);
 338   info->method (info->object);
 339   pthread_cleanup_pop (0);
 340
 341   if (! (info->data->flags & FLAG_DAEMON))
 342     {
 343       pthread_mutex_lock (&daemon_mutex);
 344       --non_daemon_count;
 345       if (! non_daemon_count)
 346         pthread_cond_signal (&daemon_cond);
 347       pthread_mutex_unlock (&daemon_mutex);
 348     }
 349
 350   return NULL;
 351 }
 352
 353 void
 354 _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
 355                  _Jv_ThreadStartFunc *meth)
 356 {
 357   struct sched_param param;
 358   pthread_attr_t attr;
 359   struct starter *info;
 360
 361   if (data->flags & FLAG_START)
 362     return;
 363   data->flags |= FLAG_START;
 364
 365   param.sched_priority = thread->getPriority();
 366
 367   pthread_attr_init (&attr);
 368   pthread_attr_setschedparam (&attr, &param);
 369
 370   // FIXME: handle marking the info object for GC.
 371   info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
 372   info->method = meth;
 373   info->object = thread;
 374   info->data = data;
 375
 376   if (! thread->isDaemon())
 377     {
 378       pthread_mutex_lock (&daemon_mutex);
 379       ++non_daemon_count;
 380       pthread_mutex_unlock (&daemon_mutex);
 381     }
 382   else
 383     data->flags |= FLAG_DAEMON;
 384   pthread_create (&data->thread, &attr, really_start, (void *) info);
 385
 386   pthread_attr_destroy (&attr);
 387 }
 388
 389 void
 390 _Jv_ThreadWait (void)
 391 {
 392   // Arrange for SIGINT to be delivered to the master thread.
 393   sigset_t mask;
 394   sigemptyset (&mask);
 395   sigaddset (&mask, SIGINT);
 396   pthread_sigmask (SIG_UNBLOCK, &mask, NULL);
 397
 398   pthread_mutex_lock (&daemon_mutex);
 399   if (non_daemon_count)
 400     pthread_cond_wait (&daemon_cond, &daemon_mutex);
 401   pthread_mutex_unlock (&daemon_mutex);
 402 }
 403
 404 void
 405 _Jv_ThreadInterrupt (_Jv_Thread_t *data)
 406 {
 407   data->flags |= FLAG_INTERRUPTED;
 408   pthread_kill (data->thread, INTR);
 409 }