1999-04-07 16:42:40 +02:00
|
|
|
|
// posix-threads.cc - interface between libjava and POSIX threads.
|
|
|
|
|
|
2006-06-19 16:10:02 +02:00
|
|
|
|
/* Copyright (C) 1998, 1999, 2000, 2001, 2004, 2006 Free Software Foundation
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
#include <gc.h>
|
|
|
|
|
#endif /* HAVE_BOEHM_GC */
|
|
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <time.h>
|
|
|
|
|
#include <signal.h>
|
1999-08-25 02:46:23 +02:00
|
|
|
|
#include <errno.h>
|
1999-12-24 02:00:46 +01:00
|
|
|
|
#include <limits.h>
|
2003-03-02 02:24:40 +01:00
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
|
#include <unistd.h> // To test for _POSIX_THREAD_PRIORITY_SCHEDULING
|
|
|
|
|
#endif
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
1999-09-11 00:03:10 +02:00
|
|
|
|
#include <gcj/cni.h>
|
1999-04-07 16:42:40 +02:00
|
|
|
|
#include <jvm.h>
|
|
|
|
|
#include <java/lang/Thread.h>
|
|
|
|
|
#include <java/lang/System.h>
|
1999-12-24 02:00:46 +01:00
|
|
|
|
#include <java/lang/Long.h>
|
|
|
|
|
#include <java/lang/OutOfMemoryError.h>
|
2004-08-12 18:20:11 +02:00
|
|
|
|
#include <java/lang/InternalError.h>
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
|
1999-09-08 02:43:06 +02:00
|
|
|
|
// 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;
|
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
|
// 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.
|
2001-10-24 23:57:08 +02:00
|
|
|
|
#if defined(LINUX_THREADS) || defined(FREEBSD_THREADS)
|
1999-12-24 02:00:46 +01:00
|
|
|
|
// LinuxThreads (prior to glibc 2.1) usurps both SIGUSR1 and SIGUSR2.
|
2001-10-24 23:57:08 +02:00
|
|
|
|
// GC on FreeBSD uses both SIGUSR1 and SIGUSR2.
|
1999-04-07 16:42:40 +02:00
|
|
|
|
# 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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
// 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.
|
1999-04-07 16:42:40 +02:00
|
|
|
|
int
|
|
|
|
|
_Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
|
|
|
|
|
jlong millis, jint nanos)
|
|
|
|
|
{
|
2000-03-28 04:22:24 +02:00
|
|
|
|
pthread_t self = pthread_self();
|
|
|
|
|
if (mu->owner != self)
|
|
|
|
|
return _JV_NOT_OWNER;
|
1999-09-01 20:29:39 +02:00
|
|
|
|
|
1999-12-24 02:00:46 +01:00
|
|
|
|
struct timespec ts;
|
1999-09-01 20:29:39 +02:00
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
if (millis > 0 || nanos > 0)
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2005-11-25 17:18:17 +01:00
|
|
|
|
// Calculate the abstime corresponding to the timeout.
|
|
|
|
|
// Everything is in milliseconds.
|
|
|
|
|
//
|
|
|
|
|
// We use `unsigned long long' rather than jlong because our
|
|
|
|
|
// caller may pass up to Long.MAX_VALUE millis. This would
|
|
|
|
|
// overflow the range of a jlong when added to the current time.
|
|
|
|
|
|
|
|
|
|
unsigned long long startTime
|
|
|
|
|
= (unsigned long long)java::lang::System::currentTimeMillis();
|
|
|
|
|
unsigned long long m = (unsigned long long)millis + startTime;
|
|
|
|
|
unsigned long long seconds = m / 1000;
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
{
|
|
|
|
|
m %= 1000;
|
|
|
|
|
ts.tv_nsec = m * 1000000 + (unsigned long long)nanos;
|
|
|
|
|
}
|
1999-12-24 02:00:46 +01:00
|
|
|
|
}
|
1999-09-08 02:43:06 +02:00
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
_Jv_Thread_t *current = _Jv_ThreadCurrentData ();
|
|
|
|
|
java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
|
|
|
|
|
|
2000-09-30 12:01:04 +02:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
// Add this thread to the cv's wait set.
|
|
|
|
|
current->next = NULL;
|
1999-09-08 02:43:06 +02:00
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
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);
|
2000-12-30 13:18:39 +01:00
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
// 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;
|
|
|
|
|
}
|
|
|
|
|
|
2000-09-30 12:01:04 +02:00
|
|
|
|
// Check for an interrupt *before* releasing the wait mutex.
|
2000-03-28 04:22:24 +02:00
|
|
|
|
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;
|
|
|
|
|
|
HACKING, [...]: Fix spelling errors.
* HACKING, gnu/gcj/xlib/Pixmap.java, gnu/gcj/xlib/XException.java,
gnu/java/rmi/rmic/RMIC.java, java/awt/Window.java,
java/awt/AWTEvent.java, java/io/ByteArrayOutputStream.java,
java/io/CharConversionException.java,
java/io/PipedInputStream.java, java/io/PipedReader.java,
java/io/PrintWriter.java, java/io/WriteAbortedException.java,
java/io/natFileWin32.cc, java/lang/Class.h,
java/lang/natClassLoader.cc, java/lang/natObject.cc,
java/lang/Package.java, java/net/BindException.java,
java/net/ConnectException.java, java/net/ProtocolException.java,
java/net/SocketException.java,
java/net/UnknownServiceException.java,
java/security/cert/X509Certificate.java,
java/security/interfaces/DSAKey.java,
java/security/SecureRandom.java, java/security/SignedObject.java,
java/sql/DatabaseMetaData.java,
java/text/DecimalFormatSymbols.java,
java/util/jar/Attributes.java, java/util/jar/JarEntry.java,
java/util/jar/JarInputStream.java,
java/util/jar/JarOutputStream.java, java/util/Calendar.java,
java/util/Collections.java, java/util/GregorianCalendar.java,
java/util/HashMap.java, java/util/List.java,
java/util/Properties.java, java/util/Timer.java,
java/util/Vector.java, java/util/WeakHashMap.java,
javax/naming/NamingException.java,
testsuite/libjava.lang/Thread_Wait.java,
org/xml/sax/helpers/DefaultHandler.java,
org/xml/sax/HandlerBase.java, org/xml/sax/SAXParseException.java,
ChangeLog, acinclude.m4, aclocal.m4, posix-threads.cc: Fix
spelling errors.
* configure: Regenerate.
From-SVN: r46665
2001-10-31 01:48:17 +01:00
|
|
|
|
// If we were interrupted, or if a timeout occurred, remove ourself from
|
2000-03-28 04:22:24 +02:00
|
|
|
|
// 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)
|
1999-12-24 02:00:46 +01:00
|
|
|
|
{
|
2000-03-28 04:22:24 +02:00
|
|
|
|
if (t == current)
|
1999-09-08 02:43:06 +02:00
|
|
|
|
{
|
2000-03-28 04:22:24 +02:00
|
|
|
|
if (prev != NULL)
|
|
|
|
|
prev->next = t->next;
|
|
|
|
|
else
|
|
|
|
|
cv->first = t->next;
|
|
|
|
|
t->next = NULL;
|
|
|
|
|
break;
|
1999-09-08 02:43:06 +02:00
|
|
|
|
}
|
2000-03-28 04:22:24 +02:00
|
|
|
|
prev = t;
|
1999-09-08 02:43:06 +02:00
|
|
|
|
}
|
2000-03-28 04:22:24 +02:00
|
|
|
|
if (interrupted)
|
|
|
|
|
return _JV_INTERRUPTED;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
2000-03-28 04:22:24 +02:00
|
|
|
|
|
|
|
|
|
return 0;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
int
|
|
|
|
|
_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2003-10-21 06:46:19 +02:00
|
|
|
|
if (_Jv_MutexCheckMonitor (mu))
|
2000-03-28 04:22:24 +02:00
|
|
|
|
return _JV_NOT_OWNER;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
_Jv_Thread_t *target;
|
|
|
|
|
_Jv_Thread_t *prev = NULL;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
for (target = cv->first; target != NULL; target = target->next)
|
|
|
|
|
{
|
|
|
|
|
pthread_mutex_lock (&target->wait_mutex);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
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;
|
|
|
|
|
}
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
pthread_cond_signal (&target->wait_cond);
|
|
|
|
|
pthread_mutex_unlock (&target->wait_mutex);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2000-09-07 14:09:41 +02:00
|
|
|
|
// Two concurrent notify() calls must not be delivered to the same
|
|
|
|
|
// thread, so remove the target thread from the cv wait list now.
|
2000-03-28 04:22:24 +02:00
|
|
|
|
if (prev == NULL)
|
|
|
|
|
cv->first = target->next;
|
|
|
|
|
else
|
|
|
|
|
prev->next = target->next;
|
|
|
|
|
|
|
|
|
|
target->next = NULL;
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
return 0;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
2000-03-28 04:22:24 +02:00
|
|
|
|
_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2003-10-21 06:46:19 +02:00
|
|
|
|
if (_Jv_MutexCheckMonitor (mu))
|
2000-03-28 04:22:24 +02:00
|
|
|
|
return _JV_NOT_OWNER;
|
|
|
|
|
|
|
|
|
|
_Jv_Thread_t *target;
|
|
|
|
|
_Jv_Thread_t *prev = NULL;
|
|
|
|
|
|
|
|
|
|
for (target = cv->first; target != NULL; target = target->next)
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2000-03-28 04:22:24 +02:00
|
|
|
|
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;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
2000-03-28 04:22:24 +02:00
|
|
|
|
if (prev != NULL)
|
|
|
|
|
prev->next = NULL;
|
|
|
|
|
|
|
|
|
|
cv->first = NULL;
|
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
void
|
|
|
|
|
_Jv_ThreadInterrupt (_Jv_Thread_t *data)
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2000-03-28 04:22:24 +02:00
|
|
|
|
pthread_mutex_lock (&data->wait_mutex);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2000-03-28 04:22:24 +02:00
|
|
|
|
// 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.
|
2001-09-21 06:23:31 +02:00
|
|
|
|
pthread_kill (data->thread, INTR);
|
2000-03-28 04:22:24 +02:00
|
|
|
|
|
|
|
|
|
pthread_cond_signal (&data->wait_cond);
|
|
|
|
|
|
|
|
|
|
pthread_mutex_unlock (&data->wait_mutex);
|
|
|
|
|
}
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
handle_intr (int)
|
|
|
|
|
{
|
|
|
|
|
// Do nothing.
|
|
|
|
|
}
|
|
|
|
|
|
2005-02-16 05:16:06 +01:00
|
|
|
|
static void
|
|
|
|
|
block_sigchld()
|
|
|
|
|
{
|
|
|
|
|
sigset_t mask;
|
|
|
|
|
sigemptyset (&mask);
|
|
|
|
|
sigaddset (&mask, SIGCHLD);
|
|
|
|
|
int c = pthread_sigmask (SIG_BLOCK, &mask, NULL);
|
|
|
|
|
if (c != 0)
|
|
|
|
|
JvFail (strerror (c));
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
|
void
|
|
|
|
|
_Jv_InitThreads (void)
|
|
|
|
|
{
|
|
|
|
|
pthread_key_create (&_Jv_ThreadKey, NULL);
|
1999-09-08 02:43:06 +02:00
|
|
|
|
pthread_key_create (&_Jv_ThreadDataKey, NULL);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
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);
|
2005-02-16 05:16:06 +01:00
|
|
|
|
|
|
|
|
|
// Block SIGCHLD here to ensure that any non-Java threads inherit the new
|
|
|
|
|
// signal mask.
|
|
|
|
|
block_sigchld();
|
2005-11-17 21:25:57 +01:00
|
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
|
2006-01-04 22:11:51 +01:00
|
|
|
|
#ifdef PTHREAD_STACK_MIN
|
2005-11-17 21:25:57 +01:00
|
|
|
|
if (min_ss < PTHREAD_STACK_MIN)
|
|
|
|
|
min_ss = PTHREAD_STACK_MIN;
|
2006-01-04 22:11:51 +01:00
|
|
|
|
#endif
|
2005-11-17 21:25:57 +01:00
|
|
|
|
|
|
|
|
|
if (gcj::stack_size > 0 && gcj::stack_size < min_ss)
|
|
|
|
|
gcj::stack_size = min_ss;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
|
|
|
|
|
2000-12-30 13:18:39 +01:00
|
|
|
|
_Jv_Thread_t *
|
|
|
|
|
_Jv_ThreadInitData (java::lang::Thread *obj)
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2001-04-28 02:04:55 +02:00
|
|
|
|
_Jv_Thread_t *data = (_Jv_Thread_t *) _Jv_Malloc (sizeof (_Jv_Thread_t));
|
2000-12-30 13:18:39 +01:00
|
|
|
|
data->flags = 0;
|
|
|
|
|
data->thread_obj = obj;
|
2000-03-28 04:22:24 +02:00
|
|
|
|
|
2000-12-30 13:18:39 +01:00
|
|
|
|
pthread_mutex_init (&data->wait_mutex, NULL);
|
|
|
|
|
pthread_cond_init (&data->wait_cond, NULL);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2000-12-30 13:18:39 +01:00
|
|
|
|
return data;
|
|
|
|
|
}
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2000-12-30 13:18:39 +01:00
|
|
|
|
void
|
|
|
|
|
_Jv_ThreadDestroyData (_Jv_Thread_t *data)
|
|
|
|
|
{
|
|
|
|
|
pthread_mutex_destroy (&data->wait_mutex);
|
|
|
|
|
pthread_cond_destroy (&data->wait_cond);
|
2001-04-28 02:04:55 +02:00
|
|
|
|
_Jv_Free ((void *)data);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
|
|
|
|
|
{
|
2003-03-02 02:24:40 +01:00
|
|
|
|
#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
|
1999-04-07 16:42:40 +02:00
|
|
|
|
if (data->flags & FLAG_START)
|
|
|
|
|
{
|
|
|
|
|
struct sched_param param;
|
|
|
|
|
|
|
|
|
|
param.sched_priority = prio;
|
2005-07-08 16:04:22 +02:00
|
|
|
|
pthread_setschedparam (data->thread, SCHED_OTHER, ¶m);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
2003-03-02 02:24:40 +01:00
|
|
|
|
#endif
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
|
|
|
|
|
2001-05-22 08:47:48 +02:00
|
|
|
|
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 ();
|
2001-05-24 07:40:37 +02:00
|
|
|
|
|
|
|
|
|
# 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
|
2004-08-12 18:20:11 +02:00
|
|
|
|
// Block SIGCHLD which is used in natPosixProcess.cc.
|
|
|
|
|
block_sigchld();
|
2001-05-22 08:47:48 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_Jv_ThreadUnRegister ()
|
|
|
|
|
{
|
|
|
|
|
pthread_setspecific (_Jv_ThreadKey, NULL);
|
|
|
|
|
pthread_setspecific (_Jv_ThreadDataKey, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
|
// 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;
|
|
|
|
|
|
2001-05-22 08:47:48 +02:00
|
|
|
|
_Jv_ThreadRegister (info->data);
|
2000-03-28 04:22:24 +02:00
|
|
|
|
|
|
|
|
|
info->method (info->data->thread_obj);
|
2001-05-24 07:40:37 +02:00
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
|
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);
|
|
|
|
|
}
|
2001-05-24 07:40:37 +02:00
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
|
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;
|
|
|
|
|
|
2004-08-12 18:20:11 +02:00
|
|
|
|
// Block SIGCHLD which is used in natPosixProcess.cc.
|
|
|
|
|
// The current mask is inherited by the child thread.
|
|
|
|
|
block_sigchld();
|
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
|
param.sched_priority = thread->getPriority();
|
|
|
|
|
|
|
|
|
|
pthread_attr_init (&attr);
|
|
|
|
|
pthread_attr_setschedparam (&attr, ¶m);
|
2000-12-30 13:18:39 +01:00
|
|
|
|
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
|
2005-11-17 21:25:57 +01:00
|
|
|
|
|
|
|
|
|
// 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));
|
|
|
|
|
}
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
|
|
|
|
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;
|
1999-12-24 02:00:46 +01:00
|
|
|
|
int r = pthread_create (&data->thread, &attr, really_start, (void *) info);
|
|
|
|
|
|
1999-04-07 16:42:40 +02:00
|
|
|
|
pthread_attr_destroy (&attr);
|
1999-12-24 02:00:46 +01:00
|
|
|
|
|
|
|
|
|
if (r)
|
|
|
|
|
{
|
|
|
|
|
const char* msg = "Cannot create additional threads";
|
exception.cc (java_eh_info): Make value type jthrowable.
* exception.cc (java_eh_info): Make value type jthrowable.
(_Jv_type_matcher): Remove now unneeded cast.
(_Jv_Throw): Make argument type jthrowable. Munge name
for SJLJ_EXCEPTIONS here ...
* gcj/cni.h: ... not here.
(JvThrow): Remove.
* gcj/javaprims.h (_Jv_Throw, _Jv_Sjlj_Throw): Update declarations.
* defineclass.cc, interpret.cc, jni.cc, posix-threads.cc,
prims.cc, resolve.cc, gnu/gcj/runtime/natFirstThread.cc,
gnu/gcj/xlib/natDrawable.cc, gnu/gcj/xlib/natFont.cc,
gnu/gcj/xlib/natWMSizeHints.cc, gnu/gcj/xlib/natWindowAttributes.cc,
gnu/gcj/xlib/natXImage.cc, java/io/natFile.cc,
java/io/natFileDescriptorEcos.cc, java/io/natFileDescriptorPosix.cc,
java/io/natFileDescriptorWin32.cc, java/io/natFileWin32.cc,
java/lang/natClass.cc, java/lang/natClassLoader.cc,
java/lang/natDouble.cc, java/lang/natObject.cc,
java/lang/natPosixProcess.cc, java/lang/natRuntime.cc,
java/lang/natString.cc, java/lang/natSystem.cc,
java/lang/natThread.cc, java/lang/reflect/natArray.cc,
java/lang/reflect/natConstructor.cc, java/lang/reflect/natField.cc,
java/lang/reflect/natMethod.cc, java/util/zip/natDeflater.cc,
java/util/zip/natInflater.cc:
Use throw, not JvThrow or _Jv_Throw.
From-SVN: r40838
2001-03-26 09:05:32 +02:00
|
|
|
|
throw new java::lang::OutOfMemoryError (JvNewStringUTF (msg));
|
1999-12-24 02:00:46 +01:00
|
|
|
|
}
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
2001-05-24 07:40:37 +02:00
|
|
|
|
|
|
|
|
|
#if defined(SLOW_PTHREAD_SELF)
|
|
|
|
|
|
2002-03-10 04:53:16 +01:00
|
|
|
|
#include "sysdep/locks.h"
|
2001-05-24 07:40:37 +02:00
|
|
|
|
|
2002-03-10 04:53:16 +01:00
|
|
|
|
// Support for pthread_self() lookup cache.
|
2001-05-24 07:40:37 +02:00
|
|
|
|
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;
|
2002-03-21 01:26:46 +01:00
|
|
|
|
write_barrier();
|
|
|
|
|
sce -> self = self;
|
2001-05-24 07:40:37 +02:00
|
|
|
|
return self;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* SLOW_PTHREAD_SELF */
|