// posix-threads.cc - interface between libjava and POSIX threads.
-/* Copyright (C) 1998, 1999 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2004, 2006 Free Software Foundation
This file is part of libgcj.
#include <config.h>
+#include "posix.h"
+#include "posix-threads.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 <signal.h>
#include <errno.h>
#include <limits.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h> // To test for _POSIX_THREAD_PRIORITY_SCHEDULING
+#endif
#include <gcj/cni.h>
#include <jvm.h>
#include <java/lang/System.h>
#include <java/lang/Long.h>
#include <java/lang/OutOfMemoryError.h>
+#include <java/lang/InternalError.h>
// This is used to implement thread startup.
struct starter
{
_Jv_ThreadStartFunc *method;
- java::lang::Thread *object;
_Jv_Thread_t *data;
};
static int non_daemon_count;
// The signal to use when interrupting a thread.
-#ifdef LINUX_THREADS
+#if defined(LINUX_THREADS) || defined(FREEBSD_THREADS)
// LinuxThreads (prior to glibc 2.1) usurps both SIGUSR1 and SIGUSR2.
+ // GC on FreeBSD uses both SIGUSR1 and SIGUSR2.
# define INTR SIGHUP
#else /* LINUX_THREADS */
# define INTR SIGUSR2
\f
int
+_Jv_MutexLock (_Jv_Mutex_t *mu)
+{
+ pthread_t self = pthread_self ();
+ if (mu->owner == self)
+ {
+ mu->count++;
+ }
+ else
+ {
+ JvSetThreadState holder (_Jv_ThreadCurrent(), JV_BLOCKED);
+
+# ifdef LOCK_DEBUG
+ int result = pthread_mutex_lock (&mu->mutex);
+ if (0 != result)
+ {
+ fprintf(stderr, "Pthread_mutex_lock returned %d\n", result);
+ for (;;) {}
+ }
+# else
+ pthread_mutex_lock (&mu->mutex);
+# endif
+ mu->count = 1;
+ mu->owner = self;
+ }
+ return 0;
+}
+
+// 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)
{
- if (_Jv_PthreadCheckMonitor (mu))
- return 1;
+ pthread_t self = pthread_self();
+ if (mu->owner != self)
+ return _JV_NOT_OWNER;
- int r;
- pthread_mutex_t *pmu = _Jv_PthreadGetMutex (mu);
struct timespec ts;
- jlong m, m2, startTime;
- bool done_sleeping = false;
- if (millis == 0 && nanos == 0)
+ JvThreadState new_state = JV_WAITING;
+ if (millis > 0 || nanos > 0)
{
-#ifdef LINUX_THREADS
- // pthread_cond_timedwait can be interrupted by a signal on linux, while
- // pthread_cond_wait can not. So pthread_cond_timedwait() forever.
- m = java::lang::Long::MAX_VALUE;
- ts.tv_sec = LONG_MAX;
- ts.tv_nsec = 0;
+ // Calculate the abstime corresponding to the timeout.
+ unsigned long long seconds;
+ unsigned long usec;
+
+ // For better accuracy, should use pthread_condattr_setclock
+ // and clock_gettime.
+#ifdef HAVE_GETTIMEOFDAY
+ timeval tv;
+ gettimeofday (&tv, NULL);
+ usec = tv.tv_usec;
+ seconds = tv.tv_sec;
+#else
+ unsigned long long startTime = java::lang::System::currentTimeMillis();
+ seconds = startTime / 1000;
+ /* Assume we're about half-way through this millisecond. */
+ usec = (startTime % 1000) * 1000 + 500;
#endif
+ /* These next two statements cannot overflow. */
+ usec += nanos / 1000;
+ usec += (millis % 1000) * 1000;
+ /* These two statements could overflow only if tv.tv_sec was
+ insanely large. */
+ seconds += millis / 1000;
+ seconds += usec / 1000000;
+
+ ts.tv_sec = seconds;
+ if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
+ {
+ // We treat a timeout that won't fit into a struct timespec
+ // as a wait forever.
+ millis = nanos = 0;
+ }
+ else
+ /* This next statement also cannot overflow. */
+ ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
+ }
+
+ _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;
}
+
+ // Set the thread's state.
+ JvSetThreadState holder (current_obj, new_state);
+
+ // 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)
{
- startTime = java::lang::System::currentTimeMillis();
- m = millis + startTime;
- ts.tv_sec = m / 1000;
- ts.tv_nsec = ((m % 1000) * 1000000) + nanos;
+ 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);
- java::lang::Thread *current = _Jv_ThreadCurrent();
+ // Reaquire the monitor mutex, and restore the lock count.
+ pthread_mutex_lock (&mu->mutex);
+ mu->owner = self;
+ mu->count = count;
- do
+ // If we were interrupted, or if a timeout occurred, 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)
{
- r = EINTR;
- // Check to ensure the thread hasn't already been interrupted.
- if (!(current->isInterrupted ()))
+ _Jv_Thread_t *prev = NULL;
+ for (_Jv_Thread_t *t = cv->first; t != NULL; t = t->next)
{
-#ifdef LINUX_THREADS
- // FIXME: in theory, interrupt() could be called on this thread
- // between the test above and the wait below, resulting in the
- // interupt() call failing. I don't see a way to fix this
- // without significant changes to the implementation.
- r = pthread_cond_timedwait (cv, pmu, &ts);
-#else
- if (millis == 0 && nanos == 0)
- r = pthread_cond_wait (cv, pmu);
- else
- r = pthread_cond_timedwait (cv, pmu, &ts);
-#endif
- }
-
- if (r == EINTR)
- {
- /* We were interrupted by a signal. Either this is
- because we were interrupted intentionally (i.e. by
- Thread.interrupt()) or by the GC if it is
- signal-based. */
- if (current->isInterrupted ())
+ if (t == current)
{
- r = 0;
- done_sleeping = true;
- }
- else
- {
- /* We were woken up by the GC or another signal. */
- m2 = java::lang::System::currentTimeMillis ();
- if (m2 >= m)
- {
- r = 0;
- done_sleeping = true;
- }
+ if (prev != NULL)
+ prev->next = t->next;
+ else
+ cv->first = t->next;
+ t->next = NULL;
+ break;
}
+ prev = t;
}
- else if (r == ETIMEDOUT)
- {
- /* A timeout is a normal result. */
- r = 0;
- done_sleeping = true;
+ if (interrupted)
+ return _JV_INTERRUPTED;
+ }
+
+ return 0;
+}
+
+int
+_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
+{
+ if (_Jv_MutexCheckMonitor (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
- done_sleeping = true;
+ prev->next = target->next;
+
+ target->next = NULL;
+
+ break;
}
- while (! done_sleeping);
- return r != 0;
+ return 0;
}
-#ifndef RECURSIVE_MUTEX_IS_DEFAULT
+int
+_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
+{
+ if (_Jv_MutexCheckMonitor (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_MutexInit (_Jv_Mutex_t *mu)
+_Jv_ThreadInterrupt (_Jv_Thread_t *data)
{
-#ifdef HAVE_RECURSIVE_MUTEX
- pthread_mutexattr_t *val = NULL;
-
-#if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE)
- pthread_mutexattr_t attr;
-
- // If this is slow, then allocate it statically and only initialize
- // it once.
- pthread_mutexattr_init (&attr);
- pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
- val = &attr;
-#elif defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP)
- pthread_mutexattr_t attr;
- pthread_mutexattr_init (&attr);
- pthread_mutexattr_setkind_np (&attr, PTHREAD_MUTEX_RECURSIVE_NP);
- val = &attr;
-#endif
+ pthread_mutex_lock (&data->wait_mutex);
- pthread_mutex_init (_Jv_PthreadGetMutex (mu), val);
-#ifdef PTHREAD_MUTEX_IS_STRUCT
- mu->count = 0;
-#endif
+ // 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;
-#if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE) || defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP)
- pthread_mutexattr_destroy (&attr);
-#endif
+ // Interrupt blocking system calls using a signal.
+ pthread_kill (data->thread, INTR);
+
+ pthread_cond_signal (&data->wait_cond);
+
+ pthread_mutex_unlock (&data->wait_mutex);
+}
-#else /* HAVE_RECURSIVE_MUTEX */
+/**
+ * Releases the block on a thread created by _Jv_ThreadPark(). This
+ * method can also be used to terminate a blockage caused by a prior
+ * call to park. This operation is unsafe, as the thread must be
+ * guaranteed to be live.
+ *
+ * @param thread the thread to unblock.
+ */
+void
+ParkHelper::unpark ()
+{
+ using namespace ::java::lang;
+ volatile obj_addr_t *ptr = &permit;
- // No recursive mutex, so simulate one.
- pthread_mutex_init (&mu->mutex, NULL);
- pthread_mutex_init (&mu->mutex2, NULL);
- pthread_cond_init (&mu->cond, 0);
- mu->count = 0;
+ /* If this thread is in state RUNNING, give it a permit and return
+ immediately. */
+ if (compare_and_swap
+ (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PERMIT))
+ return;
-#endif /* HAVE_RECURSIVE_MUTEX */
+ /* If this thread is parked, put it into state RUNNING and send it a
+ signal. */
+ if (compare_and_swap
+ (ptr, Thread::THREAD_PARK_PARKED, Thread::THREAD_PARK_RUNNING))
+ {
+ int result;
+ pthread_mutex_lock (&mutex);
+ result = pthread_cond_signal (&cond);
+ pthread_mutex_unlock (&mutex);
+ JvAssert (result == 0);
+ }
}
-#endif /* not RECURSIVE_MUTEX_IS_DEFAULT */
-
-#if ! defined (LINUX_THREADS) && ! defined (HAVE_RECURSIVE_MUTEX)
+/**
+ * Sets our state to dead.
+ */
+void
+ParkHelper::deactivate ()
+{
+ permit = ::java::lang::Thread::THREAD_PARK_DEAD;
+}
void
-_Jv_MutexDestroy (_Jv_Mutex_t *mu)
+ParkHelper::init ()
{
- pthread_mutex_destroy (&mu->mutex);
- pthread_mutex_destroy (&mu->mutex2);
- pthread_cond_destroy (&mu->cond);
+ pthread_mutex_init (&mutex, NULL);
+ pthread_cond_init (&cond, NULL);
+ permit = ::java::lang::Thread::THREAD_PARK_RUNNING;
}
-int
-_Jv_MutexLock (_Jv_Mutex_t *mu)
+/**
+ * Blocks the thread until a matching _Jv_ThreadUnpark() occurs, the
+ * thread is interrupted or the optional timeout expires. If an
+ * unpark call has already occurred, this also counts. A timeout
+ * value of zero is defined as no timeout. When isAbsolute is true,
+ * the timeout is in milliseconds relative to the epoch. Otherwise,
+ * the value is the number of nanoseconds which must occur before
+ * timeout. This call may also return spuriously (i.e. for no
+ * apparent reason).
+ *
+ * @param isAbsolute true if the timeout is specified in milliseconds from
+ * the epoch.
+ * @param time either the number of nanoseconds to wait, or a time in
+ * milliseconds from the epoch to wait for.
+ */
+void
+ParkHelper::park (jboolean isAbsolute, jlong time)
{
- if (pthread_mutex_lock (&mu->mutex))
- return -1;
- while (1)
+ using namespace ::java::lang;
+ volatile obj_addr_t *ptr = &permit;
+
+ /* If we have a permit, return immediately. */
+ if (compare_and_swap
+ (ptr, Thread::THREAD_PARK_PERMIT, Thread::THREAD_PARK_RUNNING))
+ return;
+
+ struct timespec ts;
+
+ if (time)
{
- if (mu->count == 0)
- {
- // Grab the lock.
- mu->thread = pthread_self ();
- mu->count = 1;
- pthread_mutex_lock (&mu->mutex2);
- break;
- }
- else if (pthread_self () == mu->thread)
+ unsigned long long seconds;
+ unsigned long usec;
+
+ if (isAbsolute)
{
- // Already have the lock.
- mu->count += 1;
- break;
+ ts.tv_sec = time / 1000;
+ ts.tv_nsec = (time % 1000) * 1000 * 1000;
}
else
{
- // Try to acquire the lock.
- pthread_cond_wait (&mu->cond, &mu->mutex);
+ // Calculate the abstime corresponding to the timeout.
+ jlong nanos = time;
+ jlong millis = 0;
+
+ // For better accuracy, should use pthread_condattr_setclock
+ // and clock_gettime.
+#ifdef HAVE_GETTIMEOFDAY
+ timeval tv;
+ gettimeofday (&tv, NULL);
+ usec = tv.tv_usec;
+ seconds = tv.tv_sec;
+#else
+ unsigned long long startTime
+ = java::lang::System::currentTimeMillis();
+ seconds = startTime / 1000;
+ /* Assume we're about half-way through this millisecond. */
+ usec = (startTime % 1000) * 1000 + 500;
+#endif
+ /* These next two statements cannot overflow. */
+ usec += nanos / 1000;
+ usec += (millis % 1000) * 1000;
+ /* These two statements could overflow only if tv.tv_sec was
+ insanely large. */
+ seconds += millis / 1000;
+ seconds += usec / 1000000;
+
+ ts.tv_sec = seconds;
+ if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
+ {
+ // We treat a timeout that won't fit into a struct timespec
+ // as a wait forever.
+ millis = nanos = 0;
+ }
+ else
+ /* This next statement also cannot overflow. */
+ ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
}
}
- pthread_mutex_unlock (&mu->mutex);
- return 0;
-}
-int
-_Jv_MutexUnlock (_Jv_Mutex_t *mu)
-{
- if (pthread_mutex_lock (&mu->mutex))
- return -1;
- int r = 0;
- if (mu->count == 0 || pthread_self () != mu->thread)
- r = -1;
- else
+ pthread_mutex_lock (&mutex);
+ if (compare_and_swap
+ (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PARKED))
{
- mu->count -= 1;
- if (! mu->count)
- {
- pthread_mutex_unlock (&mu->mutex2);
- pthread_cond_signal (&mu->cond);
- }
+ int result = 0;
+
+ if (! time)
+ result = pthread_cond_wait (&cond, &mutex);
+ else
+ result = pthread_cond_timedwait (&cond, &mutex, &ts);
+
+ JvAssert (result == 0 || result == ETIMEDOUT);
+
+ /* If we were unparked by some other thread, this will already
+ be in state THREAD_PARK_RUNNING. If we timed out or were
+ interrupted, we have to do it ourself. */
+ permit = Thread::THREAD_PARK_RUNNING;
}
- pthread_mutex_unlock (&mu->mutex);
- return r;
+ pthread_mutex_unlock (&mutex);
}
-#endif /* not LINUX_THREADS and not HAVE_RECURSIVE_MUTEX */
-
static void
handle_intr (int)
{
}
void
+_Jv_BlockSigchld()
+{
+ sigset_t mask;
+ sigemptyset (&mask);
+ sigaddset (&mask, SIGCHLD);
+ int c = pthread_sigmask (SIG_BLOCK, &mask, NULL);
+ if (c != 0)
+ JvFail (strerror (c));
+}
+
+void
+_Jv_UnBlockSigchld()
+{
+ sigset_t mask;
+ sigemptyset (&mask);
+ sigaddset (&mask, SIGCHLD);
+ int c = pthread_sigmask (SIG_UNBLOCK, &mask, NULL);
+ if (c != 0)
+ JvFail (strerror (c));
+}
+
+void
_Jv_InitThreads (void)
{
pthread_key_create (&_Jv_ThreadKey, NULL);
sigemptyset (&act.sa_mask);
act.sa_flags = 0;
sigaction (INTR, &act, NULL);
+
+ // Block SIGCHLD here to ensure that any non-Java threads inherit the new
+ // signal mask.
+ _Jv_BlockSigchld();
+
+ // Check/set the thread stack size.
+ size_t min_ss = 32 * 1024;
+
+ if (sizeof (void *) == 8)
+ // Bigger default on 64-bit systems.
+ min_ss *= 2;
+
+#ifdef PTHREAD_STACK_MIN
+ if (min_ss < PTHREAD_STACK_MIN)
+ min_ss = PTHREAD_STACK_MIN;
+#endif
+
+ if (gcj::stack_size > 0 && gcj::stack_size < min_ss)
+ gcj::stack_size = min_ss;
}
-void
-_Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *)
+_Jv_Thread_t *
+_Jv_ThreadInitData (java::lang::Thread *obj)
{
- _Jv_Thread_t *info = new _Jv_Thread_t;
- info->flags = 0;
+ _Jv_Thread_t *data = (_Jv_Thread_t *) _Jv_Malloc (sizeof (_Jv_Thread_t));
+ data->flags = 0;
+ data->thread_obj = obj;
- // FIXME register a finalizer for INFO here.
- // FIXME also must mark INFO somehow.
+ pthread_mutex_init (&data->wait_mutex, NULL);
+ pthread_cond_init (&data->wait_cond, NULL);
- *data = info;
+ return data;
+}
+
+void
+_Jv_ThreadDestroyData (_Jv_Thread_t *data)
+{
+ pthread_mutex_destroy (&data->wait_mutex);
+ pthread_cond_destroy (&data->wait_cond);
+ _Jv_Free ((void *)data);
}
void
_Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
{
+#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
if (data->flags & FLAG_START)
{
struct sched_param param;
param.sched_priority = prio;
- pthread_setschedparam (data->thread, SCHED_RR, ¶m);
+ pthread_setschedparam (data->thread, SCHED_OTHER, ¶m);
}
+#endif
+}
+
+void
+_Jv_ThreadRegister (_Jv_Thread_t *data)
+{
+ pthread_setspecific (_Jv_ThreadKey, data->thread_obj);
+ pthread_setspecific (_Jv_ThreadDataKey, 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.
+ data->thread = pthread_self ();
+
+# ifdef SLOW_PTHREAD_SELF
+ // Clear all self cache slots that might be needed by this thread.
+ int dummy;
+ int low_index = SC_INDEX(&dummy) + SC_CLEAR_MIN;
+ int high_index = SC_INDEX(&dummy) + SC_CLEAR_MAX;
+ for (int i = low_index; i <= high_index; ++i)
+ {
+ int current_index = i;
+ if (current_index < 0)
+ current_index += SELF_CACHE_SIZE;
+ if (current_index >= SELF_CACHE_SIZE)
+ current_index -= SELF_CACHE_SIZE;
+ _Jv_self_cache[current_index].high_sp_bits = BAD_HIGH_SP_VALUE;
+ }
+# endif
+ // Block SIGCHLD which is used in natPosixProcess.cc.
+ _Jv_BlockSigchld();
+}
+
+void
+_Jv_ThreadUnRegister ()
+{
+ pthread_setspecific (_Jv_ThreadKey, NULL);
+ pthread_setspecific (_Jv_ThreadDataKey, NULL);
}
// This function is called when a thread is started. We don't arrange
{
struct starter *info = (struct starter *) x;
- pthread_setspecific (_Jv_ThreadKey, info->object);
- pthread_setspecific (_Jv_ThreadDataKey, info->data);
- info->method (info->object);
+ _Jv_ThreadRegister (info->data);
+
+ info->method (info->data->thread_obj);
if (! (info->data->flags & FLAG_DAEMON))
{
return;
data->flags |= FLAG_START;
+ // Block SIGCHLD which is used in natPosixProcess.cc.
+ // The current mask is inherited by the child thread.
+ _Jv_BlockSigchld();
+
param.sched_priority = thread->getPriority();
pthread_attr_init (&attr);
pthread_attr_setschedparam (&attr, ¶m);
+ pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+
+ // Set stack size if -Xss option was given.
+ if (gcj::stack_size > 0)
+ {
+ int e = pthread_attr_setstacksize (&attr, gcj::stack_size);
+ if (e != 0)
+ JvFail (strerror (e));
+ }
- // FIXME: handle marking the info object for GC.
info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
info->method = meth;
- info->object = thread;
info->data = data;
if (! thread->isDaemon())
if (r)
{
const char* msg = "Cannot create additional threads";
- JvThrow (new java::lang::OutOfMemoryError (JvNewStringUTF (msg)));
+ throw new java::lang::OutOfMemoryError (JvNewStringUTF (msg));
}
}
pthread_mutex_unlock (&daemon_mutex);
}
-void
-_Jv_ThreadInterrupt (_Jv_Thread_t *data)
+#if defined(SLOW_PTHREAD_SELF)
+
+#include "sysdep/locks.h"
+
+// Support for pthread_self() lookup cache.
+volatile self_cache_entry _Jv_self_cache[SELF_CACHE_SIZE];
+
+_Jv_ThreadId_t
+_Jv_ThreadSelf_out_of_line(volatile self_cache_entry *sce, size_t high_sp_bits)
{
- pthread_kill (data->thread, INTR);
+ pthread_t self = pthread_self();
+ sce -> high_sp_bits = high_sp_bits;
+ write_barrier();
+ sce -> self = self;
+ return self;
}
+
+#endif /* SLOW_PTHREAD_SELF */
OSDN Git Service
