/* $Id$ */
#include "silcincludes.h"
-#include "silcschedule_i.h"
-/* Forward declarations */
-typedef struct SilcTaskQueueStruct *SilcTaskQueue;
-
-/* System specific routines. Implemented under unix/, win32/ and such. */
-
-/* System specific select(). Returns same values as normal select(). */
-int silc_select(SilcScheduleFd fds, SilcUInt32 fds_count,
- struct timeval *timeout);
-
-/* Initializes the platform specific scheduler. This for example initializes
- the wakeup mechanism of the scheduler. In multi-threaded environment
- the scheduler needs to be wakenup 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 *context);
-
-/* Uninitializes the platform specific scheduler context. */
-void silc_schedule_internal_uninit(void *context);
-
-/* Wakes up the scheduler. This is platform specific routine */
-void silc_schedule_internal_wakeup(void *context);
-
-/* Register signal */
-void silc_schedule_internal_signal_register(void *context,
- SilcUInt32 signal,
- SilcTaskCallback callback,
- void *callback_context);
-
-/* Unregister signal */
-void silc_schedule_internal_signal_unregister(void *context,
- SilcUInt32 signal,
- SilcTaskCallback callback,
- void *callback_context);
-
-/* Mark signal to be called later. */
-void silc_schedule_internal_signal_call(void *context, SilcUInt32 signal);
-
-/* Call all signals */
-void silc_schedule_internal_signals_call(void *context,
- SilcSchedule schedule);
-
-/* Block registered signals in scheduler. */
-void silc_schedule_internal_signals_block(void *context);
-
-/* Unblock registered signals in schedule. */
-void silc_schedule_internal_signals_unblock(void *context);
-
-/* Internal task management routines. */
+/* Platform specific implementation */
+extern const SilcScheduleOps schedule_ops;
+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,
bool dispatch_all);
-static void silc_task_queue_alloc(SilcTaskQueue *queue);
-static void silc_task_queue_free(SilcTaskQueue queue);
-static SilcTask silc_task_find(SilcTaskQueue queue, SilcUInt32 fd);
-static SilcTask silc_task_add(SilcTaskQueue queue, SilcTask newtask,
- SilcTaskPriority priority);
-static SilcTask silc_task_get_first(SilcTaskQueue queue, SilcTask first);
-static SilcTask silc_task_add_timeout(SilcTaskQueue queue, SilcTask newtask,
- SilcTaskPriority priority);
-static int silc_schedule_task_remove(SilcTaskQueue queue, SilcTask task);
-static void silc_task_del_by_context(SilcTaskQueue queue, void *context);
-static void silc_task_del_by_callback(SilcTaskQueue queue,
- SilcTaskCallback callback);
-static void silc_task_del_by_fd(SilcTaskQueue queue, SilcUInt32 fd);
-
-/* Returns the task queue by task type */
-#define SILC_SCHEDULE_GET_QUEUE(type) \
- (type == SILC_TASK_FD ? schedule->fd_queue : \
- type == SILC_TASK_TIMEOUT ? schedule->timeout_queue : \
- schedule->generic_queue)
-
-/* Locks. These also blocks signals that we care about and thus guarantee
- that while we are in scheduler no signals can happen. This way we can
- synchronise signals with SILC Scheduler. */
-#define SILC_SCHEDULE_LOCK(schedule) \
-do { \
- silc_schedule_internal_signals_block(schedule->internal); \
- silc_mutex_lock(schedule->lock); \
-} while (0)
-#define SILC_SCHEDULE_UNLOCK(schedule) \
-do { \
- silc_mutex_unlock(schedule->lock); \
- silc_schedule_internal_signals_unblock(schedule->internal); \
-} while (0)
-
-/* SILC Task object. Represents one task in the scheduler. */
-struct SilcTaskStruct {
- SilcUInt32 fd;
- SilcTaskCallback callback; /* Task callback */
- void *context; /* Task callback context */
- struct timeval timeout; /* Set for timeout tasks */
- unsigned int valid : 1; /* Set when task is valid */
- unsigned int priority : 2; /* Priority of the task */
- unsigned int type : 5; /* Type of the task */
-
- /* Pointers forming doubly linked circular list */
- struct SilcTaskStruct *next;
- struct SilcTaskStruct *prev;
-};
-
-/* SILC Task Queue object. The queue holds all the tasks in the scheduler.
- There are always three task queues in the scheduler. One for non-timeout
- tasks (fd tasks performing tasks over specified file descriptor),
- one for timeout tasks and one for generic tasks. */
-struct SilcTaskQueueStruct {
- SilcTask task; /* Pointer to all tasks */
- struct timeval timeout; /* Current timeout */
- SILC_MUTEX_DEFINE(lock); /* Queue's lock */
-};
-
-/*
- SILC Scheduler structure.
-
- 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.
-
- Following short description of the fields:
-
- SilcTaskQueue fd_queue
-
- 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.
-
- SilcTaskQueue timeout_queue
-
- 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.
- SilcTaskQueue generic_queue
+/* Fd task hash table destructor */
- 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.
-
- SilcScheduleFd fd_list
-
- List of file descriptors the scheduler is supposed to be listenning.
- This is updated internally.
-
- SilcUInt32 max_fd
- SilcUInt32 last_fd
-
- Size of the fd_list list. There can be `max_fd' many tasks in
- the scheduler at once. The `last_fd' is the last valid entry
- in the fd_list.
-
- struct timeval *timeout;
-
- Pointer to the schedules next timeout. Value of this timeout is
- automatically updated in the silc_schedule function.
-
- bool valid
-
- 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.
-
- fd_set in
- fd_set out
-
- File descriptor sets for select(). These are automatically managed
- by the scheduler and should not be touched otherwise.
-
- void *internal
-
- System specific scheduler context.
-
- SILC_MUTEX_DEFINE(lock)
-
- Scheduler lock.
-
- bool signal_tasks
-
- TRUE when tasks has been registered from signals. Next round in
- scheduler will call the callbacks when this is TRUE.
-
-*/
-struct SilcScheduleStruct {
- void *app_context; /* Application specific context */
- SilcTaskQueue fd_queue;
- SilcTaskQueue timeout_queue;
- SilcTaskQueue generic_queue;
- SilcScheduleFd fd_list;
- SilcUInt32 max_fd;
- SilcUInt32 last_fd;
- struct timeval *timeout;
- bool valid;
- void *internal;
- SILC_MUTEX_DEFINE(lock);
- bool is_locked;
- bool signal_tasks;
-};
+static void silc_schedule_fd_destructor(void *key, void *context,
+ void *user_context)
+{
+ silc_free(context);
+}
/* Initializes the scheduler. This returns the scheduler context that
is given as arugment usually to all silc_schedule_* functions.
SILC_LOG_DEBUG(("Initializing scheduler"));
schedule = silc_calloc(1, sizeof(*schedule));
+ if (!schedule)
+ return NULL;
- /* Allocate three task queues, one for file descriptor based tasks,
- one for timeout tasks and one for generic tasks. */
- silc_task_queue_alloc(&schedule->fd_queue);
- silc_task_queue_alloc(&schedule->timeout_queue);
- silc_task_queue_alloc(&schedule->generic_queue);
+ schedule->fd_queue =
+ silc_hash_table_alloc(0, silc_hash_uint, NULL, NULL, NULL,
+ silc_schedule_fd_destructor, NULL, TRUE);
+ if (!schedule->fd_queue)
+ return NULL;
- if (!max_tasks)
- max_tasks = 200;
+ silc_list_init(schedule->timeout_queue, struct SilcTaskTimeoutStruct, next);
- /* Initialize the scheduler */
- schedule->fd_list = silc_calloc(max_tasks, sizeof(*schedule->fd_list));
- schedule->max_fd = max_tasks;
- schedule->timeout = NULL;
- schedule->valid = TRUE;
schedule->app_context = app_context;
+ schedule->valid = TRUE;
+ schedule->max_tasks = max_tasks;
/* Allocate scheduler lock */
silc_mutex_alloc(&schedule->lock);
/* Initialize the platform specific scheduler. */
- schedule->internal = silc_schedule_internal_init(schedule, app_context);
+ schedule->internal = schedule_ops.init(schedule, app_context);
return schedule;
}
/* Dispatch all timeouts before going away */
SILC_SCHEDULE_LOCK(schedule);
- silc_mutex_lock(schedule->timeout_queue->lock);
silc_schedule_dispatch_timeout(schedule, TRUE);
- silc_mutex_unlock(schedule->timeout_queue->lock);
SILC_SCHEDULE_UNLOCK(schedule);
/* Deliver signals before going away */
if (schedule->signal_tasks) {
- silc_schedule_internal_signals_call(schedule->internal, schedule);
+ schedule_ops.signals_call(schedule, schedule->internal);
schedule->signal_tasks = FALSE;
}
/* Unregister all tasks */
- silc_schedule_task_remove(schedule->fd_queue, SILC_ALL_TASKS);
- silc_schedule_task_remove(schedule->timeout_queue, SILC_ALL_TASKS);
- silc_schedule_task_remove(schedule->generic_queue, SILC_ALL_TASKS);
+ silc_schedule_task_remove(schedule, SILC_ALL_TASKS);
+ silc_schedule_task_remove(schedule, SILC_ALL_TASKS);
/* Unregister all task queues */
- silc_task_queue_free(schedule->fd_queue);
- silc_task_queue_free(schedule->timeout_queue);
- silc_task_queue_free(schedule->generic_queue);
-
- silc_free(schedule->fd_list);
+ silc_hash_table_free(schedule->fd_queue);
/* Uninit the platform specific scheduler. */
- silc_schedule_internal_uninit(schedule->internal);
+ schedule_ops.uninit(schedule, schedule->internal);
silc_mutex_free(schedule->lock);
silc_free(schedule);
return TRUE;
}
-/* Enlarge the capabilities of the scheduler to handle tasks to `max_tasks'. */
-
-bool silc_schedule_reinit(SilcSchedule schedule, int max_tasks)
-{
- SILC_SCHEDULE_LOCK(schedule);
- if (schedule->max_fd <= max_tasks)
- return FALSE;
- schedule->fd_list = silc_realloc(schedule->fd_list,
- (sizeof(*schedule->fd_list) * max_tasks));
- schedule->max_fd = max_tasks;
- SILC_SCHEDULE_UNLOCK(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
silc_schedule has returned). */
SILC_SCHEDULE_UNLOCK(schedule);
}
-/* Executes nontimeout tasks. It then checks whether any of ther fd tasks
- was signaled by the silc_select. If some task was not signaled then
- all generic tasks are executed for that task. The generic tasks are
- never executed for task that has explicit fd task set. */
-/* This holds the schedule->lock and the queue locks. */
+/* Executes file descriptor tasks. Invalid tasks are removed here. */
-static void silc_schedule_dispatch_nontimeout(SilcSchedule schedule)
+static void silc_schedule_dispatch_fd(SilcSchedule schedule)
{
- SilcTask task;
- int i;
- SilcUInt32 fd, last_fd = schedule->last_fd;
- SilcUInt16 revents;
-
- for (i = 0; i <= last_fd; i++) {
- if (schedule->fd_list[i].events == 0)
- continue;
-
- /* First check whether this fd has task in the fd queue */
- silc_mutex_lock(schedule->fd_queue->lock);
- fd = schedule->fd_list[i].fd;
- task = silc_task_find(schedule->fd_queue, fd);
- revents = schedule->fd_list[i].revents;
-
- /* If the task was found then execute its callbacks. If not then
- execute all generic tasks for that fd. */
- if (task) {
- /* 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. */
-
- /* Is the task ready for reading */
- if (task->valid && revents & SILC_TASK_READ) {
- silc_mutex_unlock(schedule->fd_queue->lock);
- SILC_SCHEDULE_UNLOCK(schedule);
- task->callback(schedule, schedule->app_context,
- SILC_TASK_READ, task->fd, task->context);
- SILC_SCHEDULE_LOCK(schedule);
- silc_mutex_lock(schedule->fd_queue->lock);
- }
-
- /* Is the task ready for writing */
- if (task->valid && revents & SILC_TASK_WRITE) {
- silc_mutex_unlock(schedule->fd_queue->lock);
- SILC_SCHEDULE_UNLOCK(schedule);
- task->callback(schedule, schedule->app_context,
- SILC_TASK_WRITE, task->fd, task->context);
- SILC_SCHEDULE_LOCK(schedule);
- silc_mutex_lock(schedule->fd_queue->lock);
- }
-
- if (!task->valid)
- silc_schedule_task_remove(schedule->fd_queue, task);
-
- silc_mutex_unlock(schedule->fd_queue->lock);
- } else {
- /* Run generic tasks for this fd. */
+ SilcHashTableList htl;
+ SilcTask t;
+ SilcTaskFd task;
+ SilcUInt32 fd;
- silc_mutex_unlock(schedule->fd_queue->lock);
+ silc_hash_table_list(schedule->fd_queue, &htl);
+ while (silc_hash_table_get(&htl, (void **)&fd, (void **)&task)) {
+ t = (SilcTask)task;
- silc_mutex_lock(schedule->generic_queue->lock);
- if (!schedule->generic_queue->task) {
- silc_mutex_unlock(schedule->generic_queue->lock);
- continue;
- }
+ if (!t->valid) {
+ silc_schedule_task_remove(schedule, t);
+ continue;
+ }
+ if (!task->events || !task->revents)
+ continue;
- task = schedule->generic_queue->task;
- while(1) {
- /* Validity of the task and fd is checked always before and after
- execution beacuse the task might have been unregistered
- in the callback function, ie. it is not valid anymore. */
-
- /* Is the task ready for reading */
- if (task->valid && revents & SILC_TASK_READ &&
- fd == schedule->fd_list[i].fd) {
- silc_mutex_unlock(schedule->generic_queue->lock);
- SILC_SCHEDULE_UNLOCK(schedule);
- task->callback(schedule, schedule->app_context,
- SILC_TASK_READ, fd, task->context);
- SILC_SCHEDULE_LOCK(schedule);
- silc_mutex_lock(schedule->generic_queue->lock);
- }
-
- /* Is the task ready for writing */
- if (task->valid && revents & SILC_TASK_WRITE &&
- fd == schedule->fd_list[i].fd) {
- silc_mutex_unlock(schedule->generic_queue->lock);
- SILC_SCHEDULE_UNLOCK(schedule);
- task->callback(schedule, schedule->app_context,
- SILC_TASK_WRITE, fd, task->context);
- SILC_SCHEDULE_LOCK(schedule);
- silc_mutex_lock(schedule->generic_queue->lock);
- }
-
- if (!task->valid) {
- /* Invalid (unregistered) tasks are removed from the
- task queue. */
- if (schedule->generic_queue->task == task->next) {
- silc_schedule_task_remove(schedule->generic_queue, task);
- silc_mutex_unlock(schedule->generic_queue->lock);
- break;
- }
-
- task = task->next;
- silc_schedule_task_remove(schedule->generic_queue, task);
- continue;
- }
-
- /* Break if there isn't more tasks in the queue */
- if (schedule->generic_queue->task == task->next)
- break;
-
- task = task->next;
- }
+ /* Is the task ready for reading */
+ if (task->revents & SILC_TASK_READ) {
+ SILC_SCHEDULE_UNLOCK(schedule);
+ t->callback(schedule, schedule->app_context, SILC_TASK_READ,
+ task->fd, t->context);
+ SILC_SCHEDULE_LOCK(schedule);
+ }
- silc_mutex_unlock(schedule->generic_queue->lock);
+ /* Is the task ready for writing */
+ if (t->valid && task->revents & SILC_TASK_WRITE) {
+ SILC_SCHEDULE_UNLOCK(schedule);
+ t->callback(schedule, schedule->app_context, SILC_TASK_WRITE,
+ task->fd, t->context);
+ SILC_SCHEDULE_LOCK(schedule);
}
+
+ /* Remove if task was invalidated in the task callback */
+ if (!t->valid)
+ silc_schedule_task_remove(schedule, t);
}
+ silc_hash_table_list_reset(&htl);
}
/* 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. We don't have to care about priorities because
- tasks are already sorted in their priority order at the registration
- phase. */
-/* This holds the schedule->lock and the schedule->timeout_queue->lock */
+ tasks are removed here. */
static void silc_schedule_dispatch_timeout(SilcSchedule schedule,
bool dispatch_all)
{
- SilcTaskQueue queue = schedule->timeout_queue;
- SilcTask task;
+ SilcTask t;
+ SilcTaskTimeout task;
struct timeval curtime;
+ int count = 0;
SILC_LOG_DEBUG(("Running timeout tasks"));
silc_gettimeofday(&curtime);
- queue = schedule->timeout_queue;
- if (queue && 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 (dispatch_all ||
- silc_compare_timeval(&task->timeout, &curtime)) {
- if (task->valid) {
- silc_mutex_unlock(queue->lock);
- SILC_SCHEDULE_UNLOCK(schedule);
- task->callback(schedule, schedule->app_context,
- SILC_TASK_EXPIRE, task->fd, task->context);
- SILC_SCHEDULE_LOCK(schedule);
- silc_mutex_lock(queue->lock);
- }
-
- /* Break if there isn't more tasks in the queue */
- if (queue->task == task->next) {
- silc_schedule_task_remove(queue, task);
- break;
- }
-
- task = task->next;
-
- /* Remove the task from queue */
- silc_schedule_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;
- }
+ /* First task in the task queue has always the earliest timeout. */
+ silc_list_start(schedule->timeout_queue);
+ while ((task = silc_list_get(schedule->timeout_queue)) != SILC_LIST_END) {
+ t = (SilcTask)task;
+
+ /* Remove invalid task */
+ if (!t->valid) {
+ silc_schedule_task_remove(schedule, t);
+ continue;
+ }
+
+ /* Execute the task if the timeout has expired */
+ if (dispatch_all || silc_compare_timeval(&task->timeout, &curtime)) {
+ SILC_SCHEDULE_UNLOCK(schedule);
+ t->callback(schedule, schedule->app_context, SILC_TASK_EXPIRE, 0,
+ t->context);
+ SILC_SCHEDULE_LOCK(schedule);
+
+ /* Remove the expired task */
+ silc_schedule_task_remove(schedule, t);
+
+ /* Balance when we have lots of small timeouts */
+ if ((++count) > 50)
+ break;
}
}
}
-/* 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 holds the schedule->lock and the schedule->timeout_queue->lock */
+/* 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. */
static void silc_schedule_select_timeout(SilcSchedule schedule)
{
- SilcTaskQueue queue = schedule->timeout_queue;
- SilcTask task;
+ SilcTask t;
+ SilcTaskTimeout task;
struct timeval curtime;
+ bool dispatch = TRUE;
/* 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_compare_timeval(&task->timeout, &curtime)) {
- silc_schedule_dispatch_timeout(schedule, FALSE);
-
- /* 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;
- }
+ schedule->has_timeout = FALSE;
- /* 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;
- }
+ /* First task in the task queue has always the earliest timeout. */
+ silc_list_start(schedule->timeout_queue);
+ while ((task = silc_list_get(schedule->timeout_queue)) != SILC_LIST_END) {
+ t = (SilcTask)task;
- /* We've got the timeout value */
- break;
- } else {
- /* Task is not valid, remove it and try next one. */
- silc_schedule_task_remove(queue, task);
- task = queue->task;
- if (queue->task == NULL)
- break;
+ /* Remove invalid task */
+ if (!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) && dispatch) {
+ silc_schedule_dispatch_timeout(schedule, FALSE);
+ if (!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;
}
/* Save the timeout */
if (task) {
- schedule->timeout = &queue->timeout;
- SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule->timeout->tv_sec,
- schedule->timeout->tv_usec));
+ schedule->timeout = curtime;
+ schedule->has_timeout = TRUE;
+ SILC_LOG_DEBUG(("timeout: sec=%d, usec=%d", schedule->timeout.tv_sec,
+ schedule->timeout.tv_usec));
}
}
/* Deliver signals if any has been set to be called */
if (schedule->signal_tasks) {
SILC_SCHEDULE_UNLOCK(schedule);
- silc_schedule_internal_signals_call(schedule->internal, schedule);
+ schedule_ops.signals_call(schedule, schedule->internal);
schedule->signal_tasks = FALSE;
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) {
+ /* Check if scheduler is valid */
+ if (schedule->valid == FALSE) {
SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting"));
if (!schedule->is_locked)
SILC_SCHEDULE_UNLOCK(schedule);
return FALSE;
}
- /* 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) {
+ /* 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 (schedule->valid == FALSE) {
SILC_LOG_DEBUG(("Scheduler not valid anymore, exiting"));
if (!schedule->is_locked)
SILC_SCHEDULE_UNLOCK(schedule);
return 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(schedule);
- silc_mutex_unlock(schedule->timeout_queue->lock);
-
if (timeout_usecs >= 0) {
timeout.tv_sec = 0;
timeout.tv_usec = timeout_usecs;
- schedule->timeout = &timeout;
+ schedule->timeout = timeout;
+ schedule->has_timeout = TRUE;
}
- SILC_SCHEDULE_UNLOCK(schedule);
-
- /* This is the main select(). The program blocks here until some
+ /* 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 = silc_select(schedule->fd_list, schedule->last_fd + 1,
- schedule->timeout);
-
- SILC_SCHEDULE_LOCK(schedule);
+ ret = schedule_ops.select(schedule, schedule->internal);
switch (ret) {
case -1:
break;
case 0:
/* Timeout */
- silc_mutex_lock(schedule->timeout_queue->lock);
+ SILC_LOG_DEBUG(("Running timeout tasks"));
silc_schedule_dispatch_timeout(schedule, FALSE);
- silc_mutex_unlock(schedule->timeout_queue->lock);
break;
default:
/* There is some data available now */
- SILC_LOG_DEBUG(("Running non-timeout tasks"));
- silc_schedule_dispatch_nontimeout(schedule);
+ SILC_LOG_DEBUG(("Running fd tasks"));
+ silc_schedule_dispatch_fd(schedule);
break;
}
#ifdef SILC_THREADS
SILC_LOG_DEBUG(("Wakeup scheduler"));
SILC_SCHEDULE_LOCK(schedule);
- silc_schedule_internal_wakeup(schedule->internal);
+ schedule_ops.wakeup(schedule, schedule->internal);
SILC_SCHEDULE_UNLOCK(schedule);
#endif
}
SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd,
SilcTaskCallback callback, void *context,
long seconds, long useconds,
- SilcTaskType type,
- SilcTaskPriority priority)
+ SilcTaskType type)
{
- SilcTask newtask;
- SilcTaskQueue queue;
- int timeout = FALSE;
+ SilcTask task = NULL;
if (!schedule->valid)
return NULL;
- queue = SILC_SCHEDULE_GET_QUEUE(type);
-
- /* If the task is generic task, we check whether this task has already
- been registered. Generic tasks are registered only once and after that
- the same task applies to all file descriptors to be registered. */
- if (type == SILC_TASK_GENERIC) {
- silc_mutex_lock(queue->lock);
-
- SILC_LOG_DEBUG(("Registering new task, fd=%d type=%d priority=%d", fd,
- type, priority));
-
- if (queue->task) {
- SilcTask task = queue->task;
- while(1) {
- if ((task->callback == callback) && (task->context == context)) {
- SILC_LOG_DEBUG(("Found matching generic task, using the match"));
-
- silc_mutex_unlock(queue->lock);
-
- /* Add the fd to be listened, the task found now applies to this
- fd as well. */
- silc_schedule_set_listen_fd(schedule, fd, SILC_TASK_READ, FALSE);
- return task;
- }
-
- if (queue->task == task->next)
- break;
+ SILC_SCHEDULE_LOCK(schedule);
- task = task->next;
+ if (type == SILC_TASK_TIMEOUT) {
+ SilcTaskTimeout tmp, prev, ttask = silc_calloc(1, sizeof(*ttask));
+ if (!ttask)
+ goto out;
+
+ SILC_LOG_DEBUG(("Registering new timeout task %p", ttask));
+
+ ttask->header.type = 1;
+ ttask->header.callback = callback;
+ ttask->header.context = context;
+ ttask->header.valid = TRUE;
+
+ /* Add timeout */
+ if ((seconds + useconds) > 0) {
+ silc_gettimeofday(&ttask->timeout);
+ ttask->timeout.tv_sec += seconds + (useconds / 1000000L);
+ ttask->timeout.tv_usec += (useconds % 1000000L);
+ if (ttask->timeout.tv_usec > 999999L) {
+ ttask->timeout.tv_sec += 1;
+ ttask->timeout.tv_usec -= 1000000L;
}
}
- silc_mutex_unlock(queue->lock);
- }
-
- newtask = silc_calloc(1, sizeof(*newtask));
- if (!newtask)
- return NULL;
-
- SILC_LOG_DEBUG(("Registering new task %p, fd=%d type=%d priority=%d",
- newtask, fd, type, priority));
-
- newtask->fd = fd;
- newtask->context = context;
- newtask->callback = callback;
- newtask->valid = TRUE;
- newtask->priority = priority;
- newtask->type = type;
- newtask->next = newtask;
- newtask->prev = newtask;
-
- /* Create timeout if marked to be timeout task */
- if (((seconds + useconds) > 0) && (type == SILC_TASK_TIMEOUT)) {
- silc_gettimeofday(&newtask->timeout);
- newtask->timeout.tv_sec += seconds + (useconds / 1000000L);
- newtask->timeout.tv_usec += (useconds % 1000000L);
- if (newtask->timeout.tv_usec > 999999L) {
- newtask->timeout.tv_sec += 1;
- newtask->timeout.tv_usec -= 1000000L;
+ /* Add task to correct spot so that the first task in the list has
+ the earliest timeout. */
+ silc_list_start(schedule->timeout_queue);
+ prev = NULL;
+ while ((tmp = silc_list_get(schedule->timeout_queue)) != SILC_LIST_END) {
+ /* If we have shorter timeout, we have found our spot */
+ if (silc_compare_timeval(&ttask->timeout, &tmp->timeout)) {
+ silc_list_insert(schedule->timeout_queue, prev, ttask);
+ break;
+ }
+ prev = tmp;
+ }
+ if (!tmp)
+ silc_list_add(schedule->timeout_queue, ttask);
+
+ task = (SilcTask)ttask;
+ } else {
+ /* Check if fd is already added */
+ if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd),
+ NULL, NULL))
+ goto out;
+
+ /* Check max tasks */
+ if (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"));
+ goto out;
}
- timeout = TRUE;
- }
- /* If the task is non-timeout task we have to tell the scheduler that we
- would like to have these tasks scheduled at some odd distant future. */
- if (type != SILC_TASK_TIMEOUT)
- silc_schedule_set_listen_fd(schedule, fd, SILC_TASK_READ, FALSE);
+ SilcTaskFd ftask = silc_calloc(1, sizeof(*ftask));
+ if (!ftask)
+ goto out;
- silc_mutex_lock(queue->lock);
+ SILC_LOG_DEBUG(("Registering new fd task %p fd=%d", ftask, fd));
- /* Is this first task of the queue? */
- if (queue->task == NULL) {
- queue->task = newtask;
- silc_mutex_unlock(queue->lock);
- return newtask;
- }
+ ftask->header.type = 0;
+ ftask->header.callback = callback;
+ ftask->header.context = context;
+ ftask->header.valid = TRUE;
+ ftask->events = SILC_TASK_READ;
+ ftask->fd = fd;
- if (timeout)
- newtask = silc_task_add_timeout(queue, newtask, priority);
- else
- newtask = silc_task_add(queue, newtask, priority);
+ /* Add task */
+ silc_hash_table_add(schedule->fd_queue, SILC_32_TO_PTR(fd), ftask);
- silc_mutex_unlock(queue->lock);
+ task = (SilcTask)ftask;
+ }
- return newtask;
+ out:
+ SILC_SCHEDULE_UNLOCK(schedule);
+ return task;
}
-/* Removes a task from the scheduler */
+/* Invalidates task */
void silc_schedule_task_del(SilcSchedule schedule, SilcTask task)
{
- SilcTaskQueue queue = SILC_SCHEDULE_GET_QUEUE(task->type);
-
- /* Unregister all tasks */
if (task == SILC_ALL_TASKS) {
- SilcTask next;
- SILC_LOG_DEBUG(("Unregistering all tasks at once"));
+ SilcTask task;
+ SilcHashTableList htl;
- silc_mutex_lock(queue->lock);
+ SILC_LOG_DEBUG(("Unregister all tasks"));
- if (!queue->task) {
- silc_mutex_unlock(queue->lock);
- return;
- }
+ SILC_SCHEDULE_LOCK(schedule);
- next = queue->task;
+ /* 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);
- while(1) {
- if (next->valid)
- next->valid = FALSE;
- if (queue->task == next->next)
- break;
- next = next->next;
- }
+ /* 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_mutex_unlock(queue->lock);
+ SILC_SCHEDULE_UNLOCK(schedule);
return;
}
- SILC_LOG_DEBUG(("Unregistering task"));
-
- silc_mutex_lock(queue->lock);
-
- /* Unregister the specific task */
- if (task->valid)
- task->valid = FALSE;
-
- silc_mutex_unlock(queue->lock);
+ SILC_LOG_DEBUG(("Unregistering task %p", task));
+ SILC_SCHEDULE_LOCK(schedule);
+ task->valid = FALSE;
+ SILC_SCHEDULE_UNLOCK(schedule);
}
-/* Remove task by fd */
+/* Invalidate task by fd */
void silc_schedule_task_del_by_fd(SilcSchedule schedule, SilcUInt32 fd)
{
- SILC_LOG_DEBUG(("Unregister task by fd %d", fd));
-
- silc_task_del_by_fd(schedule->timeout_queue, fd);
- silc_task_del_by_fd(schedule->fd_queue, fd);
-}
-
-/* Remove task by task callback. */
-
-void silc_schedule_task_del_by_callback(SilcSchedule schedule,
- SilcTaskCallback callback)
-{
- SILC_LOG_DEBUG(("Unregister task by callback"));
+ SilcTask task;
- silc_task_del_by_callback(schedule->timeout_queue, callback);
- silc_task_del_by_callback(schedule->fd_queue, callback);
- silc_task_del_by_callback(schedule->generic_queue, callback);
-}
+ SILC_LOG_DEBUG(("Unregister task by fd %d", fd));
-/* Remove task by context. */
+ SILC_SCHEDULE_LOCK(schedule);
-void silc_schedule_task_del_by_context(SilcSchedule schedule, void *context)
-{
- SILC_LOG_DEBUG(("Unregister task by context"));
+ /* fd is unique, so there is only one task with this fd in the table */
+ if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd), NULL,
+ (void **)&task))
+ task->valid = FALSE;
- silc_task_del_by_context(schedule->timeout_queue, context);
- silc_task_del_by_context(schedule->fd_queue, context);
- silc_task_del_by_context(schedule->generic_queue, context);
+ 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. */
+/* Invalidate task by task callback. */
-void silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd,
- SilcTaskEvent mask, bool send_events)
+void silc_schedule_task_del_by_callback(SilcSchedule schedule,
+ SilcTaskCallback callback)
{
- int i;
- bool found = FALSE;
+ SilcTask task;
+ SilcHashTableList htl;
- if (!schedule->valid)
- return;
+ SILC_LOG_DEBUG(("Unregister task by callback"));
SILC_SCHEDULE_LOCK(schedule);
- for (i = 0; i < schedule->max_fd; i++)
- if (schedule->fd_list[i].fd == fd) {
- schedule->fd_list[i].fd = fd;
- schedule->fd_list[i].events = mask;
- schedule->fd_list[i].revents = 0;
- if (i > schedule->last_fd)
- schedule->last_fd = i;
- found = TRUE;
- if (send_events) {
- schedule->fd_list[i].revents = mask;
- silc_schedule_dispatch_nontimeout(schedule);
- }
- break;
- }
-
- if (!found)
- for (i = 0; i < schedule->max_fd; i++)
- if (schedule->fd_list[i].events == 0) {
- schedule->fd_list[i].fd = fd;
- schedule->fd_list[i].events = mask;
- schedule->fd_list[i].revents = 0;
- if (i > schedule->last_fd)
- schedule->last_fd = i;
- if (send_events) {
- schedule->fd_list[i].revents = mask;
- silc_schedule_dispatch_nontimeout(schedule);
- }
- break;
- }
+ /* 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;
+ }
+ 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) {
+ if (task->callback == callback)
+ task->valid = FALSE;
+ }
SILC_SCHEDULE_UNLOCK(schedule);
}
-/* Removes a file descriptor from listen list. */
+/* Invalidate task by context. */
-void silc_schedule_unset_listen_fd(SilcSchedule schedule, SilcUInt32 fd)
+void silc_schedule_task_del_by_context(SilcSchedule schedule, void *context)
{
- int i;
+ SilcTask task;
+ SilcHashTableList htl;
- SILC_SCHEDULE_LOCK(schedule);
+ SILC_LOG_DEBUG(("Unregister task by context"));
- SILC_LOG_DEBUG(("Unset listen fd %d", fd));
+ SILC_SCHEDULE_LOCK(schedule);
- for (i = 0; i < schedule->max_fd; i++)
- if (schedule->fd_list[i].fd == fd) {
- schedule->fd_list[i].fd = 0;
- schedule->fd_list[i].events = 0;
- schedule->fd_list[i].revents = 0;
- if (schedule->last_fd == i && i > 0)
- schedule->last_fd = i - 1;
- break;
- }
+ /* 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;
+ }
+ 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) {
+ if (task->context == context)
+ task->valid = FALSE;
+ }
SILC_SCHEDULE_UNLOCK(schedule);
}
-/* Register a new signal */
+/* Invalidate task by all */
-void silc_schedule_signal_register(SilcSchedule schedule, SilcUInt32 signal,
+void silc_schedule_task_del_by_all(SilcSchedule schedule, int fd,
SilcTaskCallback callback, void *context)
{
- silc_schedule_internal_signal_register(schedule->internal, signal,
- callback, context);
-}
-
-/* Unregister a new signal */
-
-void silc_schedule_signal_unregister(SilcSchedule schedule, SilcUInt32 signal,
- SilcTaskCallback callback, void *context)
-{
- silc_schedule_internal_signal_unregister(schedule->internal, signal,
- callback, context);
-}
-
-/* Call signal indicated by `signal'. */
+ SilcTask task;
-void silc_schedule_signal_call(SilcSchedule schedule, SilcUInt32 signal)
-{
- /* Mark that signals needs to be delivered later. */
- silc_schedule_internal_signal_call(schedule->internal, signal);
- schedule->signal_tasks = TRUE;
-}
+ SILC_LOG_DEBUG(("Unregister task by fd, callback and context"));
-/* Allocates a newtask task queue into the scheduler */
+ /* For fd task, callback and context is irrelevant as fd is unique */
+ if (fd)
+ silc_schedule_task_del_by_fd(schedule, fd);
-static void silc_task_queue_alloc(SilcTaskQueue *queue)
-{
- *queue = silc_calloc(1, sizeof(**queue));
- silc_mutex_alloc(&(*queue)->lock);
-}
+ SILC_SCHEDULE_LOCK(schedule);
-/* Free's a task queue. */
+ /* Delete from timeout queue */
+ silc_list_start(schedule->timeout_queue);
+ while ((task = (SilcTask)silc_list_get(schedule->timeout_queue))
+ != SILC_LIST_END) {
+ if (task->callback == callback && task->context == context)
+ task->valid = FALSE;
+ }
-static void silc_task_queue_free(SilcTaskQueue queue)
-{
- silc_mutex_free(queue->lock);
- memset(queue, 'F', sizeof(*queue));
- silc_free(queue);
+ SILC_SCHEDULE_UNLOCK(schedule);
}
-/* Return task by its fd. */
+/* Removes task from the scheduler. This must be called with scheduler
+ locked. */
-static SilcTask silc_task_find(SilcTaskQueue queue, SilcUInt32 fd)
+static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task)
{
- SilcTask next;
-
- if (!queue->task)
- return NULL;
+ SilcTaskFd ftask;
+ SilcTaskTimeout ttask;
- next = queue->task;
+ if (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 = (SilcTask)silc_list_get(schedule->timeout_queue))
+ != SILC_LIST_END) {
+ silc_list_del(schedule->timeout_queue, task);
+ silc_free(task);
+ }
- while (1) {
- if (next->fd == fd)
- return next;
- if (queue->task == next->next)
- return NULL;
- next = next->next;
+ return;
}
- return NULL;
-}
-
-/* Adds a non-timeout task into the task queue. This function is used
- by silc_task_register function. Returns a pointer to the registered
- task. */
-
-static SilcTask silc_task_add(SilcTaskQueue queue, SilcTask newtask,
- SilcTaskPriority priority)
-{
- SilcTask task, next, prev;
-
- /* Take the first task in the queue */
- task = queue->task;
-
- switch(priority) {
- case SILC_TASK_PRI_LOW:
- /* Lowest priority. The task is added at the end of the list. */
- prev = task->prev;
- newtask->prev = prev;
- newtask->next = task;
- prev->next = newtask;
- task->prev = newtask;
- break;
- case SILC_TASK_PRI_NORMAL:
- /* Normal priority. The task is added before lower priority tasks
- but after tasks with higher priority. */
- prev = task->prev;
- while(prev != task) {
- if (prev->priority > SILC_TASK_PRI_LOW)
+ /* Delete from timeout queue */
+ if (task->type == 1) {
+ silc_list_start(schedule->timeout_queue);
+ while ((ttask = silc_list_get(schedule->timeout_queue)) != SILC_LIST_END) {
+ if (ttask == (SilcTaskTimeout)task) {
+ silc_list_del(schedule->timeout_queue, ttask);
+ silc_free(ttask);
break;
- prev = prev->prev;
- }
- if (prev == task) {
- /* There are only lower priorities in the list, we will
- sit before them and become the first task in the queue. */
- prev = task->prev;
- newtask->prev = prev;
- newtask->next = task;
- task->prev = newtask;
- prev->next = newtask;
-
- /* We are now the first task in queue */
- queue->task = newtask;
- } else {
- /* Found a spot from the list, add the task to the list. */
- next = prev->next;
- newtask->prev = prev;
- newtask->next = next;
- prev->next = newtask;
- next->prev = newtask;
+ }
}
- break;
- default:
- silc_free(newtask);
- return NULL;
- }
- return newtask;
-}
-
-/* Return the timeout task with smallest timeout. */
-
-static SilcTask silc_task_get_first(SilcTaskQueue queue, SilcTask first)
-{
- SilcTask prev, task;
-
- prev = first->prev;
-
- if (first == prev)
- return first;
-
- task = first;
- while (1) {
- if (first == prev)
- break;
-
- if (silc_compare_timeval(&prev->timeout, &task->timeout))
- task = prev;
-
- prev = prev->prev;
+ return;
}
- return task;
+ /* Delete from fd queue */
+ ftask = (SilcTaskFd)task;
+ silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(ftask->fd));
}
-/* Adds a timeout task into the task queue. This function is used by
- silc_task_register function. Returns a pointer to the registered
- task. Timeout tasks are sorted by their timeout value in ascending
- order. The priority matters if there are more than one task with
- same timeout. */
+/* 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. */
-static SilcTask silc_task_add_timeout(SilcTaskQueue queue, SilcTask newtask,
- SilcTaskPriority priority)
+void silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd,
+ SilcTaskEvent mask, bool send_events)
{
- SilcTask task, prev, next;
-
- /* Take the first task in the queue */
- task = queue->task;
-
- /* Take last task from the list */
- prev = task->prev;
-
- switch(priority) {
- case SILC_TASK_PRI_LOW:
- /* Lowest priority. The task is added at the end of the list. */
- while(prev != task) {
-
- /* If we have longer timeout than with the task head of us
- we have found our spot. */
- if (silc_compare_timeval(&prev->timeout, &newtask->timeout))
- break;
-
- /* If we are equal size of timeout we will be after it. */
- if (!silc_compare_timeval(&newtask->timeout, &prev->timeout))
- break;
+ SilcTaskFd task;
- /* We have shorter timeout, compare to next one. */
- prev = prev->prev;
- }
- /* Found a spot from the list, add the task to the list. */
- next = prev->next;
- newtask->prev = prev;
- newtask->next = next;
- prev->next = newtask;
- next->prev = newtask;
-
- if (prev == task) {
- /* Check if we are going to be the first task in the queue */
- if (silc_compare_timeval(&prev->timeout, &newtask->timeout))
- break;
- if (!silc_compare_timeval(&newtask->timeout, &prev->timeout))
- break;
-
- /* We are now the first task in queue */
- queue->task = newtask;
- }
- break;
- case SILC_TASK_PRI_NORMAL:
- /* Normal priority. The task is added before lower priority tasks
- but after tasks with higher priority. */
- while(prev != task) {
-
- /* If we have longer timeout than with the task head of us
- we have found our spot. */
- if (silc_compare_timeval(&prev->timeout, &newtask->timeout))
- break;
-
- /* If we are equal size of timeout, priority kicks in place. */
- if (!silc_compare_timeval(&newtask->timeout, &prev->timeout))
- if (prev->priority >= SILC_TASK_PRI_NORMAL)
- break;
+ if (!schedule->valid)
+ return;
- /* We have shorter timeout or higher priority, compare to next one. */
- prev = prev->prev;
- }
- /* Found a spot from the list, add the task to the list. */
- next = prev->next;
- newtask->prev = prev;
- newtask->next = next;
- prev->next = newtask;
- next->prev = newtask;
-
- if (prev == task) {
- /* Check if we are going to be the first task in the queue */
- if (silc_compare_timeval(&prev->timeout, &newtask->timeout))
- break;
- if (!silc_compare_timeval(&newtask->timeout, &prev->timeout))
- if (prev->priority >= SILC_TASK_PRI_NORMAL)
- break;
+ SILC_SCHEDULE_LOCK(schedule);
- /* We are now the first task in queue */
- queue->task = newtask;
+ if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd),
+ NULL, (void **)&task)) {
+ task->events = mask;
+ if (send_events) {
+ task->revents = mask;
+ silc_schedule_dispatch_fd(schedule);
}
- break;
- default:
- silc_free(newtask);
- return NULL;
}
- return newtask;
+ SILC_SCHEDULE_UNLOCK(schedule);
}
-/* Removes (unregisters) a task from particular task queue. This function
- is used internally by scheduler. This must be called holding the
- queue->lock. */
+/* Removes a file descriptor from listen list. */
-static int silc_schedule_task_remove(SilcTaskQueue queue, SilcTask task)
+void silc_schedule_unset_listen_fd(SilcSchedule schedule, SilcUInt32 fd)
{
- SilcTask first, old, next;
-
- if (!queue || !task)
- return FALSE;
-
- if (!queue->task) {
- return FALSE;
- }
-
- first = queue->task;
-
- /* Unregister all tasks in queue */
- if (task == SILC_ALL_TASKS) {
- SILC_LOG_DEBUG(("Removing all tasks at once"));
- next = first;
-
- while(1) {
- old = next->next;
- silc_free(next);
- if (old == first)
- break;
- next = old;
- }
-
- queue->task = NULL;
- return TRUE;
- }
-
- SILC_LOG_DEBUG(("Removing task %p", task));
-
- /* Unregister the task */
- old = first;
- while(1) {
- if (old == task) {
- SilcTask prev, next;
-
- prev = old->prev;
- next = old->next;
- prev->next = next;
- next->prev = prev;
-
- if (prev == old && next == old)
- queue->task = NULL;
- if (queue->task == old)
- queue->task = silc_task_get_first(queue, next);
-
- silc_free(old);
- return TRUE;
- }
- old = old->prev;
-
- if (old == first) {
- return FALSE;
- }
- }
+ silc_schedule_set_listen_fd(schedule, fd, 0, FALSE);
}
-static void silc_task_del_by_fd(SilcTaskQueue queue, SilcUInt32 fd)
-{
- SilcTask next;
-
- silc_mutex_lock(queue->lock);
-
- if (!queue->task) {
- silc_mutex_unlock(queue->lock);
- return;
- }
-
- next = queue->task;
-
- while(1) {
- if (next->fd == fd)
- next->valid = FALSE;
- if (queue->task == next->next)
- break;
- next = next->next;
- }
-
- silc_mutex_unlock(queue->lock);
-}
+/* Register a new signal */
-static void silc_task_del_by_callback(SilcTaskQueue queue,
- SilcTaskCallback callback)
+void silc_schedule_signal_register(SilcSchedule schedule, SilcUInt32 signal,
+ SilcTaskCallback callback, void *context)
{
- SilcTask next;
-
- silc_mutex_lock(queue->lock);
-
- if (!queue->task) {
- silc_mutex_unlock(queue->lock);
- return;
- }
-
- next = queue->task;
-
- while(1) {
- if (next->callback == callback)
- next->valid = FALSE;
- if (queue->task == next->next)
- break;
- next = next->next;
- }
-
- silc_mutex_unlock(queue->lock);
+ schedule_ops.signal_register(schedule, schedule->internal, signal,
+ callback, context);
}
-static void silc_task_del_by_context(SilcTaskQueue queue, void *context)
-{
- SilcTask next;
-
- silc_mutex_lock(queue->lock);
-
- if (!queue->task) {
- silc_mutex_unlock(queue->lock);
- return;
- }
+/* Unregister a new signal */
- next = queue->task;
+void silc_schedule_signal_unregister(SilcSchedule schedule, SilcUInt32 signal,
+ SilcTaskCallback callback, void *context)
+{
+ schedule_ops.signal_unregister(schedule, schedule->internal, signal,
+ callback, context);
+}
- while(1) {
- if (next->context == context)
- next->valid = FALSE;
- if (queue->task == next->next)
- break;
- next = next->next;
- }
+/* Call signal indicated by `signal'. */
- silc_mutex_unlock(queue->lock);
+void silc_schedule_signal_call(SilcSchedule schedule, SilcUInt32 signal)
+{
+ /* Mark that signals needs to be delivered later. */
+ schedule_ops.signal_call(schedule, schedule->internal, signal);
+ schedule->signal_tasks = TRUE;
}
projects / silc.git / blobdiff