Changeset 450 for trunk/kernel/kern/scheduler.c

Timestamp:

Jun 29, 2018, 10:44:14 AM (6 years ago)

Author:

alain

Message:

Fix a bug in function sched_handle_signal():
When the deleted user thread is the last executed thread,
the sched->u_last field must be updated to point on another user thread.

File:

• trunk/kernel/kern/scheduler.c (modified) (10 diffs)

trunk/kernel/kern/scheduler.c

@@ -104 +104 @@
     list_entry_t * root;
     bool_t         done;
+    uint32_t       count;
 
     // take lock protecting sheduler lists
@@ -113 +114 @@
         root    = &sched->k_root;
         last    = sched->k_last;
+        done    = false;
+        count   = 0;
         current = last;
-        done    = false;
 
         while( done == false )
         {
+            assert( (count < sched->k_threads_nr), __FUNCTION__, "bad kernel threads list" );
+
             // get next entry in kernel list
             current = current->next;
@@ -126 +130 @@
             // skip the root that does not contain a thread
             if( current == root ) continue;
+            else                  count++;
 
             // get thread pointer for this entry
             thread = LIST_ELEMENT( current , thread_t , sched_list );
 
-            // select kernel thread if non blocked and non IDLE
+            // select kernel thread if non blocked and non THREAD_IDLE
             if( (thread->blocked == 0)  && (thread->type != THREAD_IDLE) )
             {
@@ -137 +142 @@
             }
         } // end loop on kernel threads
-    } // end if kernel threads
+    } // end kernel threads
 
     // second : scan the user threads list if not empty 
@@ -144 +149 @@
         root    = &sched->u_root;
         last    = sched->u_last;
+        done    = false;
+        count   = 0;
         current = last;
-        done    = false;
 
         while( done == false )
         {
+            assert( (count < sched->u_threads_nr), __FUNCTION__, "bad user threads list" );
+
             // get next entry in user list
             current = current->next;
@@ -157 +165 @@
             // skip the root that does not contain a thread
             if( current == root ) continue;
+            else                  count++;
 
             // get thread pointer for this entry
             thread = LIST_ELEMENT( current , thread_t , sched_list );
 
-            // return thread if non blocked
+            // select thread if non blocked
             if( thread->blocked == 0 )
             {
@@ -168 +177 @@
             }
         } // end loop on user threads
-    } // end if user threads
+    } // end user threads
 
     // third : return idle thread if no other runnable thread
@@ -240 +249 @@
             sched->u_threads_nr = threads_nr - 1;
             list_unlink( &thread->sched_list );
-            if( threads_nr == 1 ) sched->u_last = NULL;
-
-            // delete thread
+            if( sched->u_last == &thread->sched_list )
+            {
+                if( threads_nr == 1 ) 
+                {
+                    sched->u_last = NULL;
+                }
+                else if( sched->u_root.next == &thread->sched_list )
+                {
+                    sched->u_last = sched->u_root.pred;
+                }
+                else
+                {
+                    sched->u_last = sched->u_root.next;
+                }
+            }
+
+            // delete thread descriptor
             last_thread = thread_destroy( thread );
 
@@ -263 +286 @@
 __FUNCTION__ , process->pid , local_cxy , cycle );
 #endif
-
             }
         }
@@ -421 +443 @@
 }  // end sched_display()
 
+/////////////////////////////////////
+void sched_remote_display( cxy_t cxy,
+                           lid_t lid )
+{
+    thread_t     * thread;
+    uint32_t       save_sr;
+
+    // check cxy
+    bool_t undefined = cluster_is_undefined( cxy );
+    assert( (undefined == false), __FUNCTION__, "illegal cluster %x\n", cxy );
+
+    // check lid
+    uint32_t cores = hal_remote_lw( XPTR( cxy , &LOCAL_CLUSTER->cores_nr ) );
+    assert( (lid < cores), __FUNCTION__, "illegal core index %d\n", lid);
+
+    // get local pointer on target scheduler
+    core_t      * core  = &LOCAL_CLUSTER->core_tbl[lid];
+    scheduler_t * sched = &core->scheduler;
+
+    // get local pointer on current thread in target scheduler
+    thread_t * current = hal_remote_lpt( XPTR( cxy, &sched->current ) );
+
+    // get local pointer on the first kernel and user threads list_entry
+    list_entry_t * k_entry = hal_remote_lpt( XPTR( cxy , &sched->k_root.next ) );
+    list_entry_t * u_entry = hal_remote_lpt( XPTR( cxy , &sched->u_root.next ) );
+    
+    // get pointers on TXT0 chdev
+    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
+    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
+    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
+
+    // get extended pointer on remote TXT0 chdev lock
+    xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+
+    // get TXT0 lock in busy waiting mode
+    remote_spinlock_lock_busy( lock_xp , &save_sr );
+
+    // display header
+    nolock_printk("\n***** threads on core[%x,%d] / current %x / cycle %d\n",
+    cxy , lid, current, (uint32_t)hal_get_cycles() );
+
+    // display kernel threads
+    while( k_entry != &sched->k_root )
+    {
+        // get local pointer on kernel_thread
+        thread = LIST_ELEMENT( k_entry , thread_t , sched_list );
+
+        // get relevant thead info
+        thread_type_t type    = hal_remote_lw ( XPTR( cxy , &thread->type ) );
+        trdid_t       trdid   = hal_remote_lw ( XPTR( cxy , &thread->trdid ) );
+        uint32_t      blocked = hal_remote_lw ( XPTR( cxy , &thread->blocked ) );
+        uint32_t      flags   = hal_remote_lw ( XPTR( cxy , &thread->flags ) );
+        process_t *   process = hal_remote_lpt( XPTR( cxy , &thread->process ) );
+        pid_t         pid     = hal_remote_lw ( XPTR( cxy , &process->pid ) );
+
+        // display thread info
+        if (type == THREAD_DEV) 
+        {
+            char      name[16];
+            chdev_t * chdev = hal_remote_lpt( XPTR( cxy , &thread->chdev ) );
+            hal_remote_strcpy( XPTR( local_cxy , name ), XPTR( cxy , &chdev->name ) );
+
+            nolock_printk(" - %s / pid %X / trdid %X / desc %X / block %X / flags %X / %s\n",
+            thread_type_str( type ), pid, trdid, thread, blocked, flags, name );
+        }
+        else
+        {
+            nolock_printk(" - %s / pid %X / trdid %X / desc %X / block %X / flags %X\n",
+            thread_type_str( type ), pid, trdid, thread, blocked, flags );
+        }
+
+        // get next remote kernel thread list_entry
+        k_entry = hal_remote_lpt( XPTR( cxy , &k_entry->next ) );
+    }
+
+    // display user threads
+    while( u_entry != &sched->u_root )
+    {
+        // get local pointer on user_thread
+        thread = LIST_ELEMENT( u_entry , thread_t , sched_list );
+
+        // get relevant thead info
+        thread_type_t type    = hal_remote_lw ( XPTR( cxy , &thread->type ) );
+        trdid_t       trdid   = hal_remote_lw ( XPTR( cxy , &thread->trdid ) );
+        uint32_t      blocked = hal_remote_lw ( XPTR( cxy , &thread->blocked ) );
+        uint32_t      flags   = hal_remote_lw ( XPTR( cxy , &thread->flags ) );
+        process_t *   process = hal_remote_lpt( XPTR( cxy , &thread->process ) );
+        pid_t         pid     = hal_remote_lw ( XPTR( cxy , &process->pid ) );
+
+        nolock_printk(" - %s / pid %X / trdid %X / desc %X / block %X / flags %X\n",
+        thread_type_str( type ), pid, trdid, thread, blocked, flags );
+
+        // get next user thread list_entry
+        u_entry = hal_remote_lpt( XPTR( cxy , &u_entry->next ) );
+    }
+
+    // release TXT0 lock
+    remote_spinlock_unlock_busy( lock_xp , save_sr );
+
+}  // end sched_remote_display()
+