Changeset 407 for trunk/kernel/libk

Timestamp:

Nov 7, 2017, 3:08:12 PM (6 years ago)

Author:

alain

Message:

First implementation of fork/exec.

Location:

trunk/kernel/libk

Files:

• elf.c (modified) (9 diffs)
• remote_barrier.c (modified) (1 diff)
• remote_condvar.c (modified) (1 diff)
• remote_fifo.c (modified) (5 diffs)
• remote_fifo.h (modified) (3 diffs)
• remote_mutex.c (modified) (1 diff)
• remote_sem.c (modified) (1 diff)
• remote_spinlock.c (modified) (1 diff)
• spinlock.c (modified) (1 diff)

trunk/kernel/libk/elf.c

@@ -175 +175 @@
                 }
 
+        // get .elf file descriptor cluster and local pointer 
+        cxy_t        file_cxy = GET_CXY( file_xp );
+        vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
+
+        // get local pointer on .elf file mapper
+        mapper_t * mapper_ptr = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , 
+                                                                  &file_ptr->mapper ) );
                 // register vseg in VMM
                 vseg = (vseg_t *)vmm_create_vseg( process,
+                                          type,
                                                   vbase,
                                                   mem_size,
-                                                  type );
+                                          file_offset,
+                                          file_size,
+                                          XPTR( file_cxy , mapper_ptr ),
+                                                  local_cxy );  
                 if( vseg == NULL )
                 {
@@ -187 +198 @@
                 }
 
-        // get .elf file descriptor cluster and local pointer 
-        cxy_t        file_cxy = GET_CXY( file_xp );
-        vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
-
-        // get local pointer on .elf file mapper
-        mapper_t * mapper_ptr = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , 
-                                                                  &file_ptr->mapper ) );
-
-        // initialize "file_mapper", "file_offset", "file_size" fields in vseg 
-        vseg->mapper_xp   = XPTR( file_cxy , mapper_ptr );
-        vseg->file_offset = file_offset;
-        vseg->file_size   = file_size;
-
         // update reference counter in file descriptor
                 vfs_file_count_up( file_xp );
 
-                elf_dmsg("\n[DMSG] %s : found %s vseg / base = %x / size = %x\n"
+                elf_dmsg("\n[DBG] %s : found %s vseg / base = %x / size = %x\n"
                  "       file_size = %x / file_offset = %x / mapper_xp = %l\n",
             __FUNCTION__ , vseg_type_str(vseg->type) , vseg->min , vseg->max - vseg->min ,
@@ -225 +223 @@
         error_t      error;
 
-    elf_dmsg("\n[DMSG] %s : core[%x,%d] enter for <%s>\n",
+    elf_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s>\n",
     __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pathname );
 
@@ -233 +231 @@
 
         // open file
-        error = vfs_open( process->vfs_cwd_xp,
+        error = vfs_open( process,
                           pathname,
                           O_RDONLY,
@@ -245 +243 @@
         }
 
-    elf_dmsg("\n[DMSG] %s : open file <%s>\n", __FUNCTION__ , pathname );
+    elf_dmsg("\n[DBG] %s : open file <%s>\n", __FUNCTION__ , pathname );
 
         // load header in local buffer
@@ -258 +256 @@
         }
 
-        elf_dmsg("\n[DMSG] %s : loaded elf header for %s\n", __FUNCTION__ , pathname );
+        elf_dmsg("\n[DBG] %s : loaded elf header for %s\n", __FUNCTION__ , pathname );
 
         if( header.e_phnum == 0 )
@@ -295 +293 @@
         }
 
-        elf_dmsg("\n[DMSG] %s : segments array allocated for %s\n", __FUNCTION__ , pathname );
+        elf_dmsg("\n[DBG] %s : segments array allocated for %s\n", __FUNCTION__ , pathname );
 
         // load seg descriptors array to local buffer
@@ -312 +310 @@
         }
 
-        elf_dmsg("\n[DMSG] %s loaded segments descriptors for %s \n", __FUNCTION__ , pathname );
+        elf_dmsg("\n[DBG] %s loaded segments descriptors for %s \n", __FUNCTION__ , pathname );
 
         // register loadable segments in process VMM
@@ -337 +335 @@
         kmem_free(&req);
 
-    elf_dmsg("\n[DMSG] %s : core[%x,%d] exit for <%s> / entry_point = %x\n",
+    elf_dmsg("\n[DBG] %s : core[%x,%d] exit for <%s> / entry_point = %x\n",
     __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pathname , header.e_entry );
 

trunk/kernel/libk/remote_barrier.c

@@ -274 +274 @@
         // block & deschedule the calling thread
         thread_block( thread_ptr , THREAD_BLOCKED_USERSYNC );
-        sched_yield( NULL );
+        sched_yield();
 
         // restore interrupts

trunk/kernel/libk/remote_condvar.c

@@ -189 +189 @@
     // block the calling thread 
     thread_block( CURRENT_THREAD , THREAD_BLOCKED_USERSYNC );
-    sched_yield( NULL );
+    sched_yield();
 
     // lock the mutex before return

trunk/kernel/libk/remote_fifo.c

@@ -39 +39 @@
     uint32_t  slot;
 
+    fifo->owner     = 0;
         fifo->wr_id     = 0;
         fifo->rd_id     = 0;
@@ -47 +48 @@
 }
 
-////////////////////////////////////////////// 
-error_t remote_fifo_put_item( xptr_t     fifo, 
-                              uint64_t   item,
-                              bool_t   * first )
+/////////////////////////////////////////////////
+error_t remote_fifo_put_item( xptr_t     fifo_xp, 
+                              uint64_t   item )
 {
     uint32_t        wr_id;
@@ -56 +56 @@
     uint32_t        ptw;
     uint32_t        watchdog;
-    reg_t           save_sr;
     uint32_t        nslots;
 
     // get remote cluster identifier and pointer on FIFO
-    cxy_t           cxy = (cxy_t)GET_CXY( fifo );
-    remote_fifo_t * ptr = (remote_fifo_t *)GET_PTR( fifo );
+    cxy_t           fifo_cxy = (cxy_t)GET_CXY( fifo_xp );
+    remote_fifo_t * fifo_ptr = (remote_fifo_t *)GET_PTR( fifo_xp );
 
     // initialise watchdog for contention detection
     watchdog = 0;
 
-    // no descheduling during put access
-        hal_disable_irq( &save_sr );
-        
-    // get write slot index and atomic increment 
-        wr_id = hal_remote_atomic_add( XPTR( cxy , &ptr->wr_id ) , 1 );
+    // get write slot index with atomic increment 
+        wr_id = hal_remote_atomic_add( XPTR( fifo_cxy , &fifo_ptr->wr_id ) , 1 );
 
-    // check fifo state
+    // wait until allocated slot is empty in remote FIFO
+    // max retry = CONFIG_REMOTE_FIFO_MAX_ITERATIONS  
+    // return error if watchdog is reached
     while( 1 )
     {
         // return error if contention detected by watchdog
-        if( watchdog > CONFIG_REMOTE_FIFO_MAX_ITERATIONS ) 
-        {
-            // restore scheduling
-                hal_restore_irq( save_sr );
-
-            // return error
-            return EBUSY;
-        }
+        if( watchdog > CONFIG_REMOTE_FIFO_MAX_ITERATIONS )  return EBUSY;
 
         // read remote rd_id value
-        rd_id = hal_remote_lw( XPTR( cxy , &ptr->rd_id ) );
+        rd_id = hal_remote_lw( XPTR( fifo_cxy , &fifo_ptr->rd_id ) );
 
         // compute number of full slots
@@ -92 +83 @@
         else                 nslots = (0xFFFFFFFF - rd_id) + wr_id;
 
-        // exit if fifo not full
+        // exit waiting loop as soon as fifo not full
         if ( nslots < CONFIG_REMOTE_FIFO_SLOTS )  break;
         
-        // restore interrupts
-            hal_restore_irq( save_sr );
-
-        // deschedule without blocking 
-        if( thread_can_yield() ) sched_yield( NULL );
-
-        // disable interrupts
-            hal_disable_irq( &save_sr );
+        // retry later if fifo full:
+        // - deschedule without blocking if possible
+        // - wait ~1000 cycles otherwise
+        if( thread_can_yield() ) sched_yield();
+        else                     hal_fixed_delay( 1000 );
 
         // increment watchdog
@@ -112 +100 @@
 
     // copy item to fifo
-        hal_remote_swd( XPTR( cxy , &ptr->data[ptw] ), item );
-
+        hal_remote_swd( XPTR( fifo_cxy , &fifo_ptr->data[ptw] ), item );
         hal_fence();
 
     // set the slot valid flag
-        hal_remote_sw( XPTR( cxy , &ptr->valid[ptw] ) , 1 );
+        hal_remote_sw( XPTR( fifo_cxy , &fifo_ptr->valid[ptw] ) , 1 );
         hal_fence();
-
-    // return the first RPC flag
-    *first = ( wr_id == rd_id );
-    
-    // restore scheduling
-        hal_restore_irq( save_sr );
 
     return 0;

trunk/kernel/libk/remote_fifo.h

@@ -28 +28 @@
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <printk.h>
 #include <errno.h>
 #include <hal_remote.h>
 
 /************************************************************************************
- * This structure defines a generic, single reader, multiple writers
- * remote FIFO, that is used by the RPCs for inter cluster communications.
- * The accesses are implemented using a lock-free algorithm, as it uses a ticket 
- * based mechanism to handle concurrent access between multiple writers.
- * Each FIF0 slot can contain one 64 bits integer.
- * In case of FIFO full, the writer deschedule without blocking, to retry later.
- *
- * WARNING : the number of slots is statically defined by the global 
- * configuration parameter CONFIG_REMOTE_FIFO_SLOTS for all fifos. requiring
- * Each FIFO requires 8 + (12 * CONFIG_REMOTE_FIFO_SLOTS) bytes.
+ * This structure defines a generic, single reader, multiple writers FIFO,
+ * that is used for - RPC based - inter cluster communications.
+ * Each FIF0 slot can contain one 64 bits integer (or one extended pointer).
+ * The number of slots is defined by the CONFIG_REMOTE_FIFO_SLOTS parameter.
+ * - The write accesses are implemented using a lock-free algorithm, as it uses
+ *   a ticket based mechanism to handle concurrent access between multiple writers.
+ *   In case of FIFO full, the writer deschedule without blocking, to retry later.
+ * - The reader must take the try_lock implemented by the "owner" field, using
+ *   an atomic_add(). The TRDID is a good owner identifier, because all
+ *   RPC threads in a given cluster belong to the same kernel process,
+ *   and RPC threads cannot have local index LTID = 0.
+*
+ * WARNING : Each FIFO requires 12 + (12 * CONFIG_REMOTE_FIFO_SLOTS) bytes.
  ***********************************************************************************/
 
 typedef struct remote_fifo_s
 {
+    uint32_t           owner;                            /*! owner thread trdid    */
         volatile uint32_t  wr_id;                            /*! write slot index      */
         volatile uint32_t  rd_id;                            /*! read  slot index      */
@@ -63 +68 @@
 /************************************************************************************
  * This non blocking function tries to get one item from the local fifo.
- * The reader must get exclusive access before calling this function.  
+ * The reader must get exclusive access for read before calling this function.  
  * The read slot index is incremented.
  ************************************************************************************
@@ -75 +80 @@
 /************************************************************************************
  * This blocking function puts one item to a remote fifo identified
- * by an extended pointer.
- * This function gets a write ticket using a remote_atomic_increment on the
- * write slot. Then, it waits until the slot is empty, using a descheduling
- * policy without blocking.
+ * by an extended pointer. It gets a write ticket on the slot to be written,
+ * using a remote_atomic_add() on the write slot index. Then, it waits until
+ * the slot is empty, using a descheduling policy without blocking if required. 
+ * It implements a watchdog, returning when the item has been successfully
+ * registered, or after CONFIG_REMOTE_FIFO_MAX_ITERATIONS failures.   
  ************************************************************************************
  * @ fifo    : extended pointer to the fifo in remote cluster.
  * @ item    : item to be stored.
- * @ first   : [out] true if first item registered in remote fifo.
  * @ return  0 on success / EBUSY if a contention has been detected.
  ***********************************************************************************/
 error_t remote_fifo_put_item( xptr_t     fifo,
-                              uint64_t   item,
-                              bool_t   * first );
+                              uint64_t   item );
 
 /************************************************************************************

trunk/kernel/libk/remote_mutex.c

@@ -208 +208 @@
         // block & deschedule the calling thread   
         thread_block( thread_ptr , THREAD_BLOCKED_USERSYNC );
-        sched_yield( NULL );
+        sched_yield();
 
         // restore interrupts

trunk/kernel/libk/remote_sem.c

@@ -219 +219 @@
         // block and deschedule
         thread_block( this , THREAD_BLOCKED_SEM );  
-        sched_yield( NULL );
+        sched_yield();
         }
 }  // end remote_sem_wait()

trunk/kernel/libk/remote_spinlock.c

@@ -179 +179 @@
                 {
                         hal_restore_irq( mode );
-                        if( thread_can_yield() ) sched_yield( NULL );
+                        if( thread_can_yield() ) sched_yield();
                         hal_disable_irq( &mode );
                         continue;

trunk/kernel/libk/spinlock.c

@@ -111 +111 @@
         {
             hal_restore_irq( mode );
-            if( thread_can_yield() ) sched_yield( NULL );
+            if( thread_can_yield() ) sched_yield();
             hal_disable_irq( &mode );
             continue;