Added silc_schedule_[set|get]_global. Added many APIs to call

[crypto.git] / lib / silcutil / silcschedule.c

diff --git a/lib/silcutil/silcschedule.c b/lib/silcutil/silcschedule.c
index 53cb0aa7426f22eb883c7fc5ee73fc427a9db48f..476d11f1031e3518b39442dab2a7fe31b1242dc8 100644 (file)
--- a/lib/silcutil/silcschedule.c
+++ b/lib/silcutil/silcschedule.c
@@ -201,12 +201,12 @@ static void silc_schedule_task_remove(SilcSchedule schedule, SilcTask task)
   if (silc_unlikely(task == SILC_ALL_TASKS)) {
     SilcTask task;
     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 */
@@ -290,14 +290,14 @@ 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",
+  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));
@@ -312,27 +312,38 @@ void silc_schedule_stats(SilcSchedule schedule)
    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 silc_schedule_init(int max_tasks, void *app_context,
+                               SilcStack stack)
 {
   SilcSchedule schedule;
 
-  SILC_LOG_DEBUG(("Initializing scheduler"));
+  /* Initialize Tls, in case it hasn't been done yet */
+  silc_thread_tls_init();
+
+  stack = silc_stack_alloc(0, stack);
+  if (!stack)
+    return NULL;
 
-  schedule = silc_calloc(1, sizeof(*schedule));
+  /* Allocate scheduler from the stack */
+  schedule = silc_scalloc(stack, 1, sizeof(*schedule));
   if (!schedule)
     return NULL;
 
+  SILC_LOG_DEBUG(("Initializing scheduler %p", schedule));
+
+  /* Allocate Fd task hash table dynamically */
   schedule->fd_queue =
-    silc_hash_table_alloc(0, silc_hash_uint, NULL, NULL, NULL,
+    silc_hash_table_alloc(NULL, 0, silc_hash_uint, NULL, NULL, NULL,
                          silc_schedule_fd_destructor, NULL, TRUE);
   if (!schedule->fd_queue) {
-    silc_free(schedule);
+    silc_stack_free(stack);
     return NULL;
   }
 
   silc_list_init(schedule->timeout_queue, struct SilcTaskStruct, next);
   silc_list_init(schedule->free_tasks, struct SilcTaskStruct, next);
 
+  schedule->stack = stack;
   schedule->app_context = app_context;
   schedule->valid = TRUE;
   schedule->max_tasks = max_tasks;
@@ -345,7 +356,7 @@ SilcSchedule silc_schedule_init(int max_tasks, void *app_context)
   if (!schedule->internal) {
     silc_hash_table_free(schedule->fd_queue);
     silc_mutex_free(schedule->lock);
-    silc_free(schedule);
+    silc_stack_free(stack);
     return NULL;
   }
 
@@ -365,7 +376,9 @@ SilcBool silc_schedule_uninit(SilcSchedule schedule)
 {
   SilcTask task;
 
-  SILC_LOG_DEBUG(("Uninitializing scheduler"));
+  SILC_VERIFY(schedule);
+
+  SILC_LOG_DEBUG(("Uninitializing scheduler %p", schedule));
 
   if (schedule->valid == TRUE)
     return FALSE;
@@ -397,7 +410,7 @@ SilcBool silc_schedule_uninit(SilcSchedule schedule)
   schedule_ops.uninit(schedule, schedule->internal);
 
   silc_mutex_free(schedule->lock);
-  silc_free(schedule);
+  silc_stack_free(schedule->stack);
 
   return TRUE;
 }
@@ -409,6 +422,7 @@ SilcBool silc_schedule_uninit(SilcSchedule schedule)
 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);
@@ -548,6 +562,13 @@ void *silc_schedule_get_context(SilcSchedule schedule)
   return schedule->app_context;
 }
 
+/* Return the stack of the scheduler */
+
+SilcStack silc_schedule_get_stack(SilcSchedule schedule)
+{
+  return schedule->stack;
+}
+
 /* Set notify callback */
 
 void silc_schedule_set_notify(SilcSchedule schedule,
@@ -557,6 +578,39 @@ void silc_schedule_set_notify(SilcSchedule schedule,
   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,
@@ -566,8 +620,19 @@ 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);
 
@@ -646,6 +711,7 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd,
                      schedule->max_tasks)) {
       SILC_LOG_WARNING(("Scheduler task limit reached: cannot add new task"));
       task = NULL;
+      silc_set_errno(SILC_ERR_LIMIT);
       goto out;
     }
 
@@ -709,6 +775,15 @@ SilcTask silc_schedule_task_add(SilcSchedule schedule, SilcUInt32 fd,
 
 SilcBool silc_schedule_task_del(SilcSchedule schedule, SilcTask task)
 {
+  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;
 
@@ -766,6 +841,15 @@ SilcBool silc_schedule_task_del_by_fd(SilcSchedule schedule, SilcUInt32 fd)
 
   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 */
@@ -790,6 +874,9 @@ SilcBool silc_schedule_task_del_by_fd(SilcSchedule schedule, SilcUInt32 fd)
     ret = TRUE;
   }
 
+  if (ret == FALSE)
+    silc_set_errno(SILC_ERR_NOT_FOUND);
+
   return ret;
 }
 
@@ -805,6 +892,15 @@ SilcBool silc_schedule_task_del_by_callback(SilcSchedule schedule,
 
   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 */
@@ -840,6 +936,9 @@ SilcBool silc_schedule_task_del_by_callback(SilcSchedule schedule,
 
   SILC_SCHEDULE_UNLOCK(schedule);
 
+  if (ret == FALSE)
+    silc_set_errno(SILC_ERR_NOT_FOUND);
+
   return ret;
 }
 
@@ -855,6 +954,15 @@ SilcBool silc_schedule_task_del_by_context(SilcSchedule schedule,
 
   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 */
@@ -890,6 +998,9 @@ SilcBool silc_schedule_task_del_by_context(SilcSchedule schedule,
 
   SILC_SCHEDULE_UNLOCK(schedule);
 
+  if (ret == FALSE)
+    silc_set_errno(SILC_ERR_NOT_FOUND);
+
   return ret;
 }
 
@@ -909,6 +1020,15 @@ SilcBool silc_schedule_task_del_by_all(SilcSchedule schedule, int fd,
   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 */
@@ -928,6 +1048,9 @@ SilcBool silc_schedule_task_del_by_all(SilcSchedule schedule, int fd,
 
   SILC_SCHEDULE_UNLOCK(schedule);
 
+  if (ret == FALSE)
+    silc_set_errno(SILC_ERR_NOT_FOUND);
+
   return TRUE;
 }
 
@@ -940,8 +1063,19 @@ SilcBool silc_schedule_set_listen_fd(SilcSchedule schedule, SilcUInt32 fd,
 {
   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);
 
@@ -977,8 +1111,19 @@ SilcTaskEvent silc_schedule_get_fd_events(SilcSchedule 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),