413 lines
10 KiB
C++
413 lines
10 KiB
C++
// posix-threads.cc - interface between libjava and POSIX threads.
|
||
|
||
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
|
||
|
||
This file is part of libgcj.
|
||
|
||
This software is copyrighted work licensed under the terms of the
|
||
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
||
details. */
|
||
|
||
// TO DO:
|
||
// * Document signal handling limitations
|
||
|
||
#include <config.h>
|
||
|
||
// If we're using the Boehm GC, then we need to override some of the
|
||
// thread primitives. This is fairly gross.
|
||
#ifdef HAVE_BOEHM_GC
|
||
extern "C"
|
||
{
|
||
#include <gcconfig.h>
|
||
#include <gc.h>
|
||
};
|
||
#endif /* HAVE_BOEHM_GC */
|
||
|
||
#include <stdlib.h>
|
||
#include <time.h>
|
||
#include <signal.h>
|
||
#include <errno.h>
|
||
#include <limits.h>
|
||
|
||
#include <gcj/cni.h>
|
||
#include <jvm.h>
|
||
#include <java/lang/Thread.h>
|
||
#include <java/lang/System.h>
|
||
#include <java/lang/Long.h>
|
||
#include <java/lang/OutOfMemoryError.h>
|
||
|
||
// This is used to implement thread startup.
|
||
struct starter
|
||
{
|
||
_Jv_ThreadStartFunc *method;
|
||
_Jv_Thread_t *data;
|
||
};
|
||
|
||
// This is the key used to map from the POSIX thread value back to the
|
||
// Java object representing the thread. The key is global to all
|
||
// threads, so it is ok to make it a global here.
|
||
pthread_key_t _Jv_ThreadKey;
|
||
|
||
// This is the key used to map from the POSIX thread value back to the
|
||
// _Jv_Thread_t* representing the thread.
|
||
pthread_key_t _Jv_ThreadDataKey;
|
||
|
||
// We keep a count of all non-daemon threads which are running. When
|
||
// this reaches zero, _Jv_ThreadWait returns.
|
||
static pthread_mutex_t daemon_mutex;
|
||
static pthread_cond_t daemon_cond;
|
||
static int non_daemon_count;
|
||
|
||
// The signal to use when interrupting a thread.
|
||
#ifdef LINUX_THREADS
|
||
// LinuxThreads (prior to glibc 2.1) usurps both SIGUSR1 and SIGUSR2.
|
||
# define INTR SIGHUP
|
||
#else /* LINUX_THREADS */
|
||
# define INTR SIGUSR2
|
||
#endif /* LINUX_THREADS */
|
||
|
||
//
|
||
// These are the flags that can appear in _Jv_Thread_t.
|
||
//
|
||
|
||
// Thread started.
|
||
#define FLAG_START 0x01
|
||
// Thread is daemon.
|
||
#define FLAG_DAEMON 0x02
|
||
|
||
|
||
|
||
// Wait for the condition variable "CV" to be notified.
|
||
// Return values:
|
||
// 0: the condition was notified, or the timeout expired.
|
||
// _JV_NOT_OWNER: the thread does not own the mutex "MU".
|
||
// _JV_INTERRUPTED: the thread was interrupted. Its interrupted flag is set.
|
||
int
|
||
_Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
|
||
jlong millis, jint nanos)
|
||
{
|
||
pthread_t self = pthread_self();
|
||
if (mu->owner != self)
|
||
return _JV_NOT_OWNER;
|
||
|
||
struct timespec ts;
|
||
jlong m, startTime;
|
||
|
||
if (millis > 0 || nanos > 0)
|
||
{
|
||
startTime = java::lang::System::currentTimeMillis();
|
||
m = millis + startTime;
|
||
ts.tv_sec = m / 1000;
|
||
ts.tv_nsec = ((m % 1000) * 1000000) + nanos;
|
||
}
|
||
|
||
_Jv_Thread_t *current = _Jv_ThreadCurrentData ();
|
||
java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
|
||
|
||
pthread_mutex_lock (¤t->wait_mutex);
|
||
|
||
// Now that we hold the wait mutex, check if this thread has been
|
||
// interrupted already.
|
||
if (current_obj->interrupt_flag)
|
||
{
|
||
pthread_mutex_unlock (¤t->wait_mutex);
|
||
return _JV_INTERRUPTED;
|
||
}
|
||
|
||
// Add this thread to the cv's wait set.
|
||
current->next = NULL;
|
||
|
||
if (cv->first == NULL)
|
||
cv->first = current;
|
||
else
|
||
for (_Jv_Thread_t *t = cv->first;; t = t->next)
|
||
{
|
||
if (t->next == NULL)
|
||
{
|
||
t->next = current;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Record the current lock depth, so it can be restored when we re-aquire it.
|
||
int count = mu->count;
|
||
|
||
// Release the monitor mutex.
|
||
mu->count = 0;
|
||
mu->owner = 0;
|
||
pthread_mutex_unlock (&mu->mutex);
|
||
|
||
int r = 0;
|
||
bool done_sleeping = false;
|
||
|
||
while (! done_sleeping)
|
||
{
|
||
if (millis == 0 && nanos == 0)
|
||
r = pthread_cond_wait (¤t->wait_cond, ¤t->wait_mutex);
|
||
else
|
||
r = pthread_cond_timedwait (¤t->wait_cond, ¤t->wait_mutex,
|
||
&ts);
|
||
|
||
// In older glibc's (prior to 2.1.3), the cond_wait functions may
|
||
// spuriously wake up on a signal. Catch that here.
|
||
if (r != EINTR)
|
||
done_sleeping = true;
|
||
}
|
||
|
||
// Check for an interrupt *before* releasing the wait mutex.
|
||
jboolean interrupted = current_obj->interrupt_flag;
|
||
|
||
pthread_mutex_unlock (¤t->wait_mutex);
|
||
|
||
// Reaquire the monitor mutex, and restore the lock count.
|
||
pthread_mutex_lock (&mu->mutex);
|
||
mu->owner = self;
|
||
mu->count = count;
|
||
|
||
// If we were interrupted, or if a timeout occured, remove ourself from
|
||
// the cv wait list now. (If we were notified normally, notify() will have
|
||
// already taken care of this)
|
||
if (r == ETIMEDOUT || interrupted)
|
||
{
|
||
_Jv_Thread_t *prev = NULL;
|
||
for (_Jv_Thread_t *t = cv->first; t != NULL; t = t->next)
|
||
{
|
||
if (t == current)
|
||
{
|
||
if (prev != NULL)
|
||
prev->next = t->next;
|
||
else
|
||
cv->first = t->next;
|
||
t->next = NULL;
|
||
break;
|
||
}
|
||
prev = t;
|
||
}
|
||
if (interrupted)
|
||
return _JV_INTERRUPTED;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
|
||
{
|
||
if (_Jv_PthreadCheckMonitor (mu))
|
||
return _JV_NOT_OWNER;
|
||
|
||
_Jv_Thread_t *target;
|
||
_Jv_Thread_t *prev = NULL;
|
||
|
||
for (target = cv->first; target != NULL; target = target->next)
|
||
{
|
||
pthread_mutex_lock (&target->wait_mutex);
|
||
|
||
if (target->thread_obj->interrupt_flag)
|
||
{
|
||
// Don't notify a thread that has already been interrupted.
|
||
pthread_mutex_unlock (&target->wait_mutex);
|
||
prev = target;
|
||
continue;
|
||
}
|
||
|
||
pthread_cond_signal (&target->wait_cond);
|
||
pthread_mutex_unlock (&target->wait_mutex);
|
||
|
||
// Two concurrent notify() calls must not be delivered to the same
|
||
// thread, so remove the target thread from the cv wait list now.
|
||
if (prev == NULL)
|
||
cv->first = target->next;
|
||
else
|
||
prev->next = target->next;
|
||
|
||
target->next = NULL;
|
||
|
||
break;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
|
||
{
|
||
if (_Jv_PthreadCheckMonitor (mu))
|
||
return _JV_NOT_OWNER;
|
||
|
||
_Jv_Thread_t *target;
|
||
_Jv_Thread_t *prev = NULL;
|
||
|
||
for (target = cv->first; target != NULL; target = target->next)
|
||
{
|
||
pthread_mutex_lock (&target->wait_mutex);
|
||
pthread_cond_signal (&target->wait_cond);
|
||
pthread_mutex_unlock (&target->wait_mutex);
|
||
|
||
if (prev != NULL)
|
||
prev->next = NULL;
|
||
prev = target;
|
||
}
|
||
if (prev != NULL)
|
||
prev->next = NULL;
|
||
|
||
cv->first = NULL;
|
||
|
||
return 0;
|
||
}
|
||
|
||
void
|
||
_Jv_ThreadInterrupt (_Jv_Thread_t *data)
|
||
{
|
||
pthread_mutex_lock (&data->wait_mutex);
|
||
|
||
// Set the thread's interrupted flag *after* aquiring its wait_mutex. This
|
||
// ensures that there are no races with the interrupt flag being set after
|
||
// the waiting thread checks it and before pthread_cond_wait is entered.
|
||
data->thread_obj->interrupt_flag = true;
|
||
|
||
// Interrupt blocking system calls using a signal.
|
||
// pthread_kill (data->thread, INTR);
|
||
|
||
pthread_cond_signal (&data->wait_cond);
|
||
|
||
pthread_mutex_unlock (&data->wait_mutex);
|
||
}
|
||
|
||
static void
|
||
handle_intr (int)
|
||
{
|
||
// Do nothing.
|
||
}
|
||
|
||
void
|
||
_Jv_InitThreads (void)
|
||
{
|
||
pthread_key_create (&_Jv_ThreadKey, NULL);
|
||
pthread_key_create (&_Jv_ThreadDataKey, NULL);
|
||
pthread_mutex_init (&daemon_mutex, NULL);
|
||
pthread_cond_init (&daemon_cond, 0);
|
||
non_daemon_count = 0;
|
||
|
||
// Arrange for the interrupt signal to interrupt system calls.
|
||
struct sigaction act;
|
||
act.sa_handler = handle_intr;
|
||
sigemptyset (&act.sa_mask);
|
||
act.sa_flags = 0;
|
||
sigaction (INTR, &act, NULL);
|
||
}
|
||
|
||
_Jv_Thread_t *
|
||
_Jv_ThreadInitData (java::lang::Thread *obj)
|
||
{
|
||
_Jv_Thread_t *data = new _Jv_Thread_t;
|
||
data->flags = 0;
|
||
data->thread_obj = obj;
|
||
|
||
pthread_mutex_init (&data->wait_mutex, NULL);
|
||
pthread_cond_init (&data->wait_cond, NULL);
|
||
|
||
return data;
|
||
}
|
||
|
||
void
|
||
_Jv_ThreadDestroyData (_Jv_Thread_t *data)
|
||
{
|
||
pthread_mutex_destroy (&data->wait_mutex);
|
||
pthread_cond_destroy (&data->wait_cond);
|
||
delete data;
|
||
}
|
||
|
||
void
|
||
_Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
|
||
{
|
||
if (data->flags & FLAG_START)
|
||
{
|
||
struct sched_param param;
|
||
|
||
param.sched_priority = prio;
|
||
pthread_setschedparam (data->thread, SCHED_RR, ¶m);
|
||
}
|
||
}
|
||
|
||
// This function is called when a thread is started. We don't arrange
|
||
// to call the `run' method directly, because this function must
|
||
// return a value.
|
||
static void *
|
||
really_start (void *x)
|
||
{
|
||
struct starter *info = (struct starter *) x;
|
||
|
||
pthread_setspecific (_Jv_ThreadKey, info->data->thread_obj);
|
||
pthread_setspecific (_Jv_ThreadDataKey, info->data);
|
||
|
||
// glibc 2.1.3 doesn't set the value of `thread' until after start_routine
|
||
// is called. Since it may need to be accessed from the new thread, work
|
||
// around the potential race here by explicitly setting it again.
|
||
info->data->thread = pthread_self ();
|
||
|
||
info->method (info->data->thread_obj);
|
||
|
||
if (! (info->data->flags & FLAG_DAEMON))
|
||
{
|
||
pthread_mutex_lock (&daemon_mutex);
|
||
--non_daemon_count;
|
||
if (! non_daemon_count)
|
||
pthread_cond_signal (&daemon_cond);
|
||
pthread_mutex_unlock (&daemon_mutex);
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
void
|
||
_Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
|
||
_Jv_ThreadStartFunc *meth)
|
||
{
|
||
struct sched_param param;
|
||
pthread_attr_t attr;
|
||
struct starter *info;
|
||
|
||
if (data->flags & FLAG_START)
|
||
return;
|
||
data->flags |= FLAG_START;
|
||
|
||
param.sched_priority = thread->getPriority();
|
||
|
||
pthread_attr_init (&attr);
|
||
pthread_attr_setschedparam (&attr, ¶m);
|
||
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
|
||
|
||
// FIXME: handle marking the info object for GC.
|
||
info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
|
||
info->method = meth;
|
||
info->data = data;
|
||
|
||
if (! thread->isDaemon())
|
||
{
|
||
pthread_mutex_lock (&daemon_mutex);
|
||
++non_daemon_count;
|
||
pthread_mutex_unlock (&daemon_mutex);
|
||
}
|
||
else
|
||
data->flags |= FLAG_DAEMON;
|
||
int r = pthread_create (&data->thread, &attr, really_start, (void *) info);
|
||
|
||
pthread_attr_destroy (&attr);
|
||
|
||
if (r)
|
||
{
|
||
const char* msg = "Cannot create additional threads";
|
||
throw new java::lang::OutOfMemoryError (JvNewStringUTF (msg));
|
||
}
|
||
}
|
||
|
||
void
|
||
_Jv_ThreadWait (void)
|
||
{
|
||
pthread_mutex_lock (&daemon_mutex);
|
||
if (non_daemon_count)
|
||
pthread_cond_wait (&daemon_cond, &daemon_mutex);
|
||
pthread_mutex_unlock (&daemon_mutex);
|
||
}
|