void
mono_thread_pool_cleanup (void)
{
if (InterlockedExchange (&async_io_tp.pool_status, 2) == 1) {
socket_io_cleanup (&socket_io_data); /* Empty when DISABLE_SOCKETS is defined */
threadpool_kill_idle_threads (&async_io_tp);
}
if (async_io_tp.queue != NULL) {
MONO_SEM_DESTROY (&async_io_tp.new_job);
threadpool_free_queue (&async_io_tp);
}
if (InterlockedExchange (&async_tp.pool_status, 2) == 1) {
threadpool_kill_idle_threads (&async_tp);
threadpool_free_queue (&async_tp);
}
if (wsqs) {
EnterCriticalSection (&wsqs_lock);
mono_wsq_cleanup ();
if (wsqs)
g_ptr_array_free (wsqs, TRUE);
wsqs = NULL;
LeaveCriticalSection (&wsqs_lock);
MONO_SEM_DESTROY (&async_tp.new_job);
}
}
void
mono_thread_pool_cleanup (void)
{
if (InterlockedExchange (&async_io_tp.pool_status, 2) == 1) {
socket_io_cleanup (&socket_io_data); /* Empty when DISABLE_SOCKETS is defined */
threadpool_kill_idle_threads (&async_io_tp);
}
if (async_io_tp.queue != NULL) {
MONO_SEM_DESTROY (&async_io_tp.new_job);
threadpool_free_queue (&async_io_tp);
}
if (InterlockedExchange (&async_tp.pool_status, 2) == 1) {
threadpool_kill_idle_threads (&async_tp);
threadpool_free_queue (&async_tp);
}
if (threads) {
mono_mutex_lock (&threads_lock);
if (threads)
g_ptr_array_free (threads, FALSE);
threads = NULL;
mono_mutex_unlock (&threads_lock);
}
if (wsqs) {
mono_mutex_lock (&wsqs_lock);
mono_wsq_cleanup ();
if (wsqs)
g_ptr_array_free (wsqs, TRUE);
wsqs = NULL;
mono_mutex_unlock (&wsqs_lock);
MONO_SEM_DESTROY (&async_tp.new_job);
}
MONO_SEM_DESTROY (&monitor_sem);
}
static void
tp_poll_wait (gpointer p)
{
#if MONO_SMALL_CONFIG
#define INITIAL_POLLFD_SIZE 128
#else
#define INITIAL_POLLFD_SIZE 1024
#endif
#define POLL_ERRORS (MONO_POLLERR | MONO_POLLHUP | MONO_POLLNVAL)
mono_pollfd *pfds;
gint maxfd = 1;
gint allocated;
gint i;
MonoInternalThread *thread;
tp_poll_data *data;
SocketIOData *socket_io_data = p;
gpointer *async_results;
gint nresults;
thread = mono_thread_internal_current ();
data = socket_io_data->event_data;
allocated = INITIAL_POLLFD_SIZE;
pfds = g_new0 (mono_pollfd, allocated);
async_results = g_new0 (gpointer, allocated * 2);
INIT_POLLFD (pfds, data->pipe [0], MONO_POLLIN);
for (i = 1; i < allocated; i++)
INIT_POLLFD (&pfds [i], -1, 0);
while (1) {
int nsock = 0;
mono_pollfd *pfd;
char one [1];
MonoMList *list;
MonoObject *ares;
do {
if (nsock == -1) {
if (THREAD_WANTS_A_BREAK (thread))
mono_thread_interruption_checkpoint ();
}
nsock = mono_poll (pfds, maxfd, -1);
} while (nsock == -1 && errno == EINTR);
/*
* Apart from EINTR, we only check EBADF, for the rest:
* EINVAL: mono_poll() 'protects' us from descriptor
* numbers above the limit if using select() by marking
* then as MONO_POLLERR. If a system poll() is being
* used, the number of descriptor we're passing will not
* be over sysconf(_SC_OPEN_MAX), as the error would have
* happened when opening.
*
* EFAULT: we own the memory pointed by pfds.
* ENOMEM: we're doomed anyway
*
*/
if (nsock == -1 && errno == EBADF) {
pfds->revents = 0; /* Just in case... */
nsock = mark_bad_fds (pfds, maxfd);
}
if ((pfds->revents & POLL_ERRORS) != 0) {
/* We're supposed to die now, as the pipe has been closed */
g_free (pfds);
g_free (async_results);
socket_io_cleanup (socket_io_data);
return;
}
/* Got a new socket */
if ((pfds->revents & MONO_POLLIN) != 0) {
int nread;
for (i = 1; i < allocated; i++) {
pfd = &pfds [i];
if (pfd->fd == -1 || pfd->fd == data->newpfd.fd)
break;
}
if (i == allocated) {
mono_pollfd *oldfd;
oldfd = pfds;
i = allocated;
allocated = allocated * 2;
pfds = g_renew (mono_pollfd, oldfd, allocated);
g_free (oldfd);
for (; i < allocated; i++)
INIT_POLLFD (&pfds [i], -1, 0);
async_results = g_renew (gpointer, async_results, allocated * 2);
}
#ifndef HOST_WIN32
nread = read (data->pipe [0], one, 1);
#else
nread = recv ((SOCKET) data->pipe [0], one, 1, 0);
#endif
if (nread <= 0) {
g_free (pfds);
g_free (async_results);
return; /* we're closed */
}
INIT_POLLFD (&pfds [i], data->newpfd.fd, data->newpfd.events);
memset (&data->newpfd, 0, sizeof (mono_pollfd));
MONO_SEM_POST (&data->new_sem);
if (i >= maxfd)
maxfd = i + 1;
nsock--;
}
if (nsock == 0)
continue;
EnterCriticalSection (&socket_io_data->io_lock);
if (socket_io_data->inited == 3) {
g_free (pfds);
g_free (async_results);
LeaveCriticalSection (&socket_io_data->io_lock);
return; /* cleanup called */
}
nresults = 0;
for (i = 1; i < maxfd && nsock > 0; i++) {
pfd = &pfds [i];
if (pfd->fd == -1 || pfd->revents == 0)
continue;
nsock--;
list = mono_g_hash_table_lookup (socket_io_data->sock_to_state, GINT_TO_POINTER (pfd->fd));
if (list != NULL && (pfd->revents & (MONO_POLLIN | POLL_ERRORS)) != 0) {
ares = get_io_event (&list, MONO_POLLIN);
if (ares != NULL)
async_results [nresults++] = ares;
}
if (list != NULL && (pfd->revents & (MONO_POLLOUT | POLL_ERRORS)) != 0) {
ares = get_io_event (&list, MONO_POLLOUT);
if (ares != NULL)
async_results [nresults++] = ares;
}
if (list != NULL) {
mono_g_hash_table_replace (socket_io_data->sock_to_state, GINT_TO_POINTER (pfd->fd), list);
pfd->events = get_events_from_list (list);
} else {
mono_g_hash_table_remove (socket_io_data->sock_to_state, GINT_TO_POINTER (pfd->fd));
pfd->fd = -1;
if (i == maxfd - 1)
maxfd--;
}
}
LeaveCriticalSection (&socket_io_data->io_lock);
threadpool_append_jobs (&async_io_tp, (MonoObject **) async_results, nresults);
memset (async_results, 0, sizeof (gpointer) * nresults);
}
}