/************************** Types and definitions ***************************/
+/* Connected event context */
+typedef struct SilcScheduleEventConnectionStruct {
+ SilcSchedule schedule;
+ SilcTaskEventCallback callback;
+ void *context;
+ struct SilcScheduleEventConnectionStruct *next;
+} *SilcScheduleEventConnection;
+
/* Platform specific implementation */
extern const SilcScheduleOps schedule_ops;
static void silc_schedule_dispatch_fd(SilcSchedule schedule);
static void silc_schedule_dispatch_timeout(SilcSchedule schedule,
SilcBool dispatch_all);
-
+SILC_TASK_CALLBACK(silc_schedule_event_del_timeout);
/************************ Static utility functions **************************/
static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task)
{
- SilcTaskFd ftask;
+ SilcSchedule parent;
if (silc_unlikely(task == SILC_ALL_TASKS)) {
SilcTask task;
+ SilcEventTask etask;
SilcHashTableList htl;
- SilcUInt32 fd;
+ void *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));
+ while (silc_hash_table_get(&htl, &fd, (void *)&task))
+ silc_hash_table_del(schedule->fd_queue, fd);
silc_hash_table_list_reset(&htl);
/* Delete from timeout queue */
silc_free(task);
}
+ /* Delete even tasks */
+ parent = silc_schedule_get_parent(schedule);
+ silc_hash_table_list(parent->events, &htl);
+ while (silc_hash_table_get(&htl, NULL, (void *)&etask)) {
+ silc_hash_table_del_by_context(parent->events, etask->event, etask);
+ silc_free(etask->event);
+ silc_free(etask);
+ }
+ silc_hash_table_list_reset(&htl);
return;
}
- if (silc_likely(task->type == 1)) {
- /* Delete from timeout queue */
- silc_list_del(schedule->timeout_queue, task);
+ switch (task->type) {
+ case SILC_TASK_FD:
+ {
+ /* Delete from fd queue */
+ SilcTaskFd ftask = (SilcTaskFd)task;
+ silc_hash_table_del(schedule->fd_queue, SILC_32_TO_PTR(ftask->fd));
+ }
+ break;
- /* 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));
+ case SILC_TASK_TIMEOUT:
+ {
+ /* Delete from timeout queue */
+ silc_list_del(schedule->timeout_queue, task);
+
+ /* Put to free list */
+ silc_list_add(schedule->free_tasks, task);
+ }
+ break;
+
+ case SILC_TASK_EVENT:
+ {
+ SilcEventTask etask = (SilcEventTask)task;
+ SilcScheduleEventConnection conn;
+
+ parent = silc_schedule_get_parent(schedule);
+
+ /* Delete event */
+ silc_hash_table_del_by_context(parent->events, etask->event, etask);
+
+ /* Remove all connections */
+ silc_list_start(etask->connections);
+ while ((conn = silc_list_get(etask->connections)))
+ silc_free(conn);
+
+ silc_free(etask->event);
+ silc_free(etask);
+ }
+ break;
+
+ default:
+ break;
}
}
{
SilcTaskFd ftask;
fprintf(stdout, "Schedule %p statistics:\n\n", schedule);
- fprintf(stdout, "Num FD tasks : %lu (%lu bytes allocated)\n",
+ fprintf(stdout, "Num FD tasks : %d (%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",
+ fprintf(stdout, "Num Timeout tasks : %d (%lu 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",
+ fprintf(stdout, "Num Timeout freelist : %d (%lu bytes allocated)\n",
silc_list_count(schedule->free_tasks),
sizeof(struct SilcTaskTimeoutStruct) *
silc_list_count(schedule->free_tasks));
context that is delivered to task callbacks. */
SilcSchedule silc_schedule_init(int max_tasks, void *app_context,
- SilcStack stack)
+ SilcStack stack, SilcSchedule parent)
{
SilcSchedule schedule;
+ /* Initialize Tls, in case it hasn't been done yet */
+ silc_thread_tls_init();
+
stack = silc_stack_alloc(0, stack);
if (!stack)
return NULL;
silc_list_init(schedule->timeout_queue, struct SilcTaskStruct, next);
silc_list_init(schedule->free_tasks, struct SilcTaskStruct, next);
+ /* Get the parent */
+ if (parent && parent->parent)
+ parent = parent->parent;
+
schedule->stack = stack;
schedule->app_context = app_context;
schedule->valid = TRUE;
schedule->max_tasks = max_tasks;
+ schedule->parent = parent;
/* Allocate scheduler lock */
silc_mutex_alloc(&schedule->lock);
{
SilcTask task;
+ SILC_VERIFY(schedule);
+
SILC_LOG_DEBUG(("Uninitializing scheduler %p", schedule));
if (schedule->valid == TRUE)
void silc_schedule_stop(SilcSchedule schedule)
{
SILC_LOG_DEBUG(("Stopping scheduler"));
+ SILC_VERIFY(schedule);
SILC_SCHEDULE_LOCK(schedule);
schedule->valid = FALSE;
SILC_SCHEDULE_UNLOCK(schedule);
#endif
}
+/* Returns parent scheduler */
+
+SilcSchedule silc_schedule_get_parent(SilcSchedule schedule)
+{
+ return schedule->parent ? schedule->parent : schedule;
+}
+
/* 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
schedule->notify_context = context;
}
+/* Set global scheduler */
+
+void silc_schedule_set_global(SilcSchedule schedule)
+{
+ SilcTls tls = silc_thread_get_tls();
+
+ if (!tls) {
+ /* Try to initialize Tls */
+ tls = silc_thread_tls_init();
+ SILC_VERIFY(tls);
+ if (!tls)
+ return;
+ }
+
+ SILC_LOG_DEBUG(("Setting global scheduler %p", schedule));
+
+ tls->schedule = schedule;
+}
+
+/* Return global scheduler */
+
+SilcSchedule silc_schedule_get_global(void)
+{
+ SilcTls tls = silc_thread_get_tls();
+
+ if (!tls)
+ return NULL;
+
+ SILC_LOG_DEBUG(("Return global scheduler %p", tls->schedule));
+
+ return tls->schedule;
+}
+
/* Add new task to the scheduler */
SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd,
{
SilcTask task = NULL;
- if (silc_unlikely(!schedule->valid))
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return NULL;
+ }
+ }
+
+ if (silc_unlikely(!schedule->valid)) {
+ silc_set_errno(SILC_ERR_NOT_VALID);
return NULL;
+ }
SILC_SCHEDULE_LOCK(schedule);
schedule->max_tasks)) {
SILC_LOG_WARNING(("Scheduler task limit reached: cannot add new task"));
task = NULL;
+ silc_set_errno(SILC_ERR_LIMIT);
goto out;
}
SilcBool silc_schedule_task_del(SilcSchedule schedule, SilcTask task)
{
+ SilcSchedule parent;
+
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+ }
+
if (silc_unlikely(task == SILC_ALL_TASKS)) {
SilcHashTableList htl;
schedule->notify_context);
}
+ /* Delete even tasks */
+ parent = silc_schedule_get_parent(schedule);
+ silc_hash_table_list(parent->events, &htl);
+ while (silc_hash_table_get(&htl, NULL, (void *)&task))
+ task->valid = FALSE;
+ silc_hash_table_list_reset(&htl);
+
SILC_SCHEDULE_UNLOCK(schedule);
return TRUE;
}
- SILC_LOG_DEBUG(("Unregistering task %p", task));
+ SILC_LOG_DEBUG(("Unregistering task %p, type %d", task, task->type));
SILC_SCHEDULE_LOCK(schedule);
task->valid = FALSE;
/* Call notify callback */
- if (schedule->notify)
- schedule->notify(schedule, FALSE, task, !task->type, 0, 0, 0, 0,
- schedule->notify_context);
+ if (schedule->notify && task->type != SILC_TASK_EVENT)
+ schedule->notify(schedule, FALSE, task, task->type == SILC_TASK_FD,
+ 0, 0, 0, 0, schedule->notify_context);
SILC_SCHEDULE_UNLOCK(schedule);
+ if (task->type == SILC_TASK_EVENT) {
+ /* Schedule removal of deleted event task */
+ parent = silc_schedule_get_parent(schedule);
+ silc_schedule_task_add_timeout(parent, silc_schedule_event_del_timeout,
+ task, 0, 1);
+ }
+
return TRUE;
}
SILC_LOG_DEBUG(("Unregister task by fd %d", fd));
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+ }
+
SILC_SCHEDULE_LOCK(schedule);
/* fd is unique, so there is only one task with this fd in the table */
ret = TRUE;
}
+ if (ret == FALSE)
+ silc_set_errno(SILC_ERR_NOT_FOUND);
+
return ret;
}
SILC_LOG_DEBUG(("Unregister task by callback"));
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+ }
+
SILC_SCHEDULE_LOCK(schedule);
/* Delete from fd queue */
SILC_SCHEDULE_UNLOCK(schedule);
+ if (ret == FALSE)
+ silc_set_errno(SILC_ERR_NOT_FOUND);
+
return ret;
}
SILC_LOG_DEBUG(("Unregister task by context"));
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+ }
+
SILC_SCHEDULE_LOCK(schedule);
/* Delete from fd queue */
SILC_SCHEDULE_UNLOCK(schedule);
+ if (ret == FALSE)
+ silc_set_errno(SILC_ERR_NOT_FOUND);
+
return ret;
}
if (fd)
return silc_schedule_task_del_by_fd(schedule, fd);
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+ }
+
SILC_SCHEDULE_LOCK(schedule);
/* Delete from timeout queue */
SILC_SCHEDULE_UNLOCK(schedule);
+ if (ret == FALSE)
+ silc_set_errno(SILC_ERR_NOT_FOUND);
+
return TRUE;
}
{
SilcTaskFd task;
- if (silc_unlikely(!schedule->valid))
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+ }
+
+ if (silc_unlikely(!schedule->valid)) {
+ silc_set_errno(SILC_ERR_NOT_VALID);
return FALSE;
+ }
SILC_SCHEDULE_LOCK(schedule);
SilcTaskFd task;
SilcTaskEvent event = 0;
- if (silc_unlikely(!schedule->valid))
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return 0;
+ }
+ }
+
+ if (silc_unlikely(!schedule->valid)) {
+ silc_set_errno(SILC_ERR_NOT_VALID);
return 0;
+ }
SILC_SCHEDULE_LOCK(schedule);
if (silc_hash_table_find(schedule->fd_queue, SILC_32_TO_PTR(fd),
{
silc_schedule_set_listen_fd(schedule, fd, 0, FALSE);
}
+
+/*************************** Asynchronous Events ****************************/
+
+/* Add event */
+
+SilcTask silc_schedule_task_add_event(SilcSchedule schedule,
+ const char *event, ...)
+{
+ SilcEventTask task;
+ SilcSchedule parent;
+
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return NULL;
+ }
+ }
+
+ /* Get parent scheduler */
+ parent = silc_schedule_get_parent(schedule);
+
+ SILC_LOG_DEBUG(("Adding event '%s' to scheduler %p", event, parent));
+
+ SILC_SCHEDULE_LOCK(parent);
+
+ /* Create events hash table if not already done */
+ if (!parent->events) {
+ parent->events = silc_hash_table_alloc(NULL, 3,
+ silc_hash_string, NULL,
+ silc_hash_string_compare, NULL,
+ NULL, NULL, FALSE);
+ if (!parent->events) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ return NULL;
+ }
+ }
+
+ /* Check if this event is added already */
+ if (silc_hash_table_find(parent->events, (void *)event, NULL, NULL)) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ return NULL;
+ }
+
+ /* Add new event */
+ task = silc_calloc(1, sizeof(*task));
+ if (!task) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ return NULL;
+ }
+
+ task->header.type = SILC_TASK_EVENT;
+ task->header.valid = TRUE;
+ task->event = silc_strdup(event);
+ if (!task->event) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ silc_free(task);
+ return NULL;
+ }
+ silc_list_init(task->connections, struct SilcScheduleEventConnectionStruct,
+ next);
+
+ if (!silc_hash_table_add(parent->events, task->event, task)) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ silc_free(task->event);
+ silc_free(task);
+ return NULL;
+ }
+
+ SILC_SCHEDULE_UNLOCK(parent);
+
+ return (SilcTask)task;
+}
+
+/* Connect to event task */
+
+SilcBool silc_schedule_event_connect(SilcSchedule schedule,
+ const char *event, SilcTask task,
+ SilcTaskEventCallback callback,
+ void *context)
+{
+ SilcSchedule parent;
+ SilcScheduleEventConnection conn;
+ SilcEventTask etask;
+
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+ }
+
+ if (!event && !task) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+
+ if (task && task->type != SILC_TASK_EVENT) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+
+ /* Get parent scheduler */
+ parent = silc_schedule_get_parent(schedule);
+
+ SILC_SCHEDULE_LOCK(parent);
+
+ if (!task) {
+ /* Get the event task */
+ if (!silc_hash_table_find(parent->events, (void *)event, NULL,
+ (void *)&task)) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ return FALSE;
+ }
+ }
+ etask = (SilcEventTask)task;
+
+ /* See if task is deleted */
+ if (task->valid == FALSE) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ silc_set_errno(SILC_ERR_NOT_VALID);
+ return FALSE;
+ }
+
+ SILC_LOG_DEBUG(("Connect callback %p with context %p to event '%s'",
+ callback, context, etask->event));
+
+ /* See if already connected */
+ silc_list_start(etask->connections);
+ while ((conn = silc_list_get(etask->connections))) {
+ if (conn->callback == callback && conn->context == context) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ silc_set_errno(SILC_ERR_ALREADY_EXISTS);
+ return FALSE;
+ }
+ }
+
+ conn = silc_calloc(1, sizeof(*conn));
+ if (!conn) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ return FALSE;
+ }
+
+ /* Connect to the event */
+ conn->schedule = schedule;
+ conn->callback = callback;
+ conn->context = context;
+ silc_list_add(etask->connections, conn);
+
+ SILC_SCHEDULE_UNLOCK(parent);
+
+ return TRUE;
+}
+
+/* Disconnect from event */
+
+SilcBool silc_schedule_event_disconnect(SilcSchedule schedule,
+ const char *event, SilcTask task,
+ SilcTaskEventCallback callback,
+ void *context)
+{
+ SilcSchedule parent;
+ SilcScheduleEventConnection conn;
+ SilcEventTask etask;
+
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+ }
+
+ if (!event && !task) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+
+ if (task && task->type != SILC_TASK_EVENT) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+
+ /* Get parent scheduler */
+ parent = silc_schedule_get_parent(schedule);
+
+ SILC_SCHEDULE_LOCK(parent);
+
+ if (!task) {
+ /* Get the event task */
+ if (!silc_hash_table_find(parent->events, (void *)event, NULL,
+ (void *)&task)) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ return FALSE;
+ }
+ }
+ etask = (SilcEventTask)task;
+
+ /* See if task is deleted */
+ if (task->valid == FALSE) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ silc_set_errno(SILC_ERR_NOT_VALID);
+ return FALSE;
+ }
+
+ SILC_LOG_DEBUG(("Disconnect callback %p with context %p from event '%s'",
+ callback, context, etask->event));
+
+ /* Disconnect */
+ silc_list_start(etask->connections);
+ while ((conn = silc_list_get(etask->connections))) {
+ if (conn->callback == callback && conn->context == context) {
+ silc_list_del(etask->connections, conn);
+ silc_free(conn);
+ SILC_SCHEDULE_UNLOCK(parent);
+ return TRUE;
+ }
+ }
+
+ SILC_SCHEDULE_UNLOCK(parent);
+ silc_set_errno(SILC_ERR_NOT_FOUND);
+ return FALSE;
+}
+
+/* Signal event */
+
+SilcBool silc_schedule_event_signal(SilcSchedule schedule, const char *event,
+ SilcTask task, ...)
+{
+ SilcSchedule parent;
+ SilcScheduleEventConnection conn;
+ SilcEventTask etask;
+ SilcBool stop;
+ va_list ap, cp;
+
+ if (silc_unlikely(!schedule)) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+ }
+
+ if (silc_unlikely(!event && !task)) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+
+ if (silc_unlikely(task && task->type != SILC_TASK_EVENT)) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+
+ /* Get parent scheduler */
+ parent = silc_schedule_get_parent(schedule);
+
+ SILC_SCHEDULE_LOCK(parent);
+
+ if (!task) {
+ /* Get the event task */
+ if (!silc_hash_table_find(parent->events, (void *)event, NULL,
+ (void *)&task)) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ return FALSE;
+ }
+ }
+ etask = (SilcEventTask)task;
+
+ /* See if task is deleted */
+ if (task->valid == FALSE) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ silc_set_errno(SILC_ERR_NOT_VALID);
+ return FALSE;
+ }
+
+ SILC_LOG_DEBUG(("Signal event '%s'", etask->event));
+
+ va_start(ap, task);
+
+ /* Deliver the signal */
+ silc_list_start(etask->connections);
+ while ((conn = silc_list_get(etask->connections))) {
+ SILC_SCHEDULE_UNLOCK(parent);
+
+ silc_va_copy(cp, ap);
+ stop = conn->callback(conn->schedule, conn->schedule->app_context,
+ task, conn->context, cp);
+ va_end(cp);
+
+ SILC_SCHEDULE_LOCK(parent);
+
+ /* Stop signal if wanted or if the task was deleted */
+ if (!stop || !task->valid)
+ break;
+ }
+
+ va_end(ap);
+
+ SILC_SCHEDULE_UNLOCK(parent);
+
+ return TRUE;
+}
+
+/* Delete event */
+
+SilcBool silc_schedule_task_del_event(SilcSchedule schedule, const char *event)
+{
+ SilcSchedule parent;
+ SilcTask task;
+
+ if (!schedule) {
+ schedule = silc_schedule_get_global();
+ SILC_VERIFY(schedule);
+ if (!schedule) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+ }
+
+ if (!event) {
+ silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
+ return FALSE;
+ }
+
+ /* Get parent scheduler */
+ parent = silc_schedule_get_parent(schedule);
+
+ SILC_SCHEDULE_LOCK(parent);
+
+ /* Get the event task */
+ if (!silc_hash_table_find(parent->events, (void *)event, NULL,
+ (void *)&task)) {
+ SILC_SCHEDULE_UNLOCK(parent);
+ return FALSE;
+ }
+
+ /* See if already deleted */
+ if (task->valid == FALSE)
+ return TRUE;
+
+ SILC_LOG_DEBUG(("Delete event '%s'", ((SilcEventTask)task)->event));
+
+ SILC_SCHEDULE_UNLOCK(parent);
+
+ silc_schedule_task_del(parent, task);
+
+ return TRUE;
+}
+
+/* Timeout to remove deleted event task */
+
+SILC_TASK_CALLBACK(silc_schedule_event_del_timeout)
+{
+ SILC_SCHEDULE_LOCK(schedule);
+ silc_schedule_task_remove(schedule, context);
+ SILC_SCHEDULE_UNLOCK(schedule);
+}