+++ /dev/null
-/*
-
- silcfsm.c
-
- Author: Pekka Riikonen <priikone@silcnet.org>
-
- Copyright (C) 2005 - 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; 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
- GNU General Public License for more details.
-
-*/
-
-#include "silc.h"
-
-SILC_TASK_CALLBACK(silc_fsm_run);
-SILC_TASK_CALLBACK(silc_fsm_finish_fsm);
-SILC_TASK_CALLBACK(silc_fsm_event_timedout);
-SILC_TASK_CALLBACK(silc_fsm_start_real_thread);
-static void silc_fsm_thread_termination_signal(SilcFSMEvent event);
-static void silc_fsm_event_ref(SilcFSMEvent event);
-static void silc_fsm_event_unref(SilcFSMEvent event);
-void *silc_fsm_thread(void *context);
-
-/* Allocate FSM */
-
-SilcFSM silc_fsm_alloc(void *fsm_context,
- SilcFSMDestructor destructor,
- void *destructor_context,
- SilcSchedule schedule)
-{
- SilcFSM fsm;
-
- fsm = silc_calloc(1, sizeof(*fsm));
- if (silc_unlikely(!fsm))
- return NULL;
-
- if (silc_unlikely(!silc_fsm_init(fsm, fsm_context, destructor,
- destructor_context, schedule))) {
- silc_free(fsm);
- return NULL;
- }
-
- return fsm;
-}
-
-/* Initialize FSM */
-
-SilcBool silc_fsm_init(SilcFSM fsm,
- void *fsm_context,
- SilcFSMDestructor destructor,
- void *destructor_context,
- SilcSchedule schedule)
-{
- if (!schedule) {
- schedule = silc_schedule_get_global();
- if (!schedule) {
- silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
- return FALSE;
- }
- }
-
- fsm->fsm_context = fsm_context;
- fsm->state_context = NULL;
- fsm->destructor = destructor;
- fsm->destructor_context = destructor_context;
- fsm->schedule = schedule;
- fsm->thread = FALSE;
- fsm->async_call = FALSE;
- fsm->started = FALSE;
- fsm->u.m.lock = NULL;
- silc_atomic_init32(&fsm->u.m.threads, 0);
-
- return TRUE;
-}
-
-/* Allocate FSM thread. Internally machine and thread use same context. */
-
-SilcFSMThread silc_fsm_thread_alloc(SilcFSM fsm,
- void *thread_context,
- SilcFSMThreadDestructor destructor,
- void *destructor_context,
- SilcBool real_thread)
-{
- SilcFSMThread thread;
-
- thread = silc_calloc(1, sizeof(*thread));
- if (silc_unlikely(!thread))
- return NULL;
-
- silc_fsm_thread_init(thread, fsm, thread_context, destructor,
- destructor_context, real_thread);
- return thread;
-}
-
-/* Initialize FSM thread. Internally machine and thread use same context. */
-
-void silc_fsm_thread_init(SilcFSMThread thread,
- SilcFSM fsm,
- void *thread_context,
- SilcFSMThreadDestructor destructor,
- void *destructor_context,
- SilcBool real_thread)
-{
- SILC_LOG_DEBUG(("Initializing new thread %p (%s)",
- thread, real_thread ? "real" : "FSM"));
-
- SILC_VERIFY(!fsm->thread);
-
- thread->fsm_context = thread_context;
- thread->state_context = NULL;
- thread->destructor = (SilcFSMDestructor)destructor;
- thread->destructor_context = destructor_context;
- thread->schedule = fsm->schedule;
- thread->thread = TRUE;
- thread->async_call = FALSE;
- thread->started = FALSE;
- thread->real_thread = real_thread;
- thread->u.t.fsm = fsm;
-
- /* Add to machine */
- silc_atomic_add_int32(&fsm->u.m.threads, 1);
-
- /* Allocate lock for the machine if using real threads. */
- if (real_thread && !fsm->u.m.lock)
- if (!silc_mutex_alloc(&fsm->u.m.lock))
- thread->real_thread = FALSE;
-}
-
-/* FSM is destroyed through scheduler to make sure that all dying
- real system threads will have their finish callbacks scheduled before
- this one (when SILC_FSM_THREAD_WAIT was used). */
-
-SILC_TASK_CALLBACK(silc_fsm_free_final)
-{
- SilcFSM f = context;
-
-#if defined(SILC_DEBUG)
- /* We must be finished */
- SILC_ASSERT(f->finished);
-
- /* Machine must not have active threads */
- if (!f->thread && silc_atomic_get_int32(&f->u.m.threads))
- SILC_ASSERT(silc_atomic_get_int32(&f->u.m.threads) == 0);
-#endif /* SILC_DEBUG */
-
- if (!f->thread && f->u.m.lock)
- silc_mutex_free(f->u.m.lock);
-
- if (f->thread && f->u.t.event)
- silc_fsm_event_free(f->u.t.event);
-
- if (!f->thread)
- silc_atomic_uninit32(&f->u.m.threads);
-
- silc_free(f);
-}
-
-/* Free FSM */
-
-void silc_fsm_free(void *fsm)
-{
- SilcFSM f = fsm;
- if (!f->thread)
- if (silc_schedule_task_add_timeout(f->schedule, silc_fsm_free_final,
- f, 0, 0))
- return;
- silc_fsm_free_final(f->schedule, silc_schedule_get_context(f->schedule),
- 0, 0, f);
-}
-
-/* Task to start real thread. We start threads through scheduler, not
- directly in silc_fsm_start. */
-
-SILC_TASK_CALLBACK(silc_fsm_start_real_thread)
-{
- SilcFSM f = context;
-
-#ifdef SILC_THREADS
- if (silc_thread_create(silc_fsm_thread, f, FALSE))
- return;
-#endif /* SILC_THREADS */
-
- SILC_LOG_DEBUG(("Could not create real thread, using normal FSM thread"));
-
- /* Normal FSM operation */
- f->real_thread = FALSE;
- silc_fsm_continue_sync(f);
-}
-
-/* Start FSM in the specified state */
-
-void silc_fsm_start(void *fsm, SilcFSMStateCallback start_state)
-{
- SilcFSM f = fsm;
-
- SILC_LOG_DEBUG(("Starting %s %p", f->thread ? "thread" : "FSM", fsm));
-
- f->finished = FALSE;
- f->next_state = start_state;
- f->synchronous = FALSE;
- f->started = TRUE;
-
- /* Start real thread through scheduler */
- if (f->thread && f->real_thread) {
- if (!silc_schedule_task_add_timeout(f->schedule,
- silc_fsm_start_real_thread,
- f, 0, 0))
- silc_fsm_start_real_thread(f->schedule,
- silc_schedule_get_context(f->schedule),
- 0, 0, f);
- silc_schedule_wakeup(f->schedule);
- return;
- }
-
- /* Normal FSM operation */
- if (!silc_schedule_task_add_timeout(f->schedule, silc_fsm_run, f, 0, 0))
- silc_fsm_run(f->schedule, silc_schedule_get_context(f->schedule), 0, 0, f);
-
- /* Wakeup scheduler in case we are starting this thread from another
- real thread. */
- if (f->thread)
- silc_schedule_wakeup(f->schedule);
-}
-
-/* Start FSM in the specified state synchronously */
-
-void silc_fsm_start_sync(void *fsm, SilcFSMStateCallback start_state)
-{
- SilcFSM f = fsm;
-
- SILC_LOG_DEBUG(("Starting %s %p", f->thread ? "thread" : "FSM", fsm));
-
- f->finished = FALSE;
- f->next_state = start_state;
- f->synchronous = TRUE;
- f->started = TRUE;
-
- /* Start real thread directly */
- if (f->thread && f->real_thread) {
- silc_fsm_start_real_thread(f->schedule,
- silc_schedule_get_context(f->schedule),
- 0, 0, f);
- return;
- }
-
- /* Normal FSM operation */
- silc_fsm_run(f->schedule, silc_schedule_get_context(f->schedule), 0, 0, f);
-}
-
-/* Set next FSM state */
-
-void silc_fsm_next(void *fsm, SilcFSMStateCallback next_state)
-{
- SilcFSM f = fsm;
- f->next_state = next_state;
-}
-
-/* Continue after timeout */
-
-void silc_fsm_next_later(void *fsm, SilcFSMStateCallback next_state,
- SilcUInt32 seconds, SilcUInt32 useconds)
-{
- SilcFSM f = fsm;
-
- f->next_state = next_state;
- if (!seconds && !useconds)
- return;
-
- silc_schedule_task_add_timeout(f->schedule, silc_fsm_run, f,
- seconds, useconds);
- f->next_later = TRUE;
-
- /* Wakeup up the scheduler just in case this was called from another
- thread. */
- silc_schedule_wakeup(f->schedule);
-}
-
-/* Continue after callback or async operation */
-
-void silc_fsm_continue(void *fsm)
-{
- SilcFSM f = fsm;
-
- if (f->next_later) {
- /* Cancel next_later timeout */
- silc_schedule_task_del_by_all(f->schedule, 0, silc_fsm_run, f);
- f->next_later = FALSE;
- }
-
- if (!silc_schedule_task_add_timeout(f->schedule, silc_fsm_run, f, 0, 0))
- silc_fsm_run(f->schedule, silc_schedule_get_context(f->schedule), 0, 0, f);
-
- /* Wakeup up the scheduler just in case this was called from another
- thread. */
- silc_schedule_wakeup(f->schedule);
-}
-
-/* Continue after callback or async operation immediately */
-
-void silc_fsm_continue_sync(void *fsm)
-{
- SilcFSM f = fsm;
- if (f->next_later) {
- silc_schedule_task_del_by_all(f->schedule, 0, silc_fsm_run, f);
- f->next_later = FALSE;
- }
- silc_fsm_run(f->schedule, silc_schedule_get_context(f->schedule), 0, 0, f);
-}
-
-/* Finish FSM */
-
-void silc_fsm_finish(void *fsm)
-{
- SilcFSM f = fsm;
-
- SILC_VERIFY(!f->finished);
-
- f->started = FALSE;
- f->finished = TRUE;
-
- silc_schedule_task_del_by_all(f->schedule, 0, silc_fsm_run, f);
- f->next_later = FALSE;
-
- /* If we are thread and using real threads, the FSM thread will finish
- after the real thread has finished, in the main thread. */
- if (f->thread && f->real_thread) {
- /* Stop the real thread's scheduler to finish the thread */
- silc_schedule_stop(f->schedule);
- silc_schedule_wakeup(f->schedule);
- return;
- }
-
- /* Normal FSM operation */
- if (!f->synchronous)
- if (silc_schedule_task_add_timeout(f->schedule, silc_fsm_finish_fsm,
- f, 0, 0))
- return;
-
- silc_fsm_finish_fsm(f->schedule, silc_schedule_get_context(f->schedule),
- 0, 0, fsm);
-}
-
-/* Return associated scheduler */
-
-SilcSchedule silc_fsm_get_schedule(void *fsm)
-{
- SilcFSM f = fsm;
- return f->schedule;
-}
-
-/* Return thread's machine */
-
-SilcFSM silc_fsm_get_machine(SilcFSMThread thread)
-{
- SILC_VERIFY(thread->thread);
- return (SilcFSM)thread->u.t.fsm;
-}
-
-/* Returns TRUE if FSM is started */
-
-SilcBool silc_fsm_is_started(void *fsm)
-{
- SilcFSM f = fsm;
- return f->started;
-}
-
-/* Set context */
-
-void silc_fsm_set_context(void *fsm, void *fsm_context)
-{
- SilcFSM f = fsm;
- f->fsm_context = fsm_context;
-}
-
-/* Get context */
-
-void *silc_fsm_get_context(void *fsm)
-{
- SilcFSM f = fsm;
- return f->fsm_context;
-}
-
-/* Set state context */
-
-void silc_fsm_set_state_context(void *fsm, void *state_context)
-{
- SilcFSM f = fsm;
- f->state_context = state_context;
-}
-
-/* Get state context */
-
-void *silc_fsm_get_state_context(void *fsm)
-{
- SilcFSM f = fsm;
- return f->state_context;
-}
-
-/* Wait for thread to terminate */
-
-SilcBool silc_fsm_thread_wait(void *fsm, void *thread)
-{
- SilcFSM t = thread;
-
- SILC_VERIFY(t->thread);
-
- t->u.t.event = silc_fsm_event_alloc(t->u.t.fsm);
- if (!t->u.t.event)
- return FALSE;
-
- SILC_LOG_DEBUG(("Waiting for thread %p to terminate", thread));
- silc_fsm_event_wait(t->u.t.event, fsm);
- return TRUE;
-}
-
-/* The machine */
-
-SILC_TASK_CALLBACK(silc_fsm_run)
-{
- SilcFSM fsm = context;
- SilcFSMStatus status;
-
- SILC_LOG_DEBUG(("Running %s %p", fsm->thread ? "thread" : "FSM", fsm));
-
- /* Run the states */
- do
- status = fsm->next_state(fsm, fsm->fsm_context, fsm->state_context);
- while (status == SILC_FSM_ST_CONTINUE);
-
- switch (status) {
- case SILC_FSM_ST_YIELD:
- /* Continue through scheduler */
- silc_fsm_continue(fsm);
- break;
-
- case SILC_FSM_ST_WAIT:
- /* The machine is in hold */
- SILC_LOG_DEBUG(("State wait %p", fsm));
- fsm->synchronous = FALSE;
- break;
-
- case SILC_FSM_ST_FINISH:
- /* Finish the state machine */
- SILC_LOG_DEBUG(("State finish %p", fsm));
- silc_fsm_finish(fsm);
- break;
-
- default:
- break;
- }
-}
-
-/* Finishes the FSM. This is always executed in the main thread, even
- for FSM threads that were run in real threads. */
-
-SILC_TASK_CALLBACK(silc_fsm_finish_fsm)
-{
- SilcFSM fsm = context;
-
- SILC_LOG_DEBUG(("%s %p, is finished", fsm->thread ? "Thread" : "FSM", fsm));
-
- fsm->next_state = NULL;
-
- if (fsm->thread) {
- /* This is thread, send signal */
- if (fsm->u.t.event) {
- silc_fsm_thread_termination_signal(fsm->u.t.event);
- silc_fsm_event_free(fsm->u.t.event);
- fsm->u.t.event = NULL;
- }
-
- /* Remove the thread from machine */
- silc_atomic_sub_int32(&fsm->u.t.fsm->u.m.threads, 1);
-
- /* Call the destructor callback only if the underlaying machine is
- still valid. */
- if (fsm->destructor && fsm->u.t.fsm->finished == FALSE)
- fsm->destructor(fsm, fsm->fsm_context, fsm->destructor_context);
-
- } else {
- /* Machine must not have active threads */
- SILC_VERIFY(silc_atomic_get_int32(&fsm->u.m.threads) == 0);
-
- if (fsm->u.m.lock) {
- silc_mutex_free(fsm->u.m.lock);
- fsm->u.m.lock = NULL;
- }
-
- /* Call the destructor callback. */
- if (fsm->destructor)
- fsm->destructor(fsm, fsm->fsm_context, fsm->destructor_context);
- }
-}
-
-/* Allocate FSM event */
-
-SilcFSMEvent silc_fsm_event_alloc(SilcFSM fsm)
-{
- SilcFSMEvent event;
-
- event = silc_calloc(1, sizeof(*event));
- if (silc_unlikely(!event))
- return NULL;
-
- silc_fsm_event_init(event, fsm);
- event->allocated = TRUE;
-
- return event;
-}
-
-/* Initializes FSM event */
-
-void silc_fsm_event_init(SilcFSMEvent event, SilcFSM fsm)
-{
- SILC_LOG_DEBUG(("Initializing event %p", event));
- SILC_VERIFY(!fsm->thread);
- memset(event, 0, sizeof(*event));
- event->fsm = fsm;
- event->refcnt = 0;
- silc_list_init(event->waiters, struct SilcFSMObject, next);
-}
-
-/* Free event */
-
-void silc_fsm_event_free(SilcFSMEvent event)
-{
- if (event->refcnt > 0)
- return;
- if (silc_list_count(event->waiters) > 0)
- return;
- silc_free(event);
-}
-
-/* Reference event */
-
-static void silc_fsm_event_ref(SilcFSMEvent event)
-{
- event->refcnt++;
-}
-
-/* Unreference event */
-
-static void silc_fsm_event_unref(SilcFSMEvent event)
-{
- event->refcnt--;
- if (event->refcnt == 0 && event->allocated)
- silc_fsm_event_free(event);
-}
-
-/* Wait until event is non-zero. */
-
-SilcUInt32 silc_fsm_event_wait(SilcFSMEvent event, void *fsm)
-{
- SilcMutex lock = event->fsm->u.m.lock;
-
- silc_mutex_lock(lock);
-
- if (!event->value) {
-#if defined(SILC_DEBUG)
- SilcFSM entry;
- silc_list_start(event->waiters);
- while ((entry = silc_list_get(event->waiters)))
- SILC_ASSERT(entry != fsm);
-#endif /* SILC_DEBUG */
-
- SILC_LOG_DEBUG(("Waiting for event %p", event));
-
- /* Add the FSM to waiter list */
- silc_list_add(event->waiters, fsm);
- silc_mutex_unlock(lock);
- return 0;
- }
-
- SILC_LOG_DEBUG(("Received event %p", event));
-
- /* Remove from waiting */
- silc_list_del(event->waiters, fsm);
-
- /* Decrease the counter only after all waiters have acquired the signal. */
- if (!silc_list_count(event->waiters))
- event->value--;
-
- silc_mutex_unlock(lock);
- return 1;
-}
-
-/* Wait util event is non-zero, or timeout occurs. */
-
-SilcUInt32 silc_fsm_event_timedwait(SilcFSMEvent event, void *fsm,
- SilcUInt32 seconds, SilcUInt32 useconds,
- SilcBool *ret_to)
-{
- SilcMutex lock = event->fsm->u.m.lock;
- SilcFSM f = fsm;
- SilcUInt32 value;
-
- silc_mutex_lock(lock);
-
- if (f->event_timedout) {
- SILC_LOG_DEBUG(("Event waiting timedout"));
- f->event_timedout = FALSE;
- if (ret_to)
- *ret_to = TRUE;
- silc_mutex_unlock(lock);
- return 1;
- }
-
- silc_mutex_unlock(lock);
-
- value = silc_fsm_event_wait(event, fsm);
- if (!value) {
- silc_schedule_task_add_timeout(f->schedule, silc_fsm_event_timedout,
- f, seconds, useconds);
- f->event = event;
- }
-
- if (ret_to)
- *ret_to = FALSE;
-
- return value;
-}
-
-/* Event timedout */
-
-SILC_TASK_CALLBACK(silc_fsm_event_timedout)
-{
- SilcFSM fsm = context;
- SilcMutex lock = fsm->event->fsm->u.m.lock;
-
- SILC_LOG_DEBUG(("Event %p timedout", fsm->event));
-
- /* Remove the waiter from the event waiters list */
- silc_mutex_lock(lock);
- silc_list_del(fsm->event->waiters, fsm);
-
- /* Continue */
- if (fsm->event) {
- silc_fsm_continue(fsm);
- fsm->event_timedout = TRUE;
- fsm->event = NULL;
- }
-
- silc_mutex_unlock(lock);
-}
-
-/* Signalled, event */
-
-SILC_TASK_CALLBACK(silc_fsm_signal)
-{
- SilcFSMEventSignal p = context;
- SilcMutex lock = p->event->fsm->u.m.lock;
- SilcFSM fsm;
-
- /* We have to check for couple of things before delivering the signal. */
-
- /* If the event value has went to zero while we've been waiting this
- callback, the event has been been signalled already. It can happen
- when using real threads because the FSM may not be in waiting state
- when the event is signalled. */
- silc_mutex_lock(lock);
- if (!p->event->value) {
- silc_mutex_unlock(lock);
- silc_fsm_event_unref(p->event);
- silc_free(p);
- return;
- }
-
- /* If the waiter is not waiting anymore, don't deliver the signal. It
- can happen if there were multiple signallers and the waiter went away
- after the first signal. */
- silc_list_start(p->event->waiters);
- while ((fsm = silc_list_get(p->event->waiters)))
- if (fsm == p->fsm)
- break;
- if (!fsm) {
- silc_mutex_unlock(lock);
- silc_fsm_event_unref(p->event);
- silc_free(p);
- return;
- }
- silc_mutex_unlock(lock);
-
- SILC_LOG_DEBUG(("Signalled %s %p", p->fsm->thread ? "thread" : "FSM",
- p->fsm));
-
- /* Signal */
- silc_fsm_continue_sync(p->fsm);
-
- silc_fsm_event_unref(p->event);
- silc_free(p);
-}
-
-/* Signal event */
-
-void silc_fsm_event_signal(SilcFSMEvent event)
-{
- SilcFSM fsm;
- SilcFSMEventSignal p;
- SilcMutex lock = event->fsm->u.m.lock;
-
- SILC_LOG_DEBUG(("Signal event %p", event));
-
- silc_mutex_lock(lock);
-
- event->value++;
- silc_list_start(event->waiters);
- while ((fsm = silc_list_get(event->waiters))) {
- if (fsm->event) {
- silc_schedule_task_del_by_all(fsm->schedule, 0, silc_fsm_event_timedout,
- fsm);
- fsm->event = NULL;
- }
-
- p = silc_calloc(1, sizeof(*p));
- if (silc_unlikely(!p))
- continue;
- p->event = event;
- p->fsm = fsm;
- silc_fsm_event_ref(event);
-
- /* Signal through scheduler. Wake up destination scheduler in case
- caller is a real thread. */
- silc_schedule_task_add_timeout(fsm->schedule, silc_fsm_signal, p, 0, 0);
- silc_schedule_wakeup(fsm->schedule);
- }
-
- silc_mutex_unlock(lock);
-}
-
-/* Post thread termination event. Special function used only to
- signal thread termination when SILC_FSM_THREAD_WAIT was used. */
-
-static void silc_fsm_thread_termination_signal(SilcFSMEvent event)
-{
- SilcFSM fsm;
- SilcMutex lock = event->fsm->u.m.lock;
-
- SILC_LOG_DEBUG(("Post thread terminate event %p", event));
-
- silc_mutex_lock(lock);
-
- silc_list_start(event->waiters);
- while ((fsm = silc_list_get(event->waiters))) {
- /* Signal on thread termination. Wake up destination scheduler in case
- caller is a real thread. */
- silc_list_del(event->waiters, fsm);
- silc_fsm_continue(fsm);
- silc_schedule_wakeup(fsm->schedule);
- }
-
- silc_mutex_unlock(lock);
-}
-
-/* Real thread */
-
-void *silc_fsm_thread(void *context)
-{
- SilcFSM fsm = context;
- SilcSchedule old = fsm->schedule;
-
- SILC_LOG_DEBUG(("Starting FSM thread in real thread"));
-
- /* We allocate new SilcSchedule for the FSM, as the old SilcSchedule
- cannot be used in this thread. Application may still use it if it
- wants but we use our own. */
- fsm->schedule = silc_schedule_init(0, old, silc_schedule_get_stack(old), old);
- if (silc_unlikely(!fsm->schedule)) {
- fsm->schedule = old;
- return NULL;
- }
-
- /* The new scheduler is a global scheduler in this thread */
- silc_schedule_set_global(fsm->schedule);
-
- /* Start the FSM thread */
- if (silc_unlikely(!silc_schedule_task_add_timeout(fsm->schedule,
- silc_fsm_run, fsm, 0, 0))) {
- silc_schedule_uninit(fsm->schedule);
- fsm->schedule = old;
- return NULL;
- }
-
- /* Run the scheduler */
- silc_schedule(fsm->schedule);
-
- /* Reset global scheduler */
- silc_schedule_set_global(NULL);
-
- /* Free resources */
- silc_schedule_uninit(fsm->schedule);
-
- fsm->schedule = old;
-
- /* Finish the FSM thread in the main thread */
- SILC_ASSERT(fsm->finished);
- silc_schedule_task_add_timeout(fsm->schedule, silc_fsm_finish_fsm,
- fsm, 0, 0);
- silc_schedule_wakeup(fsm->schedule);
-
- return NULL;
-}
projects / crypto.git / blobdiff