Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1998 - 2001 Pekka Riikonen
+ Copyright (C) 1998 - 2007 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
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
+ the Free Software Foundation; version 2 of the License.
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*/
/* $Id$ */
-#include "silcincludes.h"
+#include "silc.h"
+
+#if defined(HAVE_EPOLL_WAIT)
+#include <sys/epoll.h>
+#elif defined(HAVE_POLL) && defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
+#include <poll.h>
+#endif
-/* Structure holding list of file descriptors, scheduler is supposed to
- be listenning. The max_fd field is the maximum number of possible file
- descriptors in the list. This value is set at the initialization
- of the scheduler and it usually is the maximum number of connections
- allowed. */
+const SilcScheduleOps schedule_ops;
+
+/* Internal context. */
typedef struct {
- int *fd;
- uint32 last_fd;
- uint32 max_fd;
-} SilcScheduleFdList;
+#if defined(HAVE_EPOLL_WAIT)
+ struct epoll_event *fds;
+ SilcUInt32 fds_count;
+ int epfd;
+#elif defined(HAVE_POLL) && defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
+ struct rlimit nofile;
+ struct pollfd *fds;
+ SilcUInt32 fds_count;
+#endif /* HAVE_POLL && HAVE_SETRLIMIT && RLIMIT_NOFILE */
+ void *app_context;
+ int wakeup_pipe[2];
+ SilcTask wakeup_task;
+ sigset_t signals;
+ sigset_t signals_blocked;
+} *SilcUnixScheduler;
-/*
- SILC Unix Scheduler structure.
+typedef struct {
+ SilcUInt32 sig;
+ SilcTaskCallback callback;
+ void *context;
+ SilcBool call;
+ SilcSchedule schedule;
+} SilcUnixSignal;
- This is the actual schedule object in SILC. Both SILC client and server
- uses this same scheduler. Actually, this scheduler could be used by any
- program needing scheduling.
+#define SIGNAL_COUNT 32
+SilcUnixSignal signal_call[SIGNAL_COUNT];
- Following short description of the fields:
+#if defined(HAVE_EPOLL_WAIT)
- SilcTaskQueue fd_queue
+/* Linux's fast epoll system (level triggered) */
- Task queue hook for non-timeout tasks. Usually this means that these
- tasks perform different kind of I/O on file descriptors. File
- descriptors are usually network sockets but they actually can be
- any file descriptors. This hook is initialized in silc_schedule_init
- function. Timeout tasks should not be added to this queue because
- they will never expire.
+int silc_epoll(SilcSchedule schedule, void *context)
+{
+ SilcUnixScheduler internal = context;
+ SilcTaskFd task;
+ struct epoll_event *fds = internal->fds;
+ SilcUInt32 fds_count = internal->fds_count;
+ int ret, i, timeout = -1;
+
+ /* Allocate larger fd table if needed */
+ i = silc_hash_table_count(schedule->fd_queue);
+ if (i > fds_count) {
+ fds = silc_realloc(internal->fds, sizeof(*internal->fds) *
+ (fds_count + (i / 2)));
+ if (silc_likely(fds)) {
+ internal->fds = fds;
+ internal->fds_count = fds_count = fds_count + (i / 2);
+ }
+ }
- SilcTaskQueue timeout_queue
+ if (schedule->has_timeout)
+ timeout = ((schedule->timeout.tv_sec * 1000) +
+ (schedule->timeout.tv_usec / 1000));
+
+ SILC_SCHEDULE_UNLOCK(schedule);
+ ret = epoll_wait(internal->epfd, fds, fds_count, timeout);
+ SILC_SCHEDULE_LOCK(schedule);
+ if (ret <= 0)
+ return ret;
+
+ silc_list_init(schedule->fd_dispatch, struct SilcTaskStruct, next);
+
+ for (i = 0; i < ret; i++) {
+ task = fds[i].data.ptr;
+ task->revents = 0;
+ if (!task->header.valid || !task->events) {
+ epoll_ctl(internal->epfd, EPOLL_CTL_DEL, task->fd, &fds[i]);
+ continue;
+ }
+ if (fds[i].events & (EPOLLIN | EPOLLPRI | EPOLLHUP | EPOLLERR))
+ task->revents |= SILC_TASK_READ;
+ if (fds[i].events & EPOLLOUT)
+ task->revents |= SILC_TASK_WRITE;
+ silc_list_add(schedule->fd_dispatch, task);
+ }
+
+ return ret;
+}
- Task queue hook for timeout tasks. This hook is reserved specificly
- for tasks with timeout. Non-timeout tasks should not be added to this
- queue because they will never get scheduled. This hook is also
- initialized in silc_schedule_init function.
+#elif defined(HAVE_POLL) && defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
- SilcTaskQueue generic_queue
+/* Calls normal poll() system call. */
+
+int silc_poll(SilcSchedule schedule, void *context)
+{
+ SilcUnixScheduler internal = context;
+ SilcHashTableList htl;
+ SilcTaskFd task;
+ 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, &fdp, (void *)&task)) {
+ if (!task->events)
+ continue;
+ fd = SILC_PTR_TO_32(fdp);
+
+ /* Allocate larger fd table if needed */
+ if (i >= fds_count) {
+ struct rlimit nofile;
+
+ fds = silc_realloc(internal->fds, sizeof(*internal->fds) *
+ (fds_count + (fds_count / 2)));
+ if (silc_unlikely(!fds))
+ break;
+ internal->fds = fds;
+ internal->fds_count = fds_count = fds_count + (fds_count / 2);
+ internal->nofile.rlim_cur = fds_count;
+ if (fds_count > internal->nofile.rlim_max)
+ internal->nofile.rlim_max = fds_count;
+ if (setrlimit(RLIMIT_NOFILE, &nofile) < 0)
+ break;
+ }
- Task queue hook for generic tasks. This hook is reserved specificly
- for generic tasks, tasks that apply to all file descriptors, except
- to those that have specificly registered a non-timeout task. This hook
- is also initialized in silc_schedule_init function.
+ fds[i].fd = fd;
+ fds[i].events = 0;
+ task->revents = fds[i].revents = 0;
- SilcScheduleFdList fd_list
+ if (task->events & SILC_TASK_READ)
+ fds[i].events |= (POLLIN | POLLPRI);
+ if (task->events & SILC_TASK_WRITE)
+ fds[i].events |= POLLOUT;
+ i++;
+ }
+ silc_hash_table_list_reset(&htl);
+ silc_list_init(schedule->fd_dispatch, struct SilcTaskStruct, next);
+
+ if (schedule->has_timeout)
+ timeout = ((schedule->timeout.tv_sec * 1000) +
+ (schedule->timeout.tv_usec / 1000));
+
+ fds_count = i;
+ SILC_SCHEDULE_UNLOCK(schedule);
+ ret = poll(fds, fds_count, timeout);
+ SILC_SCHEDULE_LOCK(schedule);
+ if (ret <= 0)
+ return ret;
+
+ for (i = 0; i < fds_count; i++) {
+ if (!fds[i].revents)
+ continue;
+ if (!silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fds[i].fd),
+ NULL, (void *)&task))
+ continue;
+ if (!task->header.valid || !task->events)
+ continue;
+
+ fd = fds[i].revents;
+ if (fd & (POLLIN | POLLPRI | POLLERR | POLLHUP | POLLNVAL))
+ task->revents |= SILC_TASK_READ;
+ if (fd & POLLOUT)
+ task->revents |= SILC_TASK_WRITE;
+ silc_list_add(schedule->fd_dispatch, task);
+ }
- List of file descriptors the scheduler is supposed to be listenning.
- This is updated internally.
+ return ret;
+}
- struct timeval *timeout;
+#else
- Pointer to the schedules next timeout. Value of this timeout is
- automatically updated in the silc_schedule function.
+/* Calls normal select() system call. */
- int valid
+int silc_select(SilcSchedule schedule, void *context)
+{
+ SilcHashTableList htl;
+ 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, &fdp, (void *)&task)) {
+ if (!task->events)
+ continue;
+ fd = SILC_PTR_TO_32(fdp);
+
+#ifdef FD_SETSIZE
+ if (fd >= FD_SETSIZE)
+ break;
+#endif /* FD_SETSIZE */
- Marks validity of the scheduler. This is a boolean value. When this
- is false the scheduler is terminated and the program will end. This
- set to true when the scheduler is initialized with silc_schedule_init
- function.
+ if (fd > max_fd)
+ max_fd = fd;
- fd_set in
- fd_set out
+ if (task->events & SILC_TASK_READ)
+ FD_SET(fd, &in);
+ if (task->events & SILC_TASK_WRITE)
+ FD_SET(fd, &out);
- File descriptor sets for select(). These are automatically managed
- by the scheduler and should not be touched otherwise.
+ task->revents = 0;
+ }
+ silc_hash_table_list_reset(&htl);
+ silc_list_init(schedule->fd_dispatch, struct SilcTaskStruct, next);
+
+ SILC_SCHEDULE_UNLOCK(schedule);
+ ret = select(max_fd + 1, &in, &out, NULL, (schedule->has_timeout ?
+ &schedule->timeout : NULL));
+ SILC_SCHEDULE_LOCK(schedule);
+ if (ret <= 0)
+ return ret;
+
+ silc_hash_table_list(schedule->fd_queue, &htl);
+ 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)
+ break;
+#endif /* FD_SETSIZE */
- int max_fd
+ if (FD_ISSET(fd, &in))
+ task->revents |= SILC_TASK_READ;
+ if (FD_ISSET(fd, &out))
+ task->revents |= SILC_TASK_WRITE;
+ silc_list_add(schedule->fd_dispatch, task);
+ }
+ silc_hash_table_list_reset(&htl);
- Number of maximum file descriptors for select(). This, as well, is
- managed automatically by the scheduler and should be considered to
- be read-only field otherwise.
+ return ret;
+}
-*/
-struct SilcScheduleStruct {
- SilcTaskQueue fd_queue;
- SilcTaskQueue timeout_queue;
- SilcTaskQueue generic_queue;
- SilcScheduleFdList fd_list;
- struct timeval *timeout;
- int valid;
- fd_set in;
- fd_set out;
- int max_fd;
-};
+#endif /* HAVE_POLL && HAVE_SETRLIMIT && RLIMIT_NOFILE */
-/* Initializes the scheduler. Sets the non-timeout task queue hook and
- the timeout task queue hook. This must be called before the scheduler
- is able to work. This will allocate the queue pointers if they are
- not allocated. Returns the scheduler context that must be freed by
- the silc_schedule_uninit function. */
+/* Schedule `task' with events `event_mask'. Zero `event_mask' unschedules. */
-SilcSchedule silc_schedule_init(SilcTaskQueue *fd_queue,
- SilcTaskQueue *timeout_queue,
- SilcTaskQueue *generic_queue,
- int max_fd)
+SilcBool silc_schedule_internal_schedule_fd(SilcSchedule schedule,
+ void *context,
+ SilcTaskFd task,
+ SilcTaskEvent event_mask)
{
- SilcSchedule schedule;
- int i;
+#if defined(HAVE_EPOLL_WAIT)
+ SilcUnixScheduler internal = (SilcUnixScheduler)context;
+ struct epoll_event event;
+
+ if (!internal)
+ return TRUE;
+
+ SILC_LOG_DEBUG(("Scheduling fd %lu, mask %x", task->fd, event_mask));
+
+ memset(&event, 0, sizeof(event));
+ if (event_mask & SILC_TASK_READ)
+ event.events |= (EPOLLIN | EPOLLPRI);
+ if (event_mask & SILC_TASK_WRITE)
+ event.events |= EPOLLOUT;
+
+ /* Zero mask unschedules task */
+ if (silc_unlikely(!event.events)) {
+ if (epoll_ctl(internal->epfd, EPOLL_CTL_DEL, task->fd, &event)) {
+ SILC_LOG_DEBUG(("epoll_ctl (DEL): %s", strerror(errno)));
+ return FALSE;
+ }
+ return TRUE;
+ }
+
+ /* Schedule the task */
+ if (silc_unlikely(!task->scheduled)) {
+ event.data.ptr = task;
+ if (epoll_ctl(internal->epfd, EPOLL_CTL_ADD, task->fd, &event)) {
+ SILC_LOG_DEBUG(("epoll_ctl (ADD): %s", strerror(errno)));
+ return FALSE;
+ }
+ task->scheduled = TRUE;
+ return TRUE;
+ }
- SILC_LOG_DEBUG(("Initializing scheduler"));
-
- schedule = silc_calloc(1, sizeof(*schedule));
-
- /* Register the task queues if they are not registered already. In SILC
- we have by default three task queues. One task queue for non-timeout
- tasks which perform different kind of I/O on file descriptors, timeout
- task queue for timeout tasks, and, generic non-timeout task queue whose
- tasks apply to all connections. */
- if (!*fd_queue)
- silc_task_queue_alloc(schedule, fd_queue, TRUE);
- if (!*timeout_queue)
- silc_task_queue_alloc(schedule, timeout_queue, TRUE);
- if (!*generic_queue)
- silc_task_queue_alloc(schedule, generic_queue, TRUE);
-
- /* Initialize the scheduler */
- schedule->fd_queue = *fd_queue;
- schedule->timeout_queue = *timeout_queue;
- schedule->generic_queue = *generic_queue;
- schedule->fd_list.fd = silc_calloc(max_fd, sizeof(int));
- schedule->fd_list.last_fd = 0;
- schedule->fd_list.max_fd = max_fd;
- schedule->timeout = NULL;
- schedule->valid = TRUE;
- FD_ZERO(&schedule->in);
- FD_ZERO(&schedule->out);
- schedule->max_fd = -1;
- for (i = 0; i < max_fd; i++)
- schedule->fd_list.fd[i] = -1;
-
- return schedule;
+ /* Schedule for specific mask */
+ event.data.ptr = task;
+ if (epoll_ctl(internal->epfd, EPOLL_CTL_MOD, task->fd, &event)) {
+ SILC_LOG_DEBUG(("epoll_ctl (MOD): %s", strerror(errno)));
+ return FALSE;
+ }
+#endif /* HAVE_EPOLL_WAIT */
+ return TRUE;
}
-/* Uninitializes the schedule. This is called when the program is ready
- to end. This removes all tasks and task queues. Returns FALSE if the
- scheduler could not be uninitialized. This happens when the scheduler
- is still valid and silc_schedule_stop has not been called. */
+#ifdef SILC_THREADS
-bool silc_schedule_uninit(SilcSchedule schedule)
+SILC_TASK_CALLBACK(silc_schedule_wakeup_cb)
{
+ SilcUnixScheduler internal = (SilcUnixScheduler)context;
+ unsigned char c;
- SILC_LOG_DEBUG(("Uninitializing scheduler"));
+ SILC_LOG_DEBUG(("Wokeup"));
- if (schedule->valid == TRUE)
- return FALSE;
+ (void)read(internal->wakeup_pipe[0], &c, 1);
+}
- /* Unregister all tasks */
- if (schedule->fd_queue)
- silc_task_remove(schedule->fd_queue, SILC_ALL_TASKS);
- if (schedule->timeout_queue)
- silc_task_remove(schedule->timeout_queue, SILC_ALL_TASKS);
- if (schedule->generic_queue)
- silc_task_remove(schedule->generic_queue, SILC_ALL_TASKS);
-
- /* Unregister all task queues */
- if (schedule->fd_queue)
- silc_task_queue_free(schedule->fd_queue);
- if (schedule->timeout_queue)
- silc_task_queue_free(schedule->timeout_queue);
- if (schedule->generic_queue)
- silc_task_queue_free(schedule->generic_queue);
-
- /* Clear the fd list */
- if (schedule->fd_list.fd) {
- memset(schedule->fd_list.fd, -1, schedule->fd_list.max_fd);
- silc_free(schedule->fd_list.fd);
+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 */
- memset(&schedule, 'F', sizeof(schedule));
- return TRUE;
+/* Initializes the platform specific scheduler. This for example initializes
+ the wakeup mechanism of the scheduler. In multi-threaded environment
+ the scheduler needs to be woken up when tasks are added or removed from
+ the task queues. Returns context to the platform specific scheduler. */
+
+void *silc_schedule_internal_init(SilcSchedule schedule,
+ void *app_context)
+{
+ SilcUnixScheduler internal;
+ int i;
+
+ internal = silc_scalloc(schedule->stack, 1, sizeof(*internal));
+ if (!internal)
+ return NULL;
+
+#if defined(HAVE_EPOLL_WAIT)
+ internal->epfd = epoll_create(4);
+ if (internal->epfd < 0) {
+ SILC_LOG_ERROR(("epoll_create() failed: %s", strerror(errno)));
+ return NULL;
+ }
+ internal->fds = silc_calloc(4, sizeof(*internal->fds));
+ if (!internal->fds) {
+ close(internal->epfd);
+ return NULL;
+ }
+ internal->fds_count = 4;
+#elif defined(HAVE_POLL) && defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
+ getrlimit(RLIMIT_NOFILE, &internal->nofile);
+
+ if (schedule->max_tasks > 0) {
+ internal->nofile.rlim_cur = schedule->max_tasks;
+ if (schedule->max_tasks > internal->nofile.rlim_max)
+ internal->nofile.rlim_max = schedule->max_tasks;
+ setrlimit(RLIMIT_NOFILE, &internal->nofile);
+ getrlimit(RLIMIT_NOFILE, &internal->nofile);
+ schedule->max_tasks = internal->nofile.rlim_max;
+ }
+
+ internal->fds = silc_calloc(internal->nofile.rlim_cur,
+ sizeof(*internal->fds));
+ if (!internal->fds)
+ return NULL;
+ internal->fds_count = internal->nofile.rlim_cur;
+#endif /* HAVE_POLL && HAVE_SETRLIMIT && RLIMIT_NOFILE */
+
+ sigemptyset(&internal->signals);
+
+#ifdef SILC_THREADS
+ if (pipe(internal->wakeup_pipe)) {
+ SILC_LOG_ERROR(("pipe() fails: %s", strerror(errno)));
+ return NULL;
+ }
+
+ 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;
+ }
+
+ return (void *)internal;
}
-/* Stops the schedule even if it is not supposed to be stopped yet.
- After calling this, one should call silc_schedule_uninit (after the
- silc_schedule has returned). */
+void silc_schedule_internal_signals_block(SilcSchedule schedule,
+ void *context);
+void silc_schedule_internal_signals_unblock(SilcSchedule schedule,
+ void *context);
+
+/* Uninitializes the platform specific scheduler context. */
-void silc_schedule_stop(SilcSchedule schedule)
+void silc_schedule_internal_uninit(SilcSchedule schedule, void *context)
{
- SILC_LOG_DEBUG(("Stopping scheduler"));
+ SilcUnixScheduler internal = (SilcUnixScheduler)context;
- if (schedule->valid == TRUE)
- schedule->valid = FALSE;
+ if (!internal)
+ return;
+
+#ifdef SILC_THREADS
+ close(internal->wakeup_pipe[0]);
+ close(internal->wakeup_pipe[1]);
+#endif
+
+#if defined(HAVE_EPOLL_WAIT)
+ close(internal->epfd);
+ silc_free(internal->fds);
+#elif defined(HAVE_POLL) && defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
+ silc_free(internal->fds);
+#endif /* HAVE_POLL && HAVE_SETRLIMIT && RLIMIT_NOFILE */
}
-/* Sets a file descriptor to be listened by select() in scheduler. One can
- call this directly if wanted. This can be called multiple times for
- one file descriptor to set different iomasks. */
+/* Wakes up the scheduler */
-void silc_schedule_set_listen_fd(SilcSchedule schedule, int fd, uint32 iomask)
+void silc_schedule_internal_wakeup(SilcSchedule schedule, void *context)
{
- schedule->fd_list.fd[fd] = iomask;
-
- if (fd > schedule->fd_list.last_fd)
- schedule->fd_list.last_fd = fd;
+#ifdef SILC_THREADS
+ SilcUnixScheduler internal = (SilcUnixScheduler)context;
+
+ if (!internal || !internal->wakeup_task)
+ return;
+
+ SILC_LOG_DEBUG(("Wakeup"));
+
+ (void)write(internal->wakeup_pipe[1], "!", 1);
+#endif
}
-/* Removes a file descriptor from listen list. */
+/* Signal handler */
-void silc_schedule_unset_listen_fd(SilcSchedule schedule, int fd)
+static void silc_schedule_internal_sighandler(int signal)
{
- schedule->fd_list.fd[fd] = -1;
-
- if (fd == schedule->fd_list.last_fd) {
- int i;
+ int i;
- for (i = fd; i >= 0; i--)
- if (schedule->fd_list.fd[i] != -1)
- break;
+ SILC_LOG_DEBUG(("Start"));
- schedule->fd_list.last_fd = i < 0 ? 0 : i;
+ for (i = 0; i < SIGNAL_COUNT; i++) {
+ if (signal_call[i].sig == signal) {
+ signal_call[i].call = TRUE;
+ signal_call[i].schedule->signal_tasks = TRUE;
+ SILC_LOG_DEBUG(("Scheduling signal %d to be called",
+ signal_call[i].sig));
+ break;
+ }
}
}
-/* Executes tasks matching the file descriptor set by select(). The task
- remains on the task queue after execution. Invalid tasks are removed
- here from the task queue. This macro is used by silc_schedule function.
- We don't have to care about the tasks priority here because the tasks
- are sorted in their priority order already at the registration phase. */
-
-#define SILC_SCHEDULE_RUN_TASKS \
-do { \
- queue = schedule->fd_queue; \
- if (queue && queue->valid == TRUE && queue->task) { \
- task = queue->task; \
- \
- /* Walk thorugh all tasks in the particular task queue and \
- execute the callback functions of those tasks matching the \
- fd set by select(). */ \
- while(1) { \
- /* Validity of the task is checked always before and after \
- execution beacuse the task might have been unregistered \
- in the callback function, ie. it is not valid anymore. */ \
- \
- if (task->valid) { \
- /* Task ready for reading */ \
- if ((FD_ISSET(task->fd, &schedule->in)) && \
- (task->iomask & (1L << SILC_TASK_READ))) { \
- task->callback(queue, SILC_TASK_READ, task->context, task->fd); \
- is_run = TRUE; \
- } \
- } \
- \
- if (task->valid) { \
- /* Task ready for writing */ \
- if ((FD_ISSET(task->fd, &schedule->out)) && \
- (task->iomask & (1L << SILC_TASK_WRITE))) { \
- task->callback(queue, SILC_TASK_WRITE, task->context, task->fd); \
- is_run = TRUE; \
- } \
- } \
- \
- if (!task->valid) { \
- /* Invalid (unregistered) tasks are removed from the \
- task queue. */ \
- if (queue->task == task->next) { \
- silc_task_remove(queue, task); \
- break; \
- } \
- \
- task = task->next; \
- silc_task_remove(queue, task->prev); \
- continue; \
- } \
- \
- /* Break if there isn't more tasks in the queue */ \
- if (queue->task == task->next) \
- break; \
- \
- task = task->next; \
- } \
- } \
-} while(0)
-
-/* Selects tasks to be listened by select(). These are the non-timeout
- tasks. This checks the scheduler's fd list. This macro is used by
- silc_schedule function. */
-
-#define SILC_SCHEDULE_SELECT_TASKS \
-do { \
- for (i = 0; i <= schedule->fd_list.last_fd; i++) { \
- if (schedule->fd_list.fd[i] != -1) { \
- \
- /* Set the max fd value for select() to listen */ \
- if (i > schedule->max_fd) \
- schedule->max_fd = i; \
- \
- /* Add tasks for reading */ \
- if ((schedule->fd_list.fd[i] & (1L << SILC_TASK_READ))) \
- FD_SET(i, &schedule->in); \
- \
- /* Add tasks for writing */ \
- if ((schedule->fd_list.fd[i] & (1L << SILC_TASK_WRITE))) \
- FD_SET(i, &schedule->out); \
- } \
- } \
-} while(0)
-
-/* Executes all tasks whose timeout has expired. The task is removed from
- the task queue after the callback function has returned. Also, invalid
- tasks are removed here. The current time must be get before calling this
- macro. This macro is used by silc_schedule function. We don't have to
- care about priorities because tasks are already sorted in their priority
- order at the registration phase. */
-
-#define SILC_SCHEDULE_RUN_TIMEOUT_TASKS \
-do { \
- queue = schedule->timeout_queue; \
- if (queue && queue->valid == TRUE && queue->task) { \
- task = queue->task; \
- \
- /* Walk thorugh all tasks in the particular task queue \
- and run all the expired tasks. */ \
- while(1) { \
- /* Execute the task if the timeout has expired */ \
- if (silc_task_timeout_compare(&task->timeout, &curtime)) { \
- \
- /* Task ready for reading */ \
- if (task->valid) { \
- if ((task->iomask & (1L << SILC_TASK_READ))) \
- task->callback(queue, SILC_TASK_READ, \
- task->context, task->fd); \
- } \
- \
- /* Task ready for writing */ \
- if (task->valid) { \
- if ((task->iomask & (1L << SILC_TASK_WRITE))) \
- task->callback(queue, SILC_TASK_WRITE, \
- task->context, task->fd); \
- } \
- \
- /* Break if there isn't more tasks in the queue */ \
- if (queue->task == task->next) { \
- /* Remove the task from queue */ \
- silc_task_remove(queue, task); \
- break; \
- } \
- \
- task = task->next; \
- \
- /* Remove the task from queue */ \
- silc_task_remove(queue, task->prev); \
- } else { \
- /* The timeout hasn't expired, check for next one */ \
- \
- /* Break if there isn't more tasks in the queue */ \
- if (queue->task == task->next) \
- break; \
- \
- task = task->next; \
- } \
- } \
- } \
-} while(0)
-
-/* Calculates next timeout for select(). This is the timeout value
- when at earliest some of the timeout tasks expire. If this is in the
- past, they will be run now. This macro is used by the silc_schedule
- function. */
-
-#define SILC_SCHEDULE_SELECT_TIMEOUT \
-do { \
- if (schedule->timeout_queue && schedule->timeout_queue->valid == TRUE) { \
- queue = schedule->timeout_queue; \
- task = NULL; \
- \
- /* Get the current time */ \
- gettimeofday(&curtime, NULL); \
- schedule->timeout = NULL; \
- \
- /* First task in the task queue has always the smallest timeout. */ \
- task = queue->task; \
- while(1) { \
- if (task && task->valid == TRUE) { \
- \
- /* If the timeout is in past, we will run the task and all other \
- timeout tasks from the past. */ \
- if (silc_task_timeout_compare(&task->timeout, &curtime)) { \
- SILC_SCHEDULE_RUN_TIMEOUT_TASKS; \
- \
- /* The task(s) has expired and doesn't exist on the task queue \
- anymore. We continue with new timeout. */ \
- queue = schedule->timeout_queue; \
- task = queue->task; \
- if (task == NULL || task->valid == FALSE) \
- break; \
- goto cont; \
- } else { \
- cont: \
- /* Calculate the next timeout for select() */ \
- queue->timeout.tv_sec = task->timeout.tv_sec - curtime.tv_sec; \
- queue->timeout.tv_usec = task->timeout.tv_usec - curtime.tv_usec; \
- if (queue->timeout.tv_sec < 0) \
- queue->timeout.tv_sec = 0; \
- \
- /* We wouldn't want to go under zero, check for it. */ \
- if (queue->timeout.tv_usec < 0) { \
- queue->timeout.tv_sec -= 1; \
- if (queue->timeout.tv_sec < 0) \
- queue->timeout.tv_sec = 0; \
- queue->timeout.tv_usec += 1000000L; \
- } \
- } \
- /* We've got the timeout value */ \
- break; \
- } else { \
- /* Task is not valid, remove it and try next one. */ \
- silc_task_remove(queue, task); \
- task = queue->task; \
- if (queue->task == NULL) \
- break; \
- } \
- } \
- /* Save the timeout */ \
- if (task) \
- schedule->timeout = &queue->timeout; \
- } \
-} while(0)
-
-/* Execute generic tasks. These are executed only and only if for the
- specific fd there wasn't other non-timeout tasks. This checks the earlier
- set fd list, thus the generic tasks apply to all specified fd's. All the
- generic tasks are executed at once. */
-
-#define SILC_SCHEDULE_RUN_GENERIC_TASKS \
-do { \
- if (is_run == FALSE) { \
- SILC_LOG_DEBUG(("Running generic tasks")); \
- for (i = 0; i <= schedule->fd_list.last_fd; i++) \
- if (schedule->fd_list.fd[i] != -1) { \
- \
- /* Check whether this fd is select()ed. */ \
- if ((FD_ISSET(i, &schedule->in)) || (FD_ISSET(i, &schedule->out))) { \
- \
- /* It was selected. Now find the tasks from task queue and execute \
- all generic tasks. */ \
- if (schedule->generic_queue && schedule->generic_queue->valid) { \
- queue = schedule->generic_queue; \
- \
- if (!queue->task) \
- break; \
- \
- task = queue->task; \
- \
- while(1) { \
- /* Validity of the task is checked always before and after \
- execution beacuse the task might have been unregistered \
- in the callback function, ie. it is not valid anymore. */ \
- \
- if (task->valid && schedule->fd_list.fd[i] != -1) { \
- /* Task ready for reading */ \
- if ((schedule->fd_list.fd[i] & (1L << SILC_TASK_READ))) \
- task->callback(queue, SILC_TASK_READ, \
- task->context, i); \
- } \
- \
- if (task->valid && schedule->fd_list.fd[i] != -1) { \
- /* Task ready for writing */ \
- if ((schedule->fd_list.fd[i] & (1L << SILC_TASK_WRITE))) \
- task->callback(queue, SILC_TASK_WRITE, \
- task->context, i); \
- } \
- \
- if (!task->valid) { \
- /* Invalid (unregistered) tasks are removed from the \
- task queue. */ \
- if (queue->task == task->next) { \
- silc_task_remove(queue, task); \
- break; \
- } \
- \
- task = task->next; \
- silc_task_remove(queue, task->prev); \
- continue; \
- } \
- \
- /* Break if there isn't more tasks in the queue */ \
- if (queue->task == task->next) \
- break; \
- \
- task = task->next; \
- } \
- } \
- } \
- } \
- } \
-} while(0)
-
-bool silc_schedule_one(SilcSchedule schedule, int timeout_usecs)
+void silc_schedule_internal_signal_register(SilcSchedule schedule,
+ void *context,
+ SilcUInt32 sig,
+ SilcTaskCallback callback,
+ void *callback_context)
{
- struct timeval timeout;
- int is_run, i;
- SilcTask task;
- SilcTaskQueue queue;
- struct timeval curtime;
-
- SILC_LOG_DEBUG(("In scheduler loop"));
-
- /* If the task queues aren't initialized or we aren't valid anymore
- we will return */
- if ((!schedule->fd_queue && !schedule->timeout_queue
- && !schedule->generic_queue) || schedule->valid == FALSE) {
- SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting"));
- return FALSE;
+ SilcUnixScheduler internal = (SilcUnixScheduler)context;
+ int i;
+
+ if (!internal)
+ return;
+
+ SILC_LOG_DEBUG(("Registering signal %d", sig));
+
+ silc_schedule_internal_signals_block(schedule, context);
+
+ for (i = 0; i < SIGNAL_COUNT; i++) {
+ if (!signal_call[i].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;
+ }
}
- /* Clear everything */
- FD_ZERO(&schedule->in);
- FD_ZERO(&schedule->out);
- schedule->max_fd = -1;
- is_run = FALSE;
+ silc_schedule_internal_signals_unblock(schedule, context);
+ sigaddset(&internal->signals, sig);
+}
- /* Calculate next timeout for select(). This is the timeout value
- when at earliest some of the timeout tasks expire. */
- SILC_SCHEDULE_SELECT_TIMEOUT;
+void silc_schedule_internal_signal_unregister(SilcSchedule schedule,
+ void *context,
+ SilcUInt32 sig)
+{
+ SilcUnixScheduler internal = (SilcUnixScheduler)context;
+ int i;
- /* Add the file descriptors to the fd sets. These are the non-timeout
- tasks. The select() listens to these file descriptors. */
- SILC_SCHEDULE_SELECT_TASKS;
+ if (!internal)
+ return;
- if (schedule->max_fd == -1 && !schedule->timeout)
- return FALSE;
+ SILC_LOG_DEBUG(("Unregistering signal %d", sig));
- if (schedule->timeout) {
- SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule->timeout->tv_sec,
- schedule->timeout->tv_usec));
- }
+ silc_schedule_internal_signals_block(schedule, context);
- if (timeout_usecs >= 0) {
- timeout.tv_sec = 0;
- timeout.tv_usec = timeout_usecs;
- schedule->timeout = &timeout;
+ for (i = 0; i < SIGNAL_COUNT; i++) {
+ if (signal_call[i].sig == 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);
+ }
}
- /* This is the main select(). The program blocks here until some
- of the selected file descriptors change status or the selected
- timeout expires. */
- SILC_LOG_DEBUG(("Select"));
- switch (select(schedule->max_fd + 1, &schedule->in,
- &schedule->out, 0, schedule->timeout)) {
- case -1:
- /* Error */
- if (errno == EINTR)
- break;
- SILC_LOG_ERROR(("Error in select(): %s", strerror(errno)));
- break;
- case 0:
- /* Timeout */
- SILC_LOG_DEBUG(("Running timeout tasks"));
- gettimeofday(&curtime, NULL);
- SILC_SCHEDULE_RUN_TIMEOUT_TASKS;
- break;
- default:
- /* There is some data available now */
- SILC_LOG_DEBUG(("Running non-timeout tasks"));
- SILC_SCHEDULE_RUN_TASKS;
-
- SILC_SCHEDULE_RUN_GENERIC_TASKS;
- break;
+ silc_schedule_internal_signals_unblock(schedule, context);
+ sigdelset(&internal->signals, sig);
+}
+
+/* Call all signals */
+
+void silc_schedule_internal_signals_call(SilcSchedule schedule, void *context)
+{
+ SilcUnixScheduler internal = (SilcUnixScheduler)context;
+ int i;
+
+ SILC_LOG_DEBUG(("Start"));
+
+ if (!internal)
+ return;
+
+ silc_schedule_internal_signals_block(schedule, context);
+
+ for (i = 0; i < SIGNAL_COUNT; i++) {
+ if (signal_call[i].call &&
+ 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);
+ }
}
- return TRUE;
+ silc_schedule_internal_signals_unblock(schedule, context);
}
-/* The SILC scheduler. This is actually the main routine in SILC programs.
- When this returns the program is to be ended. Before this function can
- be called, one must call silc_schedule_init function. */
+/* Block registered signals in scheduler. */
-void silc_schedule(SilcSchedule schedule)
+void silc_schedule_internal_signals_block(SilcSchedule schedule, void *context)
{
- SILC_LOG_DEBUG(("Running scheduler"));
+ SilcUnixScheduler internal = (SilcUnixScheduler)context;
- if (schedule->valid == FALSE) {
- SILC_LOG_ERROR(("Scheduler is not valid, stopping"));
+ if (!internal)
+ return;
+
+ sigprocmask(SIG_BLOCK, &internal->signals, &internal->signals_blocked);
+}
+
+/* Unblock registered signals in schedule. */
+
+void silc_schedule_internal_signals_unblock(SilcSchedule schedule,
+ void *context)
+{
+ SilcUnixScheduler internal = (SilcUnixScheduler)context;
+
+ if (!internal)
return;
- }
- /* Start the scheduler loop */
- while (silc_schedule_one(schedule, -1))
- ;
+ sigprocmask(SIG_SETMASK, &internal->signals_blocked, NULL);
}
+
+const SilcScheduleOps schedule_ops =
+{
+ silc_schedule_internal_init,
+ silc_schedule_internal_uninit,
+#if defined(HAVE_EPOLL_WAIT)
+ silc_epoll,
+#elif defined(HAVE_POLL) && defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
+ silc_poll,
+#else
+ silc_select,
+#endif /* HAVE_POLL && HAVE_SETRLIMIT && RLIMIT_NOFILE */
+ silc_schedule_internal_schedule_fd,
+ silc_schedule_internal_wakeup,
+ silc_schedule_internal_signal_register,
+ silc_schedule_internal_signal_unregister,
+ silc_schedule_internal_signals_call,
+ silc_schedule_internal_signals_block,
+ silc_schedule_internal_signals_unblock,
+};