Changes in src/libcfa/concurrency/kernel.c [c81ebf9:82ff5845]

File:

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

src/libcfa/concurrency/kernel.c

@@ -154 +154 @@
         (&this->terminated){};
         this->is_terminated = false;
-        this->disable_preempt_count = 0;
+        this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
+        this->disable_preempt_count = 1;
         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 };
 }
@@ -240 +243 @@
         //Update global state
         this->current_thread = dst;
+
+        LIB_DEBUG_PRINT_SAFE("Kernel : running %p\n", dst);
 
         // Context Switch to the thread
@@ -322 +327 @@
 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 +379 @@
 }
 
-void ScheduleInternal() {
+void BlockInternal() {
+        disable_interrupts();
         suspend();
-}
-
-void ScheduleInternal( spinlock * lock ) {
+        enable_interrupts();
+}
+
+void BlockInternal( spinlock * lock ) {
+        disable_interrupts();
         this_processor->finish.action_code = Release;
         this_processor->finish.lock = lock;
         suspend();
-}
-
-void ScheduleInternal( thread_desc * thrd ) {
+        enable_interrupts();
+}
+
+void BlockInternal( thread_desc * thrd ) {
+        disable_interrupts();
         this_processor->finish.action_code = Schedule;
         this_processor->finish.thrd = thrd;
         suspend();
-}
-
-void ScheduleInternal( spinlock * lock, thread_desc * thrd ) {
+        enable_interrupts();
+}
+
+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;
         suspend();
-}
-
-void ScheduleInternal(spinlock ** locks, unsigned short count) {
+        enable_interrupts();
+}
+
+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;
         suspend();
-}
-
-void ScheduleInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) {
+        enable_interrupts();
+}
+
+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;
@@ -384 +427 @@
         this_processor->finish.thrd_count = thrd_count;
         suspend();
+        enable_interrupts();
 }
 
@@ -403 +447 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
 
-        // Enable preemption
-        kernel_start_preemption();
-
         // Initialize the system cluster
         systemCluster = (cluster *)&systemCluster_storage;
@@ -426 +467 @@
         this_processor->current_coroutine = &mainThread->cor;
 
+        // 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
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
@@ -435 +479 @@
         // THE SYSTEM IS NOW COMPLETELY RUNNING
         LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");
+
+        enable_interrupts();
 }
 
@@ -447 +493 @@
 
         // THE SYSTEM IS NOW COMPLETELY STOPPED
+
+        // Disable preemption
+        kernel_stop_preemption();
 
         // Destroy the system processor and its context in reverse order of construction
@@ -550 +599 @@
         if( !this->cond ) {
                 append( &this->blocked, this_thread() );
-                ScheduleInternal( &this->lock );
+                BlockInternal( &this->lock );
                 lock( &this->lock );
         }