733 lines
18 KiB
C++
733 lines
18 KiB
C++
// posix-threads.cc - interface between libjava and POSIX threads.
|
||
|
||
/* Copyright (C) 1998, 1999, 2000, 2001, 2004, 2006 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>
|
||
|
||
#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
|
||
#include <gc.h>
|
||
#endif /* HAVE_BOEHM_GC */
|
||
|
||
#include <stdlib.h>
|
||
#include <time.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/Thread.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;
|
||
_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.
|
||
#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
|
||
#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
|
||
|
||
|
||
|
||
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)
|
||
{
|
||
pthread_t self = pthread_self();
|
||
if (mu->owner != self)
|
||
return _JV_NOT_OWNER;
|
||
|
||
struct timespec ts;
|
||
|
||
JvThreadState new_state = JV_WAITING;
|
||
if (millis > 0 || nanos > 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)
|
||
{
|
||
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 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)
|
||
{
|
||
_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_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
|
||
prev->next = target->next;
|
||
|
||
target->next = NULL;
|
||
|
||
break;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
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_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);
|
||
}
|
||
|
||
/**
|
||
* 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;
|
||
|
||
/* 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;
|
||
|
||
/* 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);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Sets our state to dead.
|
||
*/
|
||
void
|
||
ParkHelper::deactivate ()
|
||
{
|
||
permit = ::java::lang::Thread::THREAD_PARK_DEAD;
|
||
}
|
||
|
||
void
|
||
ParkHelper::init ()
|
||
{
|
||
pthread_mutex_init (&mutex, NULL);
|
||
pthread_cond_init (&cond, NULL);
|
||
permit = ::java::lang::Thread::THREAD_PARK_RUNNING;
|
||
}
|
||
|
||
/**
|
||
* 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)
|
||
{
|
||
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)
|
||
{
|
||
unsigned long long seconds;
|
||
unsigned long usec;
|
||
|
||
if (isAbsolute)
|
||
{
|
||
ts.tv_sec = time / 1000;
|
||
ts.tv_nsec = (time % 1000) * 1000 * 1000;
|
||
}
|
||
else
|
||
{
|
||
// 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_lock (&mutex);
|
||
if (compare_and_swap
|
||
(ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PARKED))
|
||
{
|
||
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 (&mutex);
|
||
}
|
||
|
||
static void
|
||
handle_intr (int)
|
||
{
|
||
// Do nothing.
|
||
}
|
||
|
||
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);
|
||
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);
|
||
|
||
// 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;
|
||
}
|
||
|
||
_Jv_Thread_t *
|
||
_Jv_ThreadInitData (java::lang::Thread *obj)
|
||
{
|
||
_Jv_Thread_t *data = (_Jv_Thread_t *) _Jv_Malloc (sizeof (_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);
|
||
_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_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
|
||
// 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;
|
||
|
||
_Jv_ThreadRegister (info->data);
|
||
|
||
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;
|
||
|
||
// 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));
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
#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_t self = pthread_self();
|
||
sce -> high_sp_bits = high_sp_bits;
|
||
write_barrier();
|
||
sce -> self = self;
|
||
return self;
|
||
}
|
||
|
||
#endif /* SLOW_PTHREAD_SELF */
|