1 // posix-threads.cc - interface between libjava and POSIX threads.
3 /* Copyright (C) 1998, 1999 Cygnus Solutions
5 This file is part of libgcj.
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
12 // * Document signal handling limitations
16 // If we're using the Boehm GC, then we need to override some of the
17 // thread primitives. This is fairly gross.
24 #endif /* HAVE_BOEHM_GC */
33 #include <java/lang/Thread.h>
34 #include <java/lang/System.h>
36 // This is used to implement thread startup.
39 _Jv_ThreadStartFunc *method;
40 java::lang::Thread *object;
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;
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;
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;
59 // The signal to use when interrupting a thread.
61 // LinuxThreads usurps both SIGUSR1 and SIGUSR2.
63 #else /* LINUX_THREADS */
65 #endif /* LINUX_THREADS */
68 // These are the flags that can appear in _Jv_Thread_t.
72 #define FLAG_START 0x01
74 #define FLAG_DAEMON 0x02
75 // Thread was interrupted by _Jv_ThreadInterrupt.
76 #define FLAG_INTERRUPTED 0x04
81 _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
82 jlong millis, jint nanos)
84 if (_Jv_PthreadCheckMonitor (mu))
88 pthread_mutex_t *pmu = _Jv_PthreadGetMutex (mu);
90 jlong m, m2, startTime;
91 bool done_sleeping = false;
93 if (millis == 0 && nanos == 0)
94 r = pthread_cond_wait (cv, pmu);
97 startTime = java::lang::System::currentTimeMillis();
98 m = millis + startTime;
102 ts.tv_sec = m / 1000;
103 ts.tv_nsec = ((m % 1000) * 1000000) + nanos;
105 r = pthread_cond_timedwait (cv, pmu, &ts);
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
113 _Jv_Thread_t *current = _Jv_ThreadCurrentData();
114 if (current->flags & FLAG_INTERRUPTED)
116 current->flags &= ~(FLAG_INTERRUPTED);
117 done_sleeping = true;
121 /* We were woken up by the GC or another signal. */
122 m2 = java::lang::System::currentTimeMillis ();
126 done_sleeping = true;
130 else if (r == ETIMEDOUT)
132 /* A timeout is a normal result. */
134 done_sleeping = true;
137 done_sleeping = true;
139 while (! done_sleeping);
145 #ifndef RECURSIVE_MUTEX_IS_DEFAULT
148 _Jv_MutexInit (_Jv_Mutex_t *mu)
150 #ifdef HAVE_RECURSIVE_MUTEX
151 pthread_mutexattr_t *val = NULL;
153 #if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE)
154 pthread_mutexattr_t attr;
156 // If this is slow, then allocate it statically and only initialize
158 pthread_mutexattr_init (&attr);
159 pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
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);
168 pthread_mutex_init (_Jv_PthreadGetMutex (mu), val);
169 #ifdef PTHREAD_MUTEX_IS_STRUCT
173 #if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE) || defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP)
174 pthread_mutexattr_destroy (&attr);
177 #else /* HAVE_RECURSIVE_MUTEX */
179 // No recursive mutex, so simulate one.
180 pthread_mutex_init (&mu->mutex, NULL);
181 pthread_mutex_init (&mu->mutex2, NULL);
182 pthread_cond_init (&mu->cond, 0);
185 #endif /* HAVE_RECURSIVE_MUTEX */
188 #endif /* not RECURSIVE_MUTEX_IS_DEFAULT */
190 #if ! defined (LINUX_THREADS) && ! defined (HAVE_RECURSIVE_MUTEX)
193 _Jv_MutexDestroy (_Jv_Mutex_t *mu)
195 pthread_mutex_destroy (&mu->mutex);
196 pthread_mutex_destroy (&mu->mutex2);
197 pthread_cond_destroy (&mu->cond);
201 _Jv_MutexLock (_Jv_Mutex_t *mu)
203 if (pthread_mutex_lock (&mu->mutex))
210 mu->thread = pthread_self ();
212 pthread_mutex_lock (&mu->mutex2);
215 else if (pthread_self () == mu->thread)
217 // Already have the lock.
223 // Try to acquire the lock.
224 pthread_cond_wait (&mu->cond, &mu->mutex);
227 pthread_mutex_unlock (&mu->mutex);
232 _Jv_MutexUnlock (_Jv_Mutex_t *mu)
234 if (pthread_mutex_lock (&mu->mutex))
237 if (mu->count == 0 || pthread_self () != mu->thread)
244 pthread_mutex_unlock (&mu->mutex2);
245 pthread_cond_signal (&mu->cond);
248 pthread_mutex_unlock (&mu->mutex);
252 #endif /* not LINUX_THREADS and not HAVE_RECURSIVE_MUTEX */
261 _Jv_InitThreads (void)
263 pthread_key_create (&_Jv_ThreadKey, NULL);
264 pthread_key_create (&_Jv_ThreadDataKey, NULL);
265 pthread_mutex_init (&daemon_mutex, NULL);
266 pthread_cond_init (&daemon_cond, 0);
267 non_daemon_count = 0;
269 // Arrange for the interrupt signal to interrupt system calls.
270 struct sigaction act;
271 act.sa_handler = handle_intr;
272 sigemptyset (&act.sa_mask);
274 sigaction (INTR, &act, NULL);
276 // Arrange for SIGINT to be blocked to all threads. It is only
277 // deliverable to the master thread.
280 sigaddset (&mask, SIGINT);
281 pthread_sigmask (SIG_BLOCK, &mask, NULL);
285 _Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *)
287 _Jv_Thread_t *info = new _Jv_Thread_t;
291 // FIXME register a finalizer for INFO here.
292 // FIXME also must mark INFO somehow.
298 _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
300 if (data->flags & FLAG_START)
302 struct sched_param param;
304 param.sched_priority = prio;
305 pthread_setschedparam (data->thread, SCHED_RR, ¶m);
309 // This function is called when a thread is started. We don't arrange
310 // to call the `run' method directly, because this function must
313 really_start (void *x)
315 struct starter *info = (struct starter *) x;
317 pthread_setspecific (_Jv_ThreadKey, info->object);
318 pthread_setspecific (_Jv_ThreadDataKey, info->data);
319 info->method (info->object);
321 if (! (info->data->flags & FLAG_DAEMON))
323 pthread_mutex_lock (&daemon_mutex);
325 if (! non_daemon_count)
326 pthread_cond_signal (&daemon_cond);
327 pthread_mutex_unlock (&daemon_mutex);
334 _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
335 _Jv_ThreadStartFunc *meth)
337 struct sched_param param;
339 struct starter *info;
341 if (data->flags & FLAG_START)
343 data->flags |= FLAG_START;
345 param.sched_priority = thread->getPriority();
347 pthread_attr_init (&attr);
348 pthread_attr_setschedparam (&attr, ¶m);
350 // FIXME: handle marking the info object for GC.
351 info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
353 info->object = thread;
356 if (! thread->isDaemon())
358 pthread_mutex_lock (&daemon_mutex);
360 pthread_mutex_unlock (&daemon_mutex);
363 data->flags |= FLAG_DAEMON;
364 pthread_create (&data->thread, &attr, really_start, (void *) info);
366 pthread_attr_destroy (&attr);
370 _Jv_ThreadWait (void)
372 // Arrange for SIGINT to be delivered to the master thread.
375 sigaddset (&mask, SIGINT);
376 pthread_sigmask (SIG_UNBLOCK, &mask, NULL);
378 pthread_mutex_lock (&daemon_mutex);
379 if (non_daemon_count)
380 pthread_cond_wait (&daemon_cond, &daemon_mutex);
381 pthread_mutex_unlock (&daemon_mutex);
385 _Jv_ThreadInterrupt (_Jv_Thread_t *data)
387 data->flags |= FLAG_INTERRUPTED;
388 pthread_kill (data->thread, INTR);