X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Fsilcschedule.c;h=6d3f09e1c3d3794f4776ea5211a4115c1492494c;hb=196824372226561334cd638d6471267cbffb354c;hp=046cfa3077aa88a9cbec040dbcbaaf114650f7c3;hpb=d0e5ec965faf2017fbe888192521dc7bf6c31a09;p=silc.git diff --git a/lib/silcutil/silcschedule.c b/lib/silcutil/silcschedule.c index 046cfa30..6d3f09e1 100644 --- a/lib/silcutil/silcschedule.c +++ b/lib/silcutil/silcschedule.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,174 +18,340 @@ */ /* $Id$ */ -#include "silcincludes.h" +#include "silc.h" -/* Routine to remove the task. Implemented in silctask.c. */ -int silc_task_remove(SilcTaskQueue queue, SilcTask task); +/************************** Types and definitions ***************************/ -/* System specific routines. Implemented under unix/ and win32/. */ +/* Platform specific implementation */ +extern const SilcScheduleOps schedule_ops; -/* System specific select(). */ -int silc_select(int n, fd_set *readfds, fd_set *writefds, - fd_set *exceptfds, struct timeval *timeout); +static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task); +static void silc_schedule_dispatch_fd(SilcSchedule schedule); +static void silc_schedule_dispatch_timeout(SilcSchedule schedule, + SilcBool dispatch_all); -/* Initializes the wakeup of the scheduler. In multi-threaded environment - the scheduler needs to be wakenup when tasks are added or removed from - the task queues. This will initialize the wakeup for the scheduler. - Any tasks that needs to be registered must be registered to the `queue'. - It is guaranteed that the scheduler will automatically free any - registered tasks in this queue. This is system specific routine. */ -void *silc_schedule_wakeup_init(void *queue); -/* Uninitializes the system specific wakeup. */ -void silc_schedule_wakeup_uninit(void *context); +/************************ Static utility functions **************************/ -/* Wakes up the scheduler. This is platform specific routine */ -void silc_schedule_wakeup_internal(void *context); +/* Fd task hash table destructor */ -/* 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. */ -typedef struct { - int *fd; - uint32 last_fd; - uint32 max_fd; -} SilcScheduleFdList; +static void silc_schedule_fd_destructor(void *key, void *context, + void *user_context) +{ + silc_free(context); +} -/* - SILC Scheduler structure. +/* Executes file descriptor tasks. Invalid tasks are removed here. */ - 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. +static void silc_schedule_dispatch_fd(SilcSchedule schedule) +{ + SilcTaskFd task; + SilcTask t; + + /* The dispatch list includes only valid tasks, and tasks that have + something to dispatch. Dispatching is atomic; no matter if another + thread invalidates a task when we unlock, we dispatch to completion. */ + SILC_SCHEDULE_UNLOCK(schedule); + silc_list_start(schedule->fd_dispatch); + while ((task = silc_list_get(schedule->fd_dispatch))) { + t = (SilcTask)task; + + /* Is the task ready for reading */ + if (task->revents & SILC_TASK_READ) + t->callback(schedule, schedule->app_context, SILC_TASK_READ, + task->fd, t->context); + + /* Is the task ready for writing */ + if (t->valid && task->revents & SILC_TASK_WRITE) + t->callback(schedule, schedule->app_context, SILC_TASK_WRITE, + task->fd, t->context); + } + SILC_SCHEDULE_LOCK(schedule); - Following short description of the fields: + /* Remove invalidated tasks */ + silc_list_start(schedule->fd_dispatch); + while ((task = silc_list_get(schedule->fd_dispatch))) + if (silc_unlikely(!task->header.valid)) + silc_schedule_task_remove(schedule, (SilcTask)task); +} + +/* 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. */ + +static void silc_schedule_dispatch_timeout(SilcSchedule schedule, + SilcBool dispatch_all) +{ + SilcTask t; + SilcTaskTimeout task; + struct timeval curtime; + int count = 0; - SilcTaskQueue fd_queue + SILC_LOG_DEBUG(("Running timeout tasks")); - 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. + silc_gettimeofday(&curtime); - SilcTaskQueue timeout_queue + /* First task in the task queue has always the earliest timeout. */ + silc_list_start(schedule->timeout_queue); + task = silc_list_get(schedule->timeout_queue); + if (silc_unlikely(!task)) + return; + do { + t = (SilcTask)task; - 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. + /* Remove invalid task */ + if (silc_unlikely(!t->valid)) { + silc_schedule_task_remove(schedule, t); + continue; + } - SilcTaskQueue generic_queue + /* Execute the task if the timeout has expired */ + if (silc_compare_timeval(&task->timeout, &curtime) > 0 && !dispatch_all) + 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. + t->valid = FALSE; + SILC_SCHEDULE_UNLOCK(schedule); + t->callback(schedule, schedule->app_context, SILC_TASK_EXPIRE, 0, + t->context); + SILC_SCHEDULE_LOCK(schedule); - SilcScheduleFdList fd_list + /* Remove the expired task */ + silc_schedule_task_remove(schedule, t); - List of file descriptors the scheduler is supposed to be listenning. - This is updated internally. + /* Balance when we have lots of small timeouts */ + if (silc_unlikely((++count) > 40)) + break; + } while (silc_likely((task = silc_list_get(schedule->timeout_queue)))); +} - struct timeval *timeout; +/* Calculates next timeout. This is the timeout value when at earliest some + of the timeout tasks expire. If this is in the past, they will be + dispatched now. */ - Pointer to the schedules next timeout. Value of this timeout is - automatically updated in the silc_schedule function. +static void silc_schedule_select_timeout(SilcSchedule schedule) +{ + SilcTask t; + SilcTaskTimeout task; + struct timeval curtime; + SilcBool dispatch = TRUE; - int valid + /* Get the current time */ + silc_gettimeofday(&curtime); + schedule->has_timeout = FALSE; - 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. + /* First task in the task queue has always the earliest timeout. */ + silc_list_start(schedule->timeout_queue); + task = silc_list_get(schedule->timeout_queue); + if (silc_unlikely(!task)) + return; + do { + t = (SilcTask)task; + + /* Remove invalid task */ + if (silc_unlikely(!t->valid)) { + silc_schedule_task_remove(schedule, t); + continue; + } + + /* If the timeout is in past, we will run the task and all other + timeout tasks from the past. */ + if (silc_compare_timeval(&task->timeout, &curtime) <= 0 && dispatch) { + silc_schedule_dispatch_timeout(schedule, FALSE); + if (silc_unlikely(!schedule->valid)) + return; + + /* Start selecting new timeout again after dispatch */ + silc_list_start(schedule->timeout_queue); + dispatch = FALSE; + continue; + } + + /* Calculate the next timeout */ + curtime.tv_sec = task->timeout.tv_sec - curtime.tv_sec; + curtime.tv_usec = task->timeout.tv_usec - curtime.tv_usec; + if (curtime.tv_sec < 0) + curtime.tv_sec = 0; + + /* We wouldn't want to go under zero, check for it. */ + if (curtime.tv_usec < 0) { + curtime.tv_sec -= 1; + if (curtime.tv_sec < 0) + curtime.tv_sec = 0; + curtime.tv_usec += 1000000L; + } + break; + } while ((task = silc_list_get(schedule->timeout_queue))); + + /* Save the timeout */ + if (task) { + schedule->timeout = curtime; + schedule->has_timeout = TRUE; + SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule->timeout.tv_sec, + schedule->timeout.tv_usec)); + } +} - fd_set in - fd_set out +/* Removes task from the scheduler. This must be called with scheduler + locked. */ - File descriptor sets for select(). These are automatically managed - by the scheduler and should not be touched otherwise. +static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task) +{ + SilcTaskFd ftask; + + if (silc_unlikely(task == SILC_ALL_TASKS)) { + SilcTask task; + SilcHashTableList htl; + SilcUInt32 fd; + + /* Delete from fd queue */ + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, (void *)&fd, (void *)&task)) + silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(fd)); + silc_hash_table_list_reset(&htl); + + /* Delete from timeout queue */ + silc_list_start(schedule->timeout_queue); + while ((task = silc_list_get(schedule->timeout_queue))) { + silc_list_del(schedule->timeout_queue, task); + silc_free(task); + } - int max_fd + return; + } - 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. + if (silc_likely(task->type == 1)) { + /* Delete from timeout queue */ + silc_list_del(schedule->timeout_queue, task); - void *wakeup + /* Put to free list */ + silc_list_add(schedule->free_tasks, task); + } else { + /* Delete from fd queue */ + ftask = (SilcTaskFd)task; + silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(ftask->fd)); + } +} - System specific wakeup context. On multi-threaded environments the - scheduler needs to be wakenup (in the thread) when tasks are added - or removed. This is initialized by silc_schedule_wakeup_init. +/* Timeout freelist garbage collection */ -*/ -struct SilcScheduleStruct { - SilcTaskQueue fd_queue; - SilcTaskQueue timeout_queue; - SilcTaskQueue generic_queue; - SilcScheduleFdList fd_list; - struct timeval *timeout; - bool valid; - fd_set in; - fd_set out; - int max_fd; - void *wakeup; - SILC_MUTEX_DEFINE(lock); - bool is_locked; -}; - -/* 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. */ - -SilcSchedule silc_schedule_init(SilcTaskQueue *fd_queue, - SilcTaskQueue *timeout_queue, - SilcTaskQueue *generic_queue, - int max_fd) +SILC_TASK_CALLBACK(silc_schedule_timeout_gc) +{ + SilcTaskTimeout t; + int c; + + if (!schedule->valid) + return; + + SILC_LOG_DEBUG(("Timeout freelist garbage collection")); + + SILC_SCHEDULE_LOCK(schedule); + + if (silc_list_count(schedule->free_tasks) <= 10) { + SILC_SCHEDULE_UNLOCK(schedule); + silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc, + schedule, 3600, 0); + return; + } + if (silc_list_count(schedule->timeout_queue) > + silc_list_count(schedule->free_tasks)) { + SILC_SCHEDULE_UNLOCK(schedule); + silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc, + schedule, 3600, 0); + return; + } + + c = silc_list_count(schedule->free_tasks) / 2; + if (c > silc_list_count(schedule->timeout_queue)) + c = (silc_list_count(schedule->free_tasks) - + silc_list_count(schedule->timeout_queue)); + if (silc_list_count(schedule->free_tasks) - c < 10) + c -= (10 - (silc_list_count(schedule->free_tasks) - c)); + + SILC_LOG_DEBUG(("Freeing %d unused tasks, leaving %d", c, + silc_list_count(schedule->free_tasks) - c)); + + silc_list_start(schedule->free_tasks); + while ((t = silc_list_get(schedule->free_tasks)) && c-- > 0) { + silc_list_del(schedule->free_tasks, t); + silc_free(t); + } + silc_list_start(schedule->free_tasks); + + SILC_SCHEDULE_UNLOCK(schedule); + + silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc, + schedule, 3600, 0); +} + +#ifdef SILC_DIST_INPLACE +/* Print schedule statistics to stdout */ + +void silc_schedule_stats(SilcSchedule schedule) +{ + SilcTaskFd ftask; + fprintf(stdout, "Schedule %p statistics:\n\n", schedule); + fprintf(stdout, "Num FD tasks : %lu (%lu bytes allocated)\n", + silc_hash_table_count(schedule->fd_queue), + sizeof(*ftask) * silc_hash_table_count(schedule->fd_queue)); + fprintf(stdout, "Num Timeout tasks : %d (%d bytes allocated)\n", + silc_list_count(schedule->timeout_queue), + sizeof(struct SilcTaskTimeoutStruct) * + silc_list_count(schedule->timeout_queue)); + fprintf(stdout, "Num Timeout freelist : %d (%d bytes allocated)\n", + silc_list_count(schedule->free_tasks), + sizeof(struct SilcTaskTimeoutStruct) * + silc_list_count(schedule->free_tasks)); +} +#endif /* SILC_DIST_INPLACE */ + +/****************************** Public API **********************************/ + +/* Initializes the scheduler. This returns the scheduler context that + is given as arugment usually to all silc_schedule_* functions. + The `max_tasks' indicates the number of maximum tasks that the + scheduler can handle. The `app_context' is application specific + context that is delivered to task callbacks. */ + +SilcSchedule silc_schedule_init(int max_tasks, void *app_context) { SilcSchedule schedule; - int i; SILC_LOG_DEBUG(("Initializing scheduler")); schedule = silc_calloc(1, sizeof(*schedule)); + if (!schedule) + return NULL; + + schedule->fd_queue = + silc_hash_table_alloc(0, silc_hash_uint, NULL, NULL, NULL, + silc_schedule_fd_destructor, NULL, TRUE); + if (!schedule->fd_queue) { + silc_free(schedule); + return NULL; + } - /* 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(*schedule->fd_list.fd)); - schedule->fd_list.last_fd = 0; - schedule->fd_list.max_fd = max_fd; - schedule->timeout = NULL; + silc_list_init(schedule->timeout_queue, struct SilcTaskStruct, next); + silc_list_init(schedule->free_tasks, struct SilcTaskStruct, next); + + schedule->app_context = app_context; 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; + schedule->max_tasks = max_tasks; + /* Allocate scheduler lock */ silc_mutex_alloc(&schedule->lock); - /* Initialize the wakeup */ - schedule->wakeup = silc_schedule_wakeup_init(schedule->fd_queue); + /* Initialize the platform specific scheduler. */ + schedule->internal = schedule_ops.init(schedule, app_context); + if (!schedule->internal) { + silc_hash_table_free(schedule->fd_queue); + silc_mutex_free(schedule->lock); + silc_free(schedule); + return NULL; + } + + /* Timeout freelist garbage collection */ + silc_schedule_task_add_timeout(schedule, silc_schedule_timeout_gc, + schedule, 3600, 0); return schedule; } @@ -196,542 +361,558 @@ SilcSchedule silc_schedule_init(SilcTaskQueue *fd_queue, scheduler could not be uninitialized. This happens when the scheduler is still valid and silc_schedule_stop has not been called. */ -bool silc_schedule_uninit(SilcSchedule schedule) +SilcBool silc_schedule_uninit(SilcSchedule schedule) { + SilcTask task; SILC_LOG_DEBUG(("Uninitializing scheduler")); if (schedule->valid == TRUE) return FALSE; + /* Dispatch all timeouts before going away */ + SILC_SCHEDULE_LOCK(schedule); + silc_schedule_dispatch_timeout(schedule, TRUE); + SILC_SCHEDULE_UNLOCK(schedule); + + /* Deliver signals before going away */ + if (schedule->signal_tasks) { + schedule_ops.signals_call(schedule, schedule->internal); + schedule->signal_tasks = FALSE; + } + /* 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); + silc_schedule_task_del(schedule, SILC_ALL_TASKS); + silc_schedule_task_remove(schedule, SILC_ALL_TASKS); + + /* Delete timeout task freelist */ + silc_list_start(schedule->free_tasks); + while ((task = silc_list_get(schedule->free_tasks))) + silc_free(task); /* 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_hash_table_free(schedule->fd_queue); - /* Uninit the wakeup */ - silc_schedule_wakeup_uninit(schedule->wakeup); + /* Uninit the platform specific scheduler. */ + schedule_ops.uninit(schedule, schedule->internal); silc_mutex_free(schedule->lock); + silc_free(schedule); return TRUE; } -/* Stops the schedule even if it is not supposed to be stopped yet. - After calling this, one should call silc_schedule_uninit (after the +/* 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_stop(SilcSchedule schedule) { SILC_LOG_DEBUG(("Stopping scheduler")); - silc_mutex_lock(schedule->lock); + SILC_SCHEDULE_LOCK(schedule); schedule->valid = FALSE; - silc_mutex_unlock(schedule->lock); + SILC_SCHEDULE_UNLOCK(schedule); } -/* 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. */ +/* Runs the scheduler once and then returns. Must be called locked. */ -void silc_schedule_set_listen_fd(SilcSchedule schedule, int fd, uint32 iomask) +static SilcBool silc_schedule_iterate(SilcSchedule schedule, int timeout_usecs) { - silc_mutex_lock(schedule->lock); + struct timeval timeout; + int ret; + + do { + SILC_LOG_DEBUG(("In scheduler loop")); + + /* Deliver signals if any has been set to be called */ + if (silc_unlikely(schedule->signal_tasks)) { + SILC_SCHEDULE_UNLOCK(schedule); + schedule_ops.signals_call(schedule, schedule->internal); + schedule->signal_tasks = FALSE; + SILC_SCHEDULE_LOCK(schedule); + } + + /* Check if scheduler is valid */ + if (silc_unlikely(schedule->valid == FALSE)) { + SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting")); + return FALSE; + } + + /* Calculate next timeout for silc_select(). This is the timeout value + when at earliest some of the timeout tasks expire. This may dispatch + already expired timeouts. */ + silc_schedule_select_timeout(schedule); + + /* Check if scheduler is valid */ + if (silc_unlikely(schedule->valid == FALSE)) { + SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting")); + return FALSE; + } + + if (timeout_usecs >= 0) { + timeout.tv_sec = 0; + timeout.tv_usec = timeout_usecs; + schedule->timeout = timeout; + schedule->has_timeout = TRUE; + } + + /* This is the main silc_select(). The program blocks here until some + of the selected file descriptors change status or the selected + timeout expires. */ + SILC_LOG_DEBUG(("Select")); + ret = schedule_ops.schedule(schedule, schedule->internal); + + if (silc_likely(ret == 0)) { + /* Timeout */ + SILC_LOG_DEBUG(("Running timeout tasks")); + if (silc_likely(silc_list_count(schedule->timeout_queue))) + silc_schedule_dispatch_timeout(schedule, FALSE); + continue; + + } else if (silc_likely(ret > 0)) { + /* There is some data available now */ + SILC_LOG_DEBUG(("Running fd tasks")); + silc_schedule_dispatch_fd(schedule); + continue; + + } else { + /* Error or special case handling */ + if (errno == EINTR) + continue; + if (ret == -2) + break; - schedule->fd_list.fd[fd] = iomask; - - if (fd > schedule->fd_list.last_fd) - schedule->fd_list.last_fd = fd; + SILC_LOG_ERROR(("Error in select()/poll(): %s", strerror(errno))); + continue; + } + } while (timeout_usecs == -1); - silc_mutex_unlock(schedule->lock); + return TRUE; } -/* Removes a file descriptor from listen list. */ +/* Runs the scheduler once and then returns. */ -void silc_schedule_unset_listen_fd(SilcSchedule schedule, int fd) +SilcBool silc_schedule_one(SilcSchedule schedule, int timeout_usecs) { - silc_mutex_lock(schedule->lock); + SilcBool ret; + SILC_SCHEDULE_LOCK(schedule); + ret = silc_schedule_iterate(schedule, timeout_usecs); + SILC_SCHEDULE_UNLOCK(schedule); + return ret; +} - schedule->fd_list.fd[fd] = -1; - - if (fd == schedule->fd_list.last_fd) { - int i; +/* Runs the scheduler and blocks here. When this returns the scheduler + has ended. */ - for (i = fd; i >= 0; i--) - if (schedule->fd_list.fd[i] != -1) +#ifndef SILC_SYMBIAN +void silc_schedule(SilcSchedule schedule) +{ + SILC_LOG_DEBUG(("Running scheduler")); + + /* Start the scheduler loop */ + SILC_SCHEDULE_LOCK(schedule); + silc_schedule_iterate(schedule, -1); + SILC_SCHEDULE_UNLOCK(schedule); +} +#endif /* !SILC_SYMBIAN */ + +/* Wakes up the scheduler. This is used only in multi-threaded + environments where threads may add new tasks or remove old tasks + from task queues. This is called to wake up the scheduler in the + main thread so that it detects the changes in the task queues. + If threads support is not compiled in this function has no effect. + Implementation of this function is platform specific. */ + +void silc_schedule_wakeup(SilcSchedule schedule) +{ +#ifdef SILC_THREADS + SILC_LOG_DEBUG(("Wakeup scheduler")); + SILC_SCHEDULE_LOCK(schedule); + schedule_ops.wakeup(schedule, schedule->internal); + SILC_SCHEDULE_UNLOCK(schedule); +#endif +} + +/* Returns the application specific context that was saved into the + scheduler in silc_schedule_init function. The context is also + returned to application in task callback functions, but this function + may be used to get it as well if needed. */ + +void *silc_schedule_get_context(SilcSchedule schedule) +{ + return schedule->app_context; +} + +/* Add new task to the scheduler */ + +SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd, + SilcTaskCallback callback, void *context, + long seconds, long useconds, + SilcTaskType type) +{ + SilcTask task = NULL; + + if (silc_unlikely(!schedule->valid)) + return NULL; + + SILC_SCHEDULE_LOCK(schedule); + + if (silc_likely(type == SILC_TASK_TIMEOUT)) { + SilcTaskTimeout tmp, prev, ttask; + SilcList list; + + silc_list_start(schedule->free_tasks); + ttask = silc_list_get(schedule->free_tasks); + if (silc_unlikely(!ttask)) { + ttask = silc_calloc(1, sizeof(*ttask)); + if (silc_unlikely(!ttask)) + goto out; + } else + silc_list_del(schedule->free_tasks, ttask); + + ttask->header.type = 1; + ttask->header.callback = callback; + ttask->header.context = context; + ttask->header.valid = TRUE; + + /* Add timeout */ + silc_gettimeofday(&ttask->timeout); + if ((seconds + useconds) > 0) { + ttask->timeout.tv_sec += seconds + (useconds / 1000000L); + ttask->timeout.tv_usec += (useconds % 1000000L); + if (ttask->timeout.tv_usec >= 1000000L) { + ttask->timeout.tv_sec += 1; + ttask->timeout.tv_usec -= 1000000L; + } + } + + SILC_LOG_DEBUG(("New timeout task %p: sec=%d, usec=%d", ttask, + seconds, useconds)); + + /* Add task to correct spot so that the first task in the list has + the earliest timeout. */ + list = schedule->timeout_queue; + silc_list_start(list); + prev = NULL; + while ((tmp = silc_list_get(list)) != SILC_LIST_END) { + /* If we have shorter timeout, we have found our spot */ + if (silc_compare_timeval(&ttask->timeout, &tmp->timeout) < 0) { + silc_list_insert(schedule->timeout_queue, prev, ttask); break; + } + prev = tmp; + } + if (!tmp) + silc_list_add(schedule->timeout_queue, ttask); + + task = (SilcTask)ttask; + + } else if (silc_likely(type == SILC_TASK_FD)) { + SilcTaskFd ftask; + + /* Check if fd is already added */ + if (silc_unlikely(silc_hash_table_find(schedule->fd_queue, + SILC_32_TO_PTR(fd), + NULL, (void *)&task))) { + if (task->valid) + goto out; + + /* Remove invalid task. We must have unique fd key to hash table. */ + silc_schedule_task_remove(schedule, task); + } + + /* Check max tasks */ + if (silc_unlikely(schedule->max_tasks > 0 && + silc_hash_table_count(schedule->fd_queue) >= + schedule->max_tasks)) { + SILC_LOG_WARNING(("Scheduler task limit reached: cannot add new task")); + task = NULL; + goto out; + } + + ftask = silc_calloc(1, sizeof(*ftask)); + if (silc_unlikely(!ftask)) { + task = NULL; + goto out; + } + + SILC_LOG_DEBUG(("New fd task %p fd=%d", ftask, fd)); + + ftask->header.type = 0; + ftask->header.callback = callback; + ftask->header.context = context; + ftask->header.valid = TRUE; + ftask->events = SILC_TASK_READ; + ftask->fd = fd; + + /* Add task and schedule it */ + if (!silc_hash_table_add(schedule->fd_queue, SILC_32_TO_PTR(fd), ftask)) { + silc_free(ftask); + task = NULL; + goto out; + } + if (!schedule_ops.schedule_fd(schedule, schedule->internal, + ftask, ftask->events)) { + silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(fd)); + task = NULL; + goto out; + } + + task = (SilcTask)ftask; + + } else if (silc_unlikely(type == SILC_TASK_SIGNAL)) { + SILC_SCHEDULE_UNLOCK(schedule); + schedule_ops.signal_register(schedule, schedule->internal, fd, + callback, context); + return NULL; + } + + out: + SILC_SCHEDULE_UNLOCK(schedule); - schedule->fd_list.last_fd = i < 0 ? 0 : i; +#ifdef SILC_SYMBIAN + /* On symbian we wakeup scheduler immediately after adding timeout task + in case the task is added outside the scheduler loop (in some active + object). */ + if (task && task->type == 1) + silc_schedule_wakeup(schedule); +#endif /* SILC_SYMBIAN */ + + return task; +} + +/* Invalidates task */ + +SilcBool silc_schedule_task_del(SilcSchedule schedule, SilcTask task) +{ + if (silc_unlikely(task == SILC_ALL_TASKS)) { + SilcHashTableList htl; + + SILC_LOG_DEBUG(("Unregister all tasks")); + + SILC_SCHEDULE_LOCK(schedule); + + /* Delete from fd queue */ + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, NULL, (void *)&task)) + task->valid = FALSE; + silc_hash_table_list_reset(&htl); + + /* Delete from timeout queue */ + silc_list_start(schedule->timeout_queue); + while ((task = (SilcTask)silc_list_get(schedule->timeout_queue)) + != SILC_LIST_END) + task->valid = FALSE; + + SILC_SCHEDULE_UNLOCK(schedule); + return TRUE; } - silc_mutex_unlock(schedule->lock); + SILC_LOG_DEBUG(("Unregistering task %p", task)); + SILC_SCHEDULE_LOCK(schedule); + task->valid = FALSE; + SILC_SCHEDULE_UNLOCK(schedule); + + return TRUE; } -/* 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. */ -/* This must be called holding the schedule->lock and the - schedule->fd_queue->lock. */ - -#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))) { \ - silc_mutex_unlock(queue->lock); \ - silc_mutex_unlock(schedule->lock); \ - task->callback(queue, SILC_TASK_READ, task->context, task->fd); \ - silc_mutex_lock(schedule->lock); \ - silc_mutex_lock(queue->lock); \ - is_run = TRUE; \ - } \ - } \ - \ - if (task->valid) { \ - /* Task ready for writing */ \ - if ((FD_ISSET(task->fd, &schedule->out)) && \ - (task->iomask & (1L << SILC_TASK_WRITE))) { \ - silc_mutex_unlock(queue->lock); \ - silc_mutex_unlock(schedule->lock); \ - task->callback(queue, SILC_TASK_WRITE, task->context, task->fd); \ - silc_mutex_lock(schedule->lock); \ - silc_mutex_lock(queue->lock); \ - 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. */ -/* This must be called holding schedule->lock. */ - -#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) +/* Invalidate task by fd */ -/* 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. */ -/* This must be called with holding the schedule->lock and the - schedule->timeout_queue->lock */ - -#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))) { \ - silc_mutex_unlock(queue->lock); \ - silc_mutex_unlock(schedule->lock); \ - task->callback(queue, SILC_TASK_READ, \ - task->context, task->fd); \ - silc_mutex_lock(schedule->lock); \ - silc_mutex_lock(queue->lock); \ - } \ - } \ - \ - /* Task ready for writing */ \ - if (task->valid) { \ - if ((task->iomask & (1L << SILC_TASK_WRITE))) { \ - silc_mutex_unlock(queue->lock); \ - silc_mutex_unlock(schedule->lock); \ - task->callback(queue, SILC_TASK_WRITE, \ - task->context, task->fd); \ - silc_mutex_lock(schedule->lock); \ - silc_mutex_lock(queue->lock); \ - } \ - } \ - \ - /* 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. */ -/* This must be called with holding the schedule->lock and the - schedule->timeout_queue->lock */ - -#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 */ \ - silc_gettimeofday(&curtime); \ - 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. */ -/* This must be called holding the schedule->lock and the - schedule->generic_queue->lock. */ - -#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))) { \ - silc_mutex_unlock(queue->lock); \ - silc_mutex_unlock(schedule->lock); \ - task->callback(queue, SILC_TASK_READ, \ - task->context, i); \ - silc_mutex_lock(schedule->lock); \ - silc_mutex_lock(queue->lock); \ - } \ - } \ - \ - if (task->valid && schedule->fd_list.fd[i] != -1) { \ - /* Task ready for writing */ \ - if ((schedule->fd_list.fd[i] & (1L << SILC_TASK_WRITE))) { \ - silc_mutex_unlock(queue->lock); \ - silc_mutex_unlock(schedule->lock); \ - task->callback(queue, SILC_TASK_WRITE, \ - task->context, i); \ - silc_mutex_lock(schedule->lock); \ - silc_mutex_lock(queue->lock); \ - } \ - } \ - \ - 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) +SilcBool silc_schedule_task_del_by_fd(SilcSchedule schedule, SilcUInt32 fd) { - struct timeval timeout; - int is_run, i; - SilcTask task; - SilcTaskQueue queue; - struct timeval curtime; - int ret; + SilcTask task = NULL; + SilcBool ret = FALSE; - SILC_LOG_DEBUG(("In scheduler loop")); + SILC_LOG_DEBUG(("Unregister task by fd %d", fd)); - if (!schedule->is_locked) - silc_mutex_lock(schedule->lock); + SILC_SCHEDULE_LOCK(schedule); - /* 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")); - if (!schedule->is_locked) - silc_mutex_unlock(schedule->lock); - return FALSE; + /* fd is unique, so there is only one task with this fd in the table */ + if (silc_likely(silc_hash_table_find(schedule->fd_queue, + SILC_32_TO_PTR(fd), NULL, + (void *)&task))) { + SILC_LOG_DEBUG(("Deleting task %p", task)); + task->valid = FALSE; + ret = TRUE; } - /* Clear everything */ - FD_ZERO(&schedule->in); - FD_ZERO(&schedule->out); - schedule->max_fd = -1; - is_run = FALSE; - - /* Calculate next timeout for silc_select(). This is the timeout value - when at earliest some of the timeout tasks expire. */ - silc_mutex_lock(schedule->timeout_queue->lock); - SILC_SCHEDULE_SELECT_TIMEOUT; - silc_mutex_unlock(schedule->timeout_queue->lock); - - /* Add the file descriptors to the fd sets. These are the non-timeout - tasks. The silc_select() listens to these file descriptors. */ - SILC_SCHEDULE_SELECT_TASKS; - - if (schedule->max_fd == -1 && !schedule->timeout) { - if (!schedule->is_locked) - silc_mutex_unlock(schedule->lock); - return FALSE; + SILC_SCHEDULE_UNLOCK(schedule); + + /* If it is signal, remove it */ + if (silc_unlikely(!task)) { + schedule_ops.signal_unregister(schedule, schedule->internal, fd); + ret = TRUE; } - if (schedule->timeout) { - SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule->timeout->tv_sec, - schedule->timeout->tv_usec)); + return ret; +} + +/* Invalidate task by task callback. */ + +SilcBool silc_schedule_task_del_by_callback(SilcSchedule schedule, + SilcTaskCallback callback) +{ + SilcTask task; + SilcHashTableList htl; + SilcList list; + SilcBool ret = FALSE; + + SILC_LOG_DEBUG(("Unregister task by callback")); + + SILC_SCHEDULE_LOCK(schedule); + + /* Delete from fd queue */ + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, NULL, (void *)&task)) { + if (task->callback == callback) { + task->valid = FALSE; + ret = TRUE; + } + } + silc_hash_table_list_reset(&htl); + + /* Delete from timeout queue */ + list = schedule->timeout_queue; + silc_list_start(list); + while ((task = (SilcTask)silc_list_get(list))) { + if (task->callback == callback) { + task->valid = FALSE; + ret = TRUE; + } } - if (timeout_usecs >= 0) { - timeout.tv_sec = 0; - timeout.tv_usec = timeout_usecs; - schedule->timeout = &timeout; + SILC_SCHEDULE_UNLOCK(schedule); + + return ret; +} + +/* Invalidate task by context. */ + +SilcBool silc_schedule_task_del_by_context(SilcSchedule schedule, + void *context) +{ + SilcTask task; + SilcHashTableList htl; + SilcList list; + SilcBool ret = FALSE; + + SILC_LOG_DEBUG(("Unregister task by context")); + + SILC_SCHEDULE_LOCK(schedule); + + /* Delete from fd queue */ + silc_hash_table_list(schedule->fd_queue, &htl); + while (silc_hash_table_get(&htl, NULL, (void *)&task)) { + if (task->context == context) { + task->valid = FALSE; + ret = TRUE; + } + } + silc_hash_table_list_reset(&htl); + + /* Delete from timeout queue */ + list = schedule->timeout_queue; + silc_list_start(list); + while ((task = (SilcTask)silc_list_get(list))) { + if (task->context == context) { + ret = TRUE; + task->valid = FALSE; + } } - silc_mutex_unlock(schedule->lock); + SILC_SCHEDULE_UNLOCK(schedule); - /* 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")); - ret = silc_select(schedule->max_fd + 1, &schedule->in, - &schedule->out, 0, schedule->timeout); + return ret; +} - silc_mutex_lock(schedule->lock); +/* Invalidate task by all */ - switch (ret) { - 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")); - silc_mutex_lock(schedule->timeout_queue->lock); - silc_gettimeofday(&curtime); - SILC_SCHEDULE_RUN_TIMEOUT_TASKS; - silc_mutex_unlock(schedule->timeout_queue->lock); - break; - default: - /* There is some data available now */ - SILC_LOG_DEBUG(("Running non-timeout tasks")); - silc_mutex_lock(schedule->fd_queue->lock); - SILC_SCHEDULE_RUN_TASKS; - silc_mutex_unlock(schedule->fd_queue->lock); - - silc_mutex_lock(schedule->generic_queue->lock); - SILC_SCHEDULE_RUN_GENERIC_TASKS; - silc_mutex_unlock(schedule->generic_queue->lock); - break; +SilcBool silc_schedule_task_del_by_all(SilcSchedule schedule, int fd, + SilcTaskCallback callback, + void *context) +{ + SilcTask task; + SilcList list; + SilcBool ret = FALSE; + + SILC_LOG_DEBUG(("Unregister task by fd, callback and context")); + + /* For fd task, callback and context is irrelevant as fd is unique */ + if (fd) + return silc_schedule_task_del_by_fd(schedule, fd); + + SILC_SCHEDULE_LOCK(schedule); + + /* Delete from timeout queue */ + list = schedule->timeout_queue; + silc_list_start(list); + while ((task = (SilcTask)silc_list_get(list))) { + if (task->callback == callback && task->context == context) { + task->valid = FALSE; + ret = TRUE; + } } - if (!schedule->is_locked) - silc_mutex_unlock(schedule->lock); + SILC_SCHEDULE_UNLOCK(schedule); return TRUE; } -/* 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. */ +/* Sets a file descriptor to be listened by scheduler. One can call this + directly if wanted. This can be called multiple times for one file + descriptor to set different iomasks. */ -void silc_schedule(SilcSchedule schedule) +SilcBool silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd, + SilcTaskEvent mask, SilcBool send_events) { - SILC_LOG_DEBUG(("Running scheduler")); + SilcTaskFd task; - if (schedule->valid == FALSE) { - SILC_LOG_ERROR(("Scheduler is not valid, stopping")); - return; + if (silc_unlikely(!schedule->valid)) + return FALSE; + + SILC_SCHEDULE_LOCK(schedule); + + if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), + NULL, (void *)&task)) { + if (!schedule_ops.schedule_fd(schedule, schedule->internal, task, mask)) { + SILC_SCHEDULE_UNLOCK(schedule); + return FALSE; + } + task->events = mask; + if (silc_unlikely(send_events) && mask) { + task->revents = mask; + silc_schedule_dispatch_fd(schedule); + } } - silc_mutex_lock(schedule->lock); - schedule->is_locked = TRUE; + SILC_SCHEDULE_UNLOCK(schedule); - /* Start the scheduler loop */ - while (silc_schedule_one(schedule, -1)) - ; + return TRUE; +} + +/* Returns the file descriptor's current requested event mask. */ - silc_mutex_unlock(schedule->lock); +SilcTaskEvent silc_schedule_get_fd_events(SilcSchedule schedule, + SilcUInt32 fd) +{ + SilcTaskFd task; + SilcTaskEvent event = 0; + + if (silc_unlikely(!schedule->valid)) + return 0; + + SILC_SCHEDULE_LOCK(schedule); + if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), + NULL, (void *)&task)) + event = task->events; + SILC_SCHEDULE_UNLOCK(schedule); + + return event; } -/* Wakes up the scheduler. This is used only in multi-threaded - environments where threads may add new tasks or remove old tasks - from task queues. This is called to wake up the scheduler in the - main thread so that it detects the changes in the task queues. - If threads support is not compiled in this function has no effect. - Implementation of this function is platform specific. */ +/* Removes a file descriptor from listen list. */ -void silc_schedule_wakeup(SilcSchedule schedule) +void silc_schedule_unset_listen_fd(SilcSchedule schedule, SilcUInt32 fd) { -#ifdef SILC_THREADS - SILC_LOG_DEBUG(("Wakeup scheduler")); - silc_mutex_lock(schedule->lock); - silc_schedule_wakeup_internal(schedule->wakeup); - silc_mutex_unlock(schedule->lock); -#endif + silc_schedule_set_listen_fd(schedule, fd, 0, FALSE); }