int
thread_select (int n, fd_set *rfds, fd_set *wfds, void *event, TVAL timeout)
{
thread_t *thr = current_thread;
struct timeval *ptv, tv;
char dummy;
int rc;
if (timeout == TV_INFINITE)
ptv = NULL;
else
{
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
ptv = &tv;
}
if (event)
{
thr->thr_event = event;
thr->thr_event_pipe = _ev_pipes[1];
if (rfds == NULL)
rfds = &thr->thr_rfds;
FD_SET (_ev_pipes[0], rfds);
if (_ev_pipes[0] >= n)
n = _ev_pipes[0] + 1;
Q_LOCK ();
thread_queue_to (&_waitq, thr);
Q_UNLOCK ();
}
_thread_num_wait++;
thr->thr_status = WAITEVENT;
for (;;)
{
if ((rc = select (n, rfds, wfds, NULL, ptv)) == -1)
{
switch (errno)
{
case EINTR:
continue;
default:
break;
}
thr_errno = errno;
}
else
thr_errno = 0;
break;
}
thr->thr_status = RUNNING;
_thread_num_wait--;
if (event)
{
thr->thr_event = NULL;
thr->thr_event_pipe = -1;
if (rc > 0 && FD_ISSET (_ev_pipes[0], rfds))
{
read (_ev_pipes[0], &dummy, 1);
rc = 0;
}
Q_LOCK ();
thread_queue_remove (&_waitq, thr);
Q_UNLOCK ();
}
return rc;
}
thread_t *
thread_create (
thread_init_func initial_function,
unsigned long stack_size,
void *initial_argument)
{
thread_t *thr;
int rc;
assert (_main_thread != NULL);
if (stack_size == 0)
stack_size = THREAD_STACK_SIZE;
#if (SIZEOF_VOID_P == 8)
stack_size *= 2;
#endif
#if defined (__x86_64 ) && defined (SOLARIS)
/*GK: the LDAP on that platform requires that */
stack_size *= 2;
#endif
#ifdef HPUX_ITANIUM64
stack_size += 8 * 8192;
#endif
stack_size = ((stack_size / 8192) + 1) * 8192;
#if defined (PTHREAD_STACK_MIN)
if (stack_size < PTHREAD_STACK_MIN)
{
stack_size = PTHREAD_STACK_MIN;
}
#endif
/* Any free threads with the right stack size? */
Q_LOCK ();
for (thr = (thread_t *) _deadq.thq_head.thr_next;
thr != (thread_t *) &_deadq.thq_head;
thr = (thread_t *) thr->thr_hdr.thr_next)
{
/* if (thr->thr_stack_size >= stack_size) */
break;
}
Q_UNLOCK ();
/* No free threads, create a new one */
if (thr == (thread_t *) &_deadq.thq_head)
{
#ifndef OLD_PTHREADS
size_t os_stack_size = stack_size;
#endif
thr = thread_alloc ();
thr->thr_initial_function = initial_function;
thr->thr_initial_argument = initial_argument;
thr->thr_stack_size = stack_size;
if (thr->thr_cv == NULL)
goto failed;
#ifdef HPUX_ITANIUM64
if (stack_size > PTHREAD_STACK_MIN)
{
size_t s, rses;
pthread_attr_getstacksize (&_thread_attr, &s);
pthread_attr_getrsestacksize_np (&_thread_attr, &rses);
log_error ("default rses=%d stack=%d : %m", rses,s);
}
#endif
#ifndef OLD_PTHREADS
# if defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE)
rc = pthread_attr_setstacksize (&_thread_attr, stack_size);
if (rc)
{
log_error ("Failed setting the OS thread stack size to %d : %m", stack_size);
}
# endif
#if defined(HAVE_PTHREAD_ATTR_GETSTACKSIZE)
if (0 == pthread_attr_getstacksize (&_thread_attr, &os_stack_size))
{
if (os_stack_size > 4 * 8192)
stack_size = thr->thr_stack_size = ((unsigned long) os_stack_size) - 4 * 8192;
}
#endif
#ifdef HPUX_ITANIUM64
if (stack_size > PTHREAD_STACK_MIN)
{
size_t rsestack_size = stack_size / 2;
rc = pthread_attr_setrsestacksize_np (&_thread_attr, rsestack_size);
if (rc)
{
log_error ("Failed setting the OS thread 'rse' stack size to %d (plain stack size set to %d) : %m", rsestack_size, stack_size);
}
thr->thr_stack_size /= 2;
}
#endif
rc = pthread_create ((pthread_t *) thr->thr_handle, &_thread_attr,
_thread_boot, thr);
CKRET (rc);
/* rc = pthread_detach (*(pthread_t *) thr->thr_handle); */
/* CKRET (rc); */
#else /* OLD_PTHREAD */
rc = pthread_attr_setstacksize (&_thread_attr, stack_size);
CKRET (rc);
rc = pthread_create ((pthread_t *) thr->thr_handle, _thread_attr,
_thread_boot, thr);
CKRET (rc);
/* rc = pthread_detach ((pthread_t *) thr->thr_handle); */
/* CKRET (rc); */
#endif
_thread_num_total++;
#if 0
if (DO_LOG(LOG_THR))
log_info ("THRD_0 OS threads create (%i)", _thread_num_total);
#endif
thread_set_priority (thr, NORMAL_PRIORITY);
}
else
{
Q_LOCK ();
thread_queue_remove (&_deadq, thr);
_thread_num_dead--;
Q_UNLOCK ();
assert (thr->thr_status == DEAD);
/* Set new context for the thread and resume it */
thr->thr_initial_function = initial_function;
thr->thr_initial_argument = initial_argument;
thr->thr_status = RUNNABLE;
rc = pthread_cond_signal ((pthread_cond_t *) thr->thr_cv);
CKRET (rc);
/* if (DO_LOG(LOG_THR))
log_info ("THRD_3 OS threads reuse. Info threads - total (%ld) wait (%ld) dead (%ld)",
_thread_num_total, _thread_num_wait, _thread_num_dead);*/
}
return thr;
failed:
if (thr->thr_status == RUNNABLE)
{
_thread_free_attributes (thr);
dk_free (thr, sizeof (thread_t));
}
return NULL;
}
void
thread_exit (int n)
{
thread_t *thr = current_thread;
volatile int is_attached = thr->thr_attached;
if (thr == _main_thread)
{
call_exit (n);
}
thr->thr_retcode = n;
thr->thr_status = DEAD;
if (is_attached)
{
thr->thr_status = TERMINATE;
goto terminate;
}
Q_LOCK ();
thread_queue_to (&_deadq, thr);
_thread_num_dead++;
do
{
int rc = pthread_cond_wait ((pthread_cond_t *) thr->thr_cv, (pthread_mutex_t*) &_q_lock->mtx_mtx);
CKRET (rc);
} while (thr->thr_status == DEAD);
Q_UNLOCK ();
if (thr->thr_status == TERMINATE)
goto terminate;
/* Jumps back into _thread_boot */
longjmp (thr->thr_init_context, 1);
failed:
thread_queue_remove (&_deadq, thr);
_thread_num_dead--;
Q_UNLOCK ();
terminate:
if (thr->thr_status == TERMINATE)
{
#ifndef OLD_PTHREADS
pthread_detach (* (pthread_t *)thr->thr_handle);
#else
pthread_detach ( (pthread_t *)thr->thr_handle);
#endif
_thread_free_attributes (thr);
dk_free ((void *) thr->thr_cv, sizeof (pthread_cond_t));
semaphore_free (thr->thr_sem);
semaphore_free (thr->thr_schedule_sem);
dk_free (thr->thr_handle, sizeof (pthread_t));
thr_free_alloc_cache (thr);
dk_free (thr, sizeof (thread_t));
}
if (!is_attached)
{
_thread_num_total--;
pthread_exit ((void *) 1L);
}
}
