X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Funix%2Fsilcunixschedule.c;h=0856358764ec216f67c5c5dfa7e9872f3c7b8ed3;hb=7c09989ba3aa3b85f8494821806400984c7cd588;hp=03bd312109e4a9a08971dd2b14e556e46ceaf9ea;hpb=0d88839b0027590e041b90fb0a6611f8c85779ba;p=silc.git diff --git a/lib/silcutil/unix/silcunixschedule.c b/lib/silcutil/unix/silcunixschedule.c index 03bd3121..08563587 100644 --- a/lib/silcutil/unix/silcunixschedule.c +++ b/lib/silcutil/unix/silcunixschedule.c @@ -4,13 +4,12 @@ Author: Pekka Riikonen - 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 @@ -19,585 +18,599 @@ */ /* $Id$ */ -#include "silcincludes.h" +#include "silc.h" + +#if defined(HAVE_EPOLL_WAIT) +#include +#elif defined(HAVE_POLL) && defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE) +#include +#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_calloc(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))); + silc_free(internal); + 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); -void silc_schedule_stop(SilcSchedule schedule) +/* Uninitializes the platform specific scheduler context. */ + +void silc_schedule_internal_uninit(SilcSchedule schedule, void *context) { - SILC_LOG_DEBUG(("Stopping scheduler")); + SilcUnixScheduler internal = (SilcUnixScheduler)context; + + if (!internal) + return; - if (schedule->valid == TRUE) - schedule->valid = FALSE; +#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 */ + + silc_free(internal); } -/* 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); +} + +void silc_schedule_internal_signal_unregister(SilcSchedule schedule, + void *context, + SilcUInt32 sig) +{ + SilcUnixScheduler internal = (SilcUnixScheduler)context; + int i; - /* Calculate next timeout for select(). This is the timeout value - when at earliest some of the timeout tasks expire. */ - SILC_SCHEDULE_SELECT_TIMEOUT; + if (!internal) + return; - /* 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; + SILC_LOG_DEBUG(("Unregistering signal %d", sig)); - if (schedule->max_fd == -1 && !schedule->timeout) - return FALSE; + silc_schedule_internal_signals_block(schedule, context); - if (schedule->timeout) { - SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule->timeout->tv_sec, - schedule->timeout->tv_usec)); + 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); + } } - if (timeout_usecs >= 0) { - timeout.tv_sec = 0; - timeout.tv_usec = timeout_usecs; - schedule->timeout = &timeout; - } + silc_schedule_internal_signals_unblock(schedule, context); + sigdelset(&internal->signals, sig); +} - /* 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; +/* 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; - } - /* Start the scheduler loop */ - while (silc_schedule_one(schedule, -1)) - ; + 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; + + 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, +};