Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1998 - 2007 Pekka Riikonen
+ Copyright (C) 1998 - 2008 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
GNU General Public License for more details.
*/
-/* $Id$ */
-#include "silc.h"
+#include "silcruntime.h"
#if defined(HAVE_EPOLL_WAIT)
#include <sys/epoll.h>
} SilcUnixSignal;
#define SIGNAL_COUNT 32
-SilcUnixSignal signal_call[SIGNAL_COUNT];
#if defined(HAVE_EPOLL_WAIT)
struct pollfd *fds = internal->fds;
SilcUInt32 fds_count = internal->fds_count;
int fd, ret, i = 0, timeout = -1;
+ void *fdp;
silc_hash_table_list(schedule->fd_queue, &htl);
- while (silc_hash_table_get(&htl, (void *)&fd, (void *)&task)) {
+ while (silc_hash_table_get(&htl, &fdp, (void *)&task)) {
if (!task->events)
continue;
+ fd = SILC_PTR_TO_32(fdp);
/* Allocate larger fd table if needed */
if (i >= fds_count) {
SilcTaskFd task;
fd_set in, out;
int fd, max_fd = 0, ret;
+ void *fdp;
FD_ZERO(&in);
FD_ZERO(&out);
silc_hash_table_list(schedule->fd_queue, &htl);
- while (silc_hash_table_get(&htl, (void *)&fd, (void *)&task)) {
+ while (silc_hash_table_get(&htl, &fdp, (void *)&task)) {
if (!task->events)
continue;
+ fd = SILC_PTR_TO_32(fdp);
#ifdef FD_SETSIZE
if (fd >= FD_SETSIZE)
return ret;
silc_hash_table_list(schedule->fd_queue, &htl);
- while (silc_hash_table_get(&htl, (void *)&fd, (void *)&task)) {
+ while (silc_hash_table_get(&htl, &fdp, (void *)&task)) {
if (!task->header.valid || !task->events)
continue;
+ fd = SILC_PTR_TO_32(fdp);
#ifdef FD_SETSIZE
if (fd >= FD_SETSIZE)
SILC_LOG_DEBUG(("epoll_ctl (DEL): %s", strerror(errno)));
return FALSE;
}
+ task->scheduled = FALSE;
return TRUE;
}
SILC_LOG_DEBUG(("Wokeup"));
- read(internal->wakeup_pipe[0], &c, 1);
+ (void)read(internal->wakeup_pipe[0], &c, 1);
}
+SILC_TASK_CALLBACK(silc_schedule_wakeup_init)
+{
+ SilcUnixScheduler internal = schedule->internal;
+
+ internal->wakeup_task =
+ silc_schedule_task_add(schedule, internal->wakeup_pipe[0],
+ silc_schedule_wakeup_cb, internal,
+ 0, 0, SILC_TASK_FD);
+ if (!internal->wakeup_task) {
+ SILC_LOG_WARNING(("Could not add a wakeup task, threads won't work"));
+ close(internal->wakeup_pipe[0]);
+ return;
+ }
+ silc_schedule_internal_schedule_fd(schedule, internal,
+ (SilcTaskFd)internal->wakeup_task,
+ SILC_TASK_READ);
+}
#endif /* SILC_THREADS */
/* Initializes the platform specific scheduler. This for example initializes
void *app_context)
{
SilcUnixScheduler internal;
+ SilcUnixSignal *signal_call;
int i;
- internal = silc_calloc(1, sizeof(*internal));
+ internal = silc_scalloc(schedule->stack, 1, sizeof(*internal));
if (!internal)
return NULL;
#ifdef SILC_THREADS
if (pipe(internal->wakeup_pipe)) {
SILC_LOG_ERROR(("pipe() fails: %s", strerror(errno)));
- silc_free(internal);
return NULL;
}
- internal->wakeup_task =
- silc_schedule_task_add(schedule, internal->wakeup_pipe[0],
- silc_schedule_wakeup_cb, internal,
- 0, 0, SILC_TASK_FD);
- if (!internal->wakeup_task) {
- SILC_LOG_ERROR(("Could not add a wakeup task, threads won't work"));
- close(internal->wakeup_pipe[0]);
- close(internal->wakeup_pipe[1]);
- silc_free(internal);
- return NULL;
- }
- silc_schedule_internal_schedule_fd(schedule, internal,
- (SilcTaskFd)internal->wakeup_task,
- SILC_TASK_READ);
+ silc_schedule_task_add_timeout(schedule, silc_schedule_wakeup_init,
+ internal, 0, 0);
#endif /* SILC_THREADS */
internal->app_context = app_context;
- for (i = 0; i < SIGNAL_COUNT; i++) {
- signal_call[i].sig = 0;
- signal_call[i].call = FALSE;
- signal_call[i].schedule = schedule;
+ signal_call = silc_global_get_var("srtsignals", TRUE);
+ if (!signal_call)
+ signal_call = silc_global_set_var("srtsignals",
+ sizeof(*signal_call) * SIGNAL_COUNT,
+ NULL, TRUE);
+ if (signal_call) {
+ for (i = 0; i < SIGNAL_COUNT; i++) {
+ signal_call[i].sig = 0;
+ signal_call[i].call = FALSE;
+ signal_call[i].schedule = schedule;
+ }
}
return (void *)internal;
silc_free(internal->fds);
#endif /* HAVE_POLL && HAVE_SETRLIMIT && RLIMIT_NOFILE */
- silc_free(internal);
+ silc_global_del_var("srtsignals", TRUE);
}
/* Wakes up the scheduler */
SILC_LOG_DEBUG(("Wakeup"));
- write(internal->wakeup_pipe[1], "!", 1);
+ (void)write(internal->wakeup_pipe[1], "!", 1);
#endif
}
static void silc_schedule_internal_sighandler(int signal)
{
int i;
+ SilcUnixSignal *signal_call = silc_global_get_var("srtsignals", TRUE);
+
+ if (!signal_call)
+ return;
+
+ SILC_LOG_DEBUG(("Start"));
for (i = 0; i < SIGNAL_COUNT; i++) {
if (signal_call[i].sig == signal) {
void *callback_context)
{
SilcUnixScheduler internal = (SilcUnixScheduler)context;
+ SilcUnixSignal *signal_call = silc_global_get_var("srtsignals", TRUE);
int i;
- if (!internal)
+ if (!internal || !signal_call)
return;
SILC_LOG_DEBUG(("Registering signal %d", sig));
signal_call[i].sig = sig;
signal_call[i].callback = callback;
signal_call[i].context = callback_context;
+ signal_call[i].schedule = schedule;
signal_call[i].call = FALSE;
signal(sig, silc_schedule_internal_sighandler);
break;
SilcUInt32 sig)
{
SilcUnixScheduler internal = (SilcUnixScheduler)context;
+ SilcUnixSignal *signal_call = silc_global_get_var("srtsignals", TRUE);
int i;
- if (!internal)
+ if (!internal || !signal_call)
return;
SILC_LOG_DEBUG(("Unregistering signal %d", sig));
signal_call[i].sig = 0;
signal_call[i].callback = NULL;
signal_call[i].context = NULL;
+ signal_call[i].schedule = NULL;
signal_call[i].call = FALSE;
signal(sig, SIG_DFL);
}
void silc_schedule_internal_signals_call(SilcSchedule schedule, void *context)
{
SilcUnixScheduler internal = (SilcUnixScheduler)context;
+ SilcUnixSignal *signal_call = silc_global_get_var("srtsignals", TRUE);
int i;
SILC_LOG_DEBUG(("Start"));
- if (!internal)
+ if (!internal || !signal_call)
return;
silc_schedule_internal_signals_block(schedule, context);
signal_call[i].callback) {
SILC_LOG_DEBUG(("Calling signal %d callback",
signal_call[i].sig));
+ silc_schedule_internal_signals_unblock(schedule, context);
signal_call[i].callback(schedule, internal->app_context,
SILC_TASK_INTERRUPT,
signal_call[i].sig,
signal_call[i].context);
signal_call[i].call = FALSE;
+ silc_schedule_internal_signals_block(schedule, context);
}
}