Index: src/benchmark/interrupt_linux.c =================================================================== --- src/benchmark/interrupt_linux.c (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) +++ src/benchmark/interrupt_linux.c (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -0,0 +1,35 @@ +#include +#include +#include + +#define __CFA_SIGCXT__ ucontext_t * +#define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt + +void sigHandler( __CFA_SIGPARMS__ ) { + sigset_t mask; + sigemptyset( &mask ); + sigaddset( &mask, SIGUSR1 ); + + if ( sigprocmask( SIG_UNBLOCK, &mask, NULL ) == -1 ) { + abort(); + } // if +} + +int main() { + + struct sigaction act; + + act.sa_sigaction = (void (*)(int, siginfo_t *, void *))sigHandler; + sigemptyset( &act.sa_mask ); + sigaddset( &act.sa_mask, SIGUSR1 ); + + act.sa_flags = SA_SIGINFO; + + if ( sigaction( SIGUSR1, &act, NULL ) == -1 ) { + abort(); + } // if + + for( int i = 0; i < 50000000ul; i++ ) { + pthread_kill( pthread_self(), SIGUSR1 ); + } +} Index: src/libcfa/concurrency/alarm.c =================================================================== --- src/libcfa/concurrency/alarm.c (revision da244680ae17dc5096698c3329c84254f9deaa55) +++ src/libcfa/concurrency/alarm.c (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -16,5 +16,9 @@ extern "C" { +#include +#include +#include #include +#include #include } @@ -22,4 +26,5 @@ #include "alarm.h" #include "kernel_private.h" +#include "libhdr.h" #include "preemption.h" @@ -31,8 +36,21 @@ timespec curr; clock_gettime( CLOCK_REALTIME, &curr ); - return ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec; + __cfa_time_t curr_time = ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec; + LIB_DEBUG_DO( + char text[256]; + __attribute__((unused)) int len = snprintf( text, 256, "Kernel : current time is %lu\n", curr_time ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); + return curr_time; } void __kernel_set_timer( __cfa_time_t alarm ) { + + LIB_DEBUG_DO( + char text[256]; + __attribute__((unused)) int len = snprintf( text, 256, "Kernel : set timer to %lu\n", (__cfa_time_t)alarm ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); + itimerval val; val.it_value.tv_sec = alarm / TIMEGRAN; // seconds @@ -71,6 +89,15 @@ } +LIB_DEBUG_DO( bool validate( alarm_list_t * this ) { + alarm_node_t ** it = &this->head; + while( (*it) ) { + it = &(*it)->next; + } + + return it == this->tail; +}) + static inline void insert_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t p ) { - assert( !n->next ); + verify( !n->next ); if( p == this->tail ) { this->tail = &n->next; @@ -80,4 +107,6 @@ } *p = n; + + verify( validate( this ) ); } @@ -89,4 +118,6 @@ insert_at( this, n, it ); + + verify( validate( this ) ); } @@ -100,4 +131,5 @@ head->next = NULL; } + verify( validate( this ) ); return head; } @@ -105,43 +137,67 @@ static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) { verify( it ); - verify( (*it)->next == n ); - - (*it)->next = n->next; + verify( (*it) == n ); + + (*it) = n->next; if( !n-> next ) { this->tail = it; } n->next = NULL; + + verify( validate( this ) ); } static inline void remove( alarm_list_t * this, alarm_node_t * n ) { alarm_node_t ** it = &this->head; - while( (*it) && (*it)->next != n ) { + while( (*it) && (*it) != n ) { it = &(*it)->next; } + verify( validate( this ) ); + if( *it ) { remove_at( this, n, it ); } + + verify( validate( this ) ); } void register_self( alarm_node_t * this ) { disable_interrupts(); - assert( !systemProcessor->pending_alarm ); + verify( !systemProcessor->pending_alarm ); lock( &systemProcessor->alarm_lock ); { + verify( validate( &systemProcessor->alarms ) ); + bool first = !systemProcessor->alarms.head; + insert( &systemProcessor->alarms, this ); if( systemProcessor->pending_alarm ) { tick_preemption(); } + if( first ) { + __kernel_set_timer( systemProcessor->alarms.head->alarm - __kernel_get_time() ); + } } unlock( &systemProcessor->alarm_lock ); this->set = true; - enable_interrupts(); + enable_interrupts( __PRETTY_FUNCTION__ ); } void unregister_self( alarm_node_t * this ) { + LIB_DEBUG_DO( + char text[256]; + __attribute__((unused)) int len = snprintf( text, 256, "Kernel : unregister %p start\n", this ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); disable_interrupts(); lock( &systemProcessor->alarm_lock ); - remove( &systemProcessor->alarms, this ); + { + verify( validate( &systemProcessor->alarms ) ); + remove( &systemProcessor->alarms, this ); + } unlock( &systemProcessor->alarm_lock ); disable_interrupts(); this->set = false; -} + LIB_DEBUG_DO( + len = snprintf( text, 256, "Kernel : unregister %p end\n", this ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); +} Index: src/libcfa/concurrency/coroutine.c =================================================================== --- src/libcfa/concurrency/coroutine.c (revision da244680ae17dc5096698c3329c84254f9deaa55) +++ src/libcfa/concurrency/coroutine.c (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -32,5 +32,5 @@ #include "invoke.h" -extern thread_local processor * this_processor; +extern volatile thread_local processor * this_processor; //----------------------------------------------------------------------------- Index: src/libcfa/concurrency/invoke.c =================================================================== --- src/libcfa/concurrency/invoke.c (revision da244680ae17dc5096698c3329c84254f9deaa55) +++ src/libcfa/concurrency/invoke.c (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -30,4 +30,6 @@ extern void __suspend_internal(void); extern void __leave_monitor_desc( struct monitor_desc * this ); +extern void disable_interrupts(); +extern void enable_interrupts( const char * ); void CtxInvokeCoroutine( @@ -67,8 +69,10 @@ struct monitor_desc* mon = &thrd->mon; cor->state = Active; + enable_interrupts( __PRETTY_FUNCTION__ ); // LIB_DEBUG_PRINTF("Invoke Thread : invoking main %p (args %p)\n", main, this); main( this ); + disable_interrupts(); __leave_monitor_desc( mon ); Index: src/libcfa/concurrency/kernel =================================================================== --- src/libcfa/concurrency/kernel (revision da244680ae17dc5096698c3329c84254f9deaa55) +++ src/libcfa/concurrency/kernel (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -90,7 +90,7 @@ unsigned int preemption; - unsigned short disable_preempt_count; + bool pending_preemption; - bool pending_preemption; + char * last_enable; }; Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision da244680ae17dc5096698c3329c84254f9deaa55) +++ src/libcfa/concurrency/kernel.c (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -59,5 +59,6 @@ // Global state -thread_local processor * this_processor; +volatile thread_local processor * this_processor; +volatile thread_local unsigned short disable_preempt_count; coroutine_desc * this_coroutine(void) { @@ -142,5 +143,4 @@ this->preemption_alarm = NULL; this->preemption = default_preemption(); - this->disable_preempt_count = 1; //Start with interrupts disabled this->pending_preemption = false; @@ -154,11 +154,15 @@ (&this->terminated){}; this->is_terminated = false; - this->disable_preempt_count = 0; + this->preemption_alarm = NULL; + this->preemption = default_preemption(); this->pending_preemption = false; + this->kernel_thread = pthread_self(); this->runner = runner; - LIB_DEBUG_PRINT_SAFE("Kernel : constructing processor context %p\n", runner); + LIB_DEBUG_PRINT_SAFE("Kernel : constructing system processor context %p\n", runner); runner{ this }; } + +LIB_DEBUG_DO( bool validate( alarm_list_t * this ); ) void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) { @@ -168,4 +172,6 @@ (&this->proc){ cltr, runner }; + + verify( validate( &this->alarms ) ); } @@ -209,5 +215,9 @@ if(readyThread) { + verify( disable_preempt_count > 0 ); + runThread(this, readyThread); + + verify( disable_preempt_count > 0 ); //Some actions need to be taken from the kernel @@ -289,4 +299,5 @@ processor * proc = (processor *) arg; this_processor = proc; + disable_preempt_count = 1; // SKULLDUGGERY: We want to create a context for the processor coroutine // which is needed for the 2-step context switch. However, there is no reason @@ -322,6 +333,33 @@ void start(processor * this) { LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this); - + + // SIGALRM must only be caught by the system processor + sigset_t old_mask; + bool is_system_proc = this_processor == &systemProcessor->proc; + if ( is_system_proc ) { + // Child kernel-thread inherits the signal mask from the parent kernel-thread. So one special case for the + // system processor creating the user processor => toggle the blocking SIGALRM on system processor, create user + // processor, and toggle back (below) previous signal mask of the system processor. + + sigset_t new_mask; + sigemptyset( &new_mask ); + sigemptyset( &old_mask ); + sigaddset( &new_mask, SIGALRM ); + + if ( sigprocmask( SIG_BLOCK, &new_mask, &old_mask ) == -1 ) { + abortf( "internal error, sigprocmask" ); + } + + assert( ! sigismember( &old_mask, SIGALRM ) ); + } + pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this ); + + // Toggle back previous signal mask of system processor. + if ( is_system_proc ) { + if ( sigprocmask( SIG_SETMASK, &old_mask, NULL ) == -1 ) { + abortf( "internal error, sigprocmask" ); + } // if + } // if LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this); @@ -347,35 +385,64 @@ } -void ScheduleInternal() { +void BlockInternal() { + disable_interrupts(); + verify( disable_preempt_count > 0 ); suspend(); -} - -void ScheduleInternal( spinlock * lock ) { + verify( disable_preempt_count > 0 ); + enable_interrupts( __PRETTY_FUNCTION__ ); +} + +void BlockInternal( spinlock * lock ) { + disable_interrupts(); this_processor->finish.action_code = Release; this_processor->finish.lock = lock; + + verify( disable_preempt_count > 0 ); suspend(); -} - -void ScheduleInternal( thread_desc * thrd ) { + verify( disable_preempt_count > 0 ); + + enable_interrupts( __PRETTY_FUNCTION__ ); +} + +void BlockInternal( thread_desc * thrd ) { + disable_interrupts(); this_processor->finish.action_code = Schedule; this_processor->finish.thrd = thrd; + + verify( disable_preempt_count > 0 ); suspend(); -} - -void ScheduleInternal( spinlock * lock, thread_desc * thrd ) { + verify( disable_preempt_count > 0 ); + + enable_interrupts( __PRETTY_FUNCTION__ ); +} + +void BlockInternal( spinlock * lock, thread_desc * thrd ) { + disable_interrupts(); this_processor->finish.action_code = Release_Schedule; this_processor->finish.lock = lock; this_processor->finish.thrd = thrd; + + verify( disable_preempt_count > 0 ); suspend(); -} - -void ScheduleInternal(spinlock ** locks, unsigned short count) { + verify( disable_preempt_count > 0 ); + + enable_interrupts( __PRETTY_FUNCTION__ ); +} + +void BlockInternal(spinlock ** locks, unsigned short count) { + disable_interrupts(); this_processor->finish.action_code = Release_Multi; this_processor->finish.locks = locks; this_processor->finish.lock_count = count; + + verify( disable_preempt_count > 0 ); suspend(); -} - -void ScheduleInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) { + verify( disable_preempt_count > 0 ); + + enable_interrupts( __PRETTY_FUNCTION__ ); +} + +void BlockInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) { + disable_interrupts(); this_processor->finish.action_code = Release_Multi_Schedule; this_processor->finish.locks = locks; @@ -383,5 +450,10 @@ this_processor->finish.thrds = thrds; this_processor->finish.thrd_count = thrd_count; + + verify( disable_preempt_count > 0 ); suspend(); + verify( disable_preempt_count > 0 ); + + enable_interrupts( __PRETTY_FUNCTION__ ); } @@ -403,7 +475,4 @@ LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n"); - // Enable preemption - kernel_start_preemption(); - // Initialize the system cluster systemCluster = (cluster *)&systemCluster_storage; @@ -425,4 +494,8 @@ this_processor->current_thread = mainThread; this_processor->current_coroutine = &mainThread->cor; + disable_preempt_count = 1; + + // Enable preemption + kernel_start_preemption(); // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX @@ -435,8 +508,12 @@ // THE SYSTEM IS NOW COMPLETELY RUNNING LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n"); + + enable_interrupts( __PRETTY_FUNCTION__ ); } void kernel_shutdown(void) { LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n"); + + disable_interrupts(); // SKULLDUGGERY: Notify the systemProcessor it needs to terminates. @@ -447,4 +524,7 @@ // THE SYSTEM IS NOW COMPLETELY STOPPED + + // Disable preemption + kernel_stop_preemption(); // Destroy the system processor and its context in reverse order of construction @@ -550,8 +630,9 @@ if( !this->cond ) { append( &this->blocked, this_thread() ); - ScheduleInternal( &this->lock ); - lock( &this->lock ); - } - unlock( &this->lock ); + BlockInternal( &this->lock ); + } + else { + unlock( &this->lock ); + } } @@ -561,8 +642,10 @@ this->cond = true; + disable_interrupts(); thread_desc * it; while( it = pop_head( &this->blocked) ) { ScheduleThread( it ); } + enable_interrupts( __PRETTY_FUNCTION__ ); } unlock( &this->lock ); Index: src/libcfa/concurrency/kernel_private.h =================================================================== --- src/libcfa/concurrency/kernel_private.h (revision da244680ae17dc5096698c3329c84254f9deaa55) +++ src/libcfa/concurrency/kernel_private.h (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -30,10 +30,10 @@ thread_desc * nextThread(cluster * this); -void ScheduleInternal(void); -void ScheduleInternal(spinlock * lock); -void ScheduleInternal(thread_desc * thrd); -void ScheduleInternal(spinlock * lock, thread_desc * thrd); -void ScheduleInternal(spinlock ** locks, unsigned short count); -void ScheduleInternal(spinlock ** locks, unsigned short count, thread_desc ** thrds, unsigned short thrd_count); +void BlockInternal(void); +void BlockInternal(spinlock * lock); +void BlockInternal(thread_desc * thrd); +void BlockInternal(spinlock * lock, thread_desc * thrd); +void BlockInternal(spinlock ** locks, unsigned short count); +void BlockInternal(spinlock ** locks, unsigned short count, thread_desc ** thrds, unsigned short thrd_count); //----------------------------------------------------------------------------- @@ -60,23 +60,11 @@ extern cluster * systemCluster; extern system_proc_t * systemProcessor; -extern thread_local processor * this_processor; +extern volatile thread_local processor * this_processor; +extern volatile thread_local unsigned short disable_preempt_count; -static inline void disable_interrupts() { - __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, 1, __ATOMIC_SEQ_CST ); - assert( prev != (unsigned short) -1 ); -} - -static inline void enable_interrupts_noRF() { - __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST ); - verify( prev != (unsigned short) 0 ); -} - -static inline void enable_interrupts() { - __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST ); - verify( prev != (unsigned short) 0 ); - if( prev == 1 && this_processor->pending_preemption ) { - ScheduleInternal( this_processor->current_thread ); - this_processor->pending_preemption = false; - } +extern "C" { + void disable_interrupts(); + void enable_interrupts_noRF(); + void enable_interrupts( const char * ); } Index: src/libcfa/concurrency/monitor.c =================================================================== --- src/libcfa/concurrency/monitor.c (revision da244680ae17dc5096698c3329c84254f9deaa55) +++ src/libcfa/concurrency/monitor.c (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -63,7 +63,7 @@ append( &this->entry_queue, thrd ); LIB_DEBUG_PRINT_SAFE("%p Blocking on entry\n", thrd); - ScheduleInternal( &this->lock ); - - //ScheduleInternal will unlock spinlock, no need to unlock ourselves + BlockInternal( &this->lock ); + + //BlockInternal will unlock spinlock, no need to unlock ourselves return; } @@ -170,5 +170,5 @@ unsigned short count = this->monitor_count; unsigned int recursions[ count ]; //Save the current recursion levels to restore them later - spinlock * locks [ count ]; //We need to pass-in an array of locks to ScheduleInternal + spinlock * locks [ count ]; //We need to pass-in an array of locks to BlockInternal LIB_DEBUG_PRINT_SAFE("count %i\n", count); @@ -208,5 +208,5 @@ // Everything is ready to go to sleep - ScheduleInternal( locks, count, threads, thread_count ); + BlockInternal( locks, count, threads, thread_count ); @@ -281,5 +281,5 @@ unsigned short count = this->monitor_count; unsigned int recursions[ count ]; //Save the current recursion levels to restore them later - spinlock * locks [ count ]; //We need to pass-in an array of locks to ScheduleInternal + spinlock * locks [ count ]; //We need to pass-in an array of locks to BlockInternal lock_all( this->monitors, locks, count ); @@ -309,5 +309,5 @@ //Everything is ready to go to sleep - ScheduleInternal( locks, count, &signallee, 1 ); + BlockInternal( locks, count, &signallee, 1 ); @@ -339,5 +339,5 @@ // unsigned short count = this->current_monitor_count; // unsigned int recursions[ count ]; //Save the current recursion levels to restore them later - // spinlock * locks [ count ]; //We need to pass-in an array of locks to ScheduleInternal + // spinlock * locks [ count ]; //We need to pass-in an array of locks to BlockInternal // lock_all( this->current_monitors, locks, count ); @@ -348,5 +348,5 @@ // // // Everything is ready to go to sleep - // // ScheduleInternal( locks, count, threads, thread_count ); + // // BlockInternal( locks, count, threads, thread_count ); Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision da244680ae17dc5096698c3329c84254f9deaa55) +++ src/libcfa/concurrency/preemption.c (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -17,9 +17,18 @@ #include "preemption.h" + extern "C" { +#include +#define __USE_GNU #include -} - -#define __CFA_DEFAULT_PREEMPTION__ 10 +#undef __USE_GNU +#include +#include +#include +} + +#include "libhdr.h" + +#define __CFA_DEFAULT_PREEMPTION__ 10000 __attribute__((weak)) unsigned int default_preemption() { @@ -27,6 +36,14 @@ } +#define __CFA_SIGCXT__ ucontext_t * +#define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt + static void preempt( processor * this ); static void timeout( thread_desc * this ); + +void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ); +void sigHandler_alarm ( __CFA_SIGPARMS__ ); + +static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ); //============================================================================================= @@ -35,12 +52,37 @@ void kernel_start_preemption() { - -} + LIB_DEBUG_PRINT_SAFE("Kernel : Starting preemption\n"); + __kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO ); + __kernel_sigaction( SIGALRM, sigHandler_alarm , SA_SIGINFO ); +} + +void kernel_stop_preemption() { + //Block all signals, we are no longer in a position to handle them + sigset_t mask; + sigfillset( &mask ); + sigprocmask( SIG_BLOCK, &mask, NULL ); + LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n"); + + assert( !systemProcessor->alarms.head ); + assert( systemProcessor->alarms.tail == &systemProcessor->alarms.head ); +} + +LIB_DEBUG_DO( bool validate( alarm_list_t * this ); ) void tick_preemption() { + LIB_DEBUG_DO( + char text[256]; + __attribute__((unused)) int len = snprintf( text, 256, "Ticking preemption\n" ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); + alarm_list_t * alarms = &systemProcessor->alarms; __cfa_time_t currtime = __kernel_get_time(); while( alarms->head && alarms->head->alarm < currtime ) { alarm_node_t * node = pop(alarms); + LIB_DEBUG_DO( + len = snprintf( text, 256, "Ticking %p\n", node ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); if( node->kernel_alarm ) { preempt( node->proc ); @@ -50,6 +92,8 @@ } + LIB_DEBUG_DO( assert( validate( alarms ) ) ); + if( node->period > 0 ) { - node->alarm += node->period; + node->alarm = currtime + node->period; insert( alarms, node ); } @@ -62,9 +106,21 @@ __kernel_set_timer( alarms->head->alarm - currtime ); } + + verify( validate( alarms ) ); + LIB_DEBUG_DO( + len = snprintf( text, 256, "Ticking preemption done\n" ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); } void update_preemption( processor * this, __cfa_time_t duration ) { - // assert( THREAD_GETMEM( disableInt ) && THREAD_GETMEM( disableIntCnt ) == 1 ); + LIB_DEBUG_DO( + char text[256]; + __attribute__((unused)) int len = snprintf( text, 256, "Processor : %p updating preemption to %lu\n", this, duration ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); + alarm_node_t * alarm = this->preemption_alarm; + duration *= 1000; // Alarms need to be enabled @@ -97,4 +153,6 @@ void ^?{}( preemption_scope * this ) { + disable_interrupts(); + update_preemption( this->proc, 0 ); } @@ -104,6 +162,47 @@ //============================================================================================= +extern "C" { + void disable_interrupts() { + __attribute__((unused)) unsigned short new_val = __atomic_add_fetch_2( &disable_preempt_count, 1, __ATOMIC_SEQ_CST ); + verify( new_val < (unsigned short)65_000 ); + verify( new_val != (unsigned short) 0 ); + } + + void enable_interrupts_noRF() { + unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST ); + verify( prev != (unsigned short) 0 ); + } + + void enable_interrupts( const char * func ) { + unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST ); + verify( prev != (unsigned short) 0 ); + if( prev == 1 && this_processor->pending_preemption ) { + this_processor->pending_preemption = false; + LIB_DEBUG_DO( + char text[256]; + __attribute__((unused)) int len = snprintf( text, 256, "Executing deferred CtxSwitch on %p\n", this_processor ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); + BlockInternal( this_processor->current_thread ); + } + + this_processor->last_enable = func; + } +} + +static inline void signal_unblock( bool alarm ) { + sigset_t mask; + sigemptyset( &mask ); + sigaddset( &mask, SIGUSR1 ); + + if( alarm ) sigaddset( &mask, SIGALRM ); + + if ( sigprocmask( SIG_UNBLOCK, &mask, NULL ) == -1 ) { + abortf( "internal error, sigprocmask" ); + } // if +} + static inline bool preemption_ready() { - return this_processor->disable_preempt_count == 0; + return disable_preempt_count == 0; } @@ -116,14 +215,38 @@ } -void sigHandler_ctxSwitch( __attribute__((unused)) int sig ) { +void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) { + + LIB_DEBUG_DO( + char text[256]; + __attribute__((unused)) int len = snprintf( text, 256, "Ctx Switch IRH %p\n", (void *)(cxt->uc_mcontext.gregs[REG_RIP])); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); + + signal_unblock( false ); if( preemption_ready() ) { - ScheduleInternal( this_processor->current_thread ); + LIB_DEBUG_DO( + len = snprintf( text, 256, "Ctx Switch IRH : Blocking thread %p on %p\n", this_processor->current_thread, this_processor ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); + BlockInternal( this_processor->current_thread ); } else { + LIB_DEBUG_DO( + len = snprintf( text, 256, "Ctx Switch IRH : Defering\n" ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); defer_ctxSwitch(); } } -void sigHandler_alarm( __attribute__((unused)) int sig ) { +void sigHandler_alarm( __CFA_SIGPARMS__ ) { + + LIB_DEBUG_DO( + char text[256]; + __attribute__((unused)) int len = snprintf( text, 256, "\nAlarm IRH %p\n", (void *)(cxt->uc_mcontext.gregs[REG_RIP]) ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); + + signal_unblock( true ); if( try_lock( &systemProcessor->alarm_lock ) ) { tick_preemption(); @@ -133,8 +256,28 @@ defer_alarm(); } + + if( preemption_ready() && this_processor->pending_preemption ) { + LIB_DEBUG_DO( + len = snprintf( text, 256, "Alarm IRH : Blocking thread\n" ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); + this_processor->pending_preemption = false; + BlockInternal( this_processor->current_thread ); + } } static void preempt( processor * this ) { - pthread_kill( this->kernel_thread, SIGUSR1 ); + LIB_DEBUG_DO( + char text[256]; + __attribute__((unused)) int len = snprintf( text, 256, "Processor : signalling %p\n", this ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); + + if( this != systemProcessor ) { + pthread_kill( this->kernel_thread, SIGUSR1 ); + } + else { + defer_ctxSwitch(); + } } @@ -142,2 +285,22 @@ //TODO : implement waking threads } + +static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ) { + struct sigaction act; + + act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler; + sigemptyset( &act.sa_mask ); + sigaddset( &act.sa_mask, SIGALRM ); // disabled during signal handler + sigaddset( &act.sa_mask, SIGUSR1 ); + + act.sa_flags = flags; + + if ( sigaction( sig, &act, NULL ) == -1 ) { + // THE KERNEL IS NOT STARTED SO CALL NO uC++ ROUTINES! + char helpText[256]; + __attribute__((unused)) int len = snprintf( helpText, 256, " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n", + sig, handler, flags, errno, strerror( errno ) ); + LIB_DEBUG_WRITE( STDERR_FILENO, helpText, len ); + _exit( EXIT_FAILURE ); + } // if +} Index: src/libcfa/concurrency/thread.c =================================================================== --- src/libcfa/concurrency/thread.c (revision da244680ae17dc5096698c3329c84254f9deaa55) +++ src/libcfa/concurrency/thread.c (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -28,5 +28,5 @@ } -extern thread_local processor * this_processor; +extern volatile thread_local processor * this_processor; //----------------------------------------------------------------------------- @@ -84,5 +84,5 @@ void yield( void ) { - ScheduleInternal( this_processor->current_thread ); + BlockInternal( this_processor->current_thread ); } Index: src/libcfa/libhdr/libdebug.h =================================================================== --- src/libcfa/libhdr/libdebug.h (revision da244680ae17dc5096698c3329c84254f9deaa55) +++ src/libcfa/libhdr/libdebug.h (revision 405c5926c54ac57ff71e511c1792b90be12f7b82) @@ -19,8 +19,8 @@ #ifdef __CFA_DEBUG__ #define LIB_DEBUG_DO(x) x - #define LIB_NO_DEBUG_DO(x) ((void)0) + #define LIB_NO_DEBUG_DO(x) #else - #define LIB_DEBUG_DO(x) ((void)0) - #define LIB_NO_DEBUG_DO(x) x + #define LIB_DEBUG_DO(x) + #define LIB_NO_DEBUG_DO(x) x #endif