Changes in src/libcfa/concurrency/kernel.c [4aa2fb2:0b33412]

File:

• src/libcfa/concurrency/kernel.c (modified) (15 diffs)

src/libcfa/concurrency/kernel.c

@@ -59 +59 @@
 // 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 +143 @@
         this->preemption_alarm = NULL;
         this->preemption = default_preemption();
-        this->disable_preempt_count = 1;                //Start with interrupts disabled
         this->pending_preemption = false;
 
@@ -154 +154 @@
         (&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 +172 @@
 
         (&this->proc){ cltr, runner };
+
+        verify( validate( &this->alarms ) );
 }
 
@@ -209 +215 @@
                         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 +299 @@
         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 +333 @@
 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 +385 @@
 }
 
-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 +450 @@
         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 +475 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
 
-        // Enable preemption
-        kernel_start_preemption();
-
         // Initialize the system cluster
         systemCluster = (cluster *)&systemCluster_storage;
@@ -425 +494 @@
         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 +508 @@
         // 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 +524 @@
 
         // THE SYSTEM IS NOW COMPLETELY STOPPED
+
+        // Disable preemption
+        kernel_stop_preemption();
 
         // Destroy the system processor and its context in reverse order of construction
@@ -550 +630 @@
         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 +642 @@
                 this->cond = true;
 
+                disable_interrupts();
                 thread_desc * it;
                 while( it = pop_head( &this->blocked) ) {
                         ScheduleThread( it );
                 }
+                enable_interrupts( __PRETTY_FUNCTION__ );
         }
         unlock( &this->lock );