Changeset 714

Timestamp:

Oct 7, 2015, 12:02:48 PM (9 years ago)

Author:

alain

Message:

Introduce the _sys_fbf_size() function.
Modify the _sys_fbf_alloc() / _sys_fbf_release() functions
to allow all threads of a given vspace to access the frame buffer.
(replace the lock by a multi-threads allocator.

Location:

soft/giet_vm/giet_kernel

Files:

• ctx_handler.c (modified) (1 diff)
• ctx_handler.h (modified) (1 diff)
• sys_handler.c (modified) (142 diffs)
• sys_handler.h (modified) (5 diffs)

soft/giet_vm/giet_kernel/ctx_handler.c

@@ -58 +58 @@
     if ( psched->context[ltid].slot[CTX_LOCKS_ID] & LOCKS_MASK_FAT ) 
     {
+        
         _spin_lock_release( &_fat.fat_lock );
+    }
+
+    // release FBF lock if taken 
+    if ( psched->context[ltid].slot[CTX_LOCKS_ID] & LOCKS_MASK_FBF ) 
+    {
+        _sys_fbf_release();
     }
 

soft/giet_vm/giet_kernel/ctx_handler.h

@@ -104 +104 @@
 #define LOCKS_MASK_BDV        0x00000001   // BDV kernel lock taken
 #define LOCKS_MASK_FAT        0x00000002   // FAT kernel lock taken
+#define LOCKS_MASK_FBF        0x00000004   // FBF kernel lock taken
 
 /////////////////////////////////////////////////////////////////////////////////

soft/giet_vm/giet_kernel/sys_handler.c

@@ -95 +95 @@
 extern static_scheduler_t* _schedulers[X_SIZE][Y_SIZE][NB_PROCS_MAX]; 
 
+// allocated in bdv_driver.c file
+spin_lock_t  _bdv_lock;
+
+////////////////////////////////////////////////////////////////////////////////
+//     Allocator protecting exclusive access to FBF by a single application.
+// - The number of users in a given application should be set by a single
+//   thread using an _atomic_test_and_set().
+// - The allocator is atomically decremented by each user thread when 
+//   the thread exit.    
+////////////////////////////////////////////////////////////////////////////////
+
+__attribute__((section(".kdata")))
+unsigned int _fbf_alloc = 0;
+
 ////////////////////////////////////////////////////////////////////////////////
 //     Channel allocators for multi-channels peripherals
@@ -179 +193 @@
     &_sys_xy_from_ptr,               /* 0x03 */
     &_sys_ukn,                       /* 0x04 */
-    &_sys_ukn,                       /* 0x05 */
-    &_sys_ukn,                       /* 0x06 */
+    &_sys_vseg_get_vbase,            /* 0x05 */
+    &_sys_vseg_get_length,           /* 0x06 */
     &_sys_heap_info,                 /* 0x07 */
-    &_sys_vseg_get_vbase,            /* 0x08 */
-    &_sys_vseg_get_length,           /* 0x09 */ 
+    &_sys_fbf_size,                  /* 0x08 */
+    &_sys_fbf_alloc,                 /* 0x09 */ 
     &_sys_fbf_cma_alloc,             /* 0x0A */
     &_sys_fbf_cma_init_buf,          /* 0x0B */
@@ -251 +265 @@
 // This function is called by the _sys_exec_application function
 // to reload all data segments contained in an application.elf file.
+// File checking is minimal, because these segments have already
+// been loaded by the boot code. 
 ////////////////////////////////////////////////////////////////////////
 static unsigned int _load_writable_segments( mapping_vspace_t*  vspace )
@@ -262 +278 @@
 unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _load_writable_segments() : P[%d,%d,%d] "
-        "enters for %s\n", x , y , p , vspace->name );
+_printf("\n[DEBUG EXEC] _load_writable_segments() at cycle %d\n"
+        "P[%d,%d,%d] enters for %s\n",
+        _get_proctime() , x , y , p , vspace->name );
 #endif
 
@@ -271 +288 @@
     unsigned int vseg_id;        // vseg index in mapping
     char         buf[4096];      // buffer to store one cluster
-    unsigned int fd = 0;         // file descriptor
+    unsigned int fd    = 0;      // file descriptor
+    unsigned int found = 0;
 
     // first scan on vsegs in vspace to find the .elf pathname
@@ -283 +301 @@
             fd = _fat_open( vseg[vseg_id].binpath , O_RDONLY );
             if ( fd < 0 ) return 1;
-            break;
 
 #if GIET_DEBUG_EXEC
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _load_writable_segments() : P[%d,%d,%d] "
-        "open %s / fd = %d\n", x , y , p , vseg[vseg_id].binpath , fd );
-#endif
+_printf("\n[DEBUG EXEC] _load_writable_segments() at cycle %d\n"
+        "P[%d,%d,%d] open %s / fd = %d\n", 
+        _get_proctime() , x , y , p , vseg[vseg_id].binpath , fd );
+#endif
+            found = 1;
+            break;
+ 
         }
     }
  
+    // check .elf file found
+    if ( found == 0 )
+    {
+
+_printf("@@@ _load_writable_segments() : .elf not found\n");
+
+        return 1;
+    }
+
     // load Elf-Header into buffer from .elf file
     if ( _fat_lseek( fd, 0, SEEK_SET ) < 0 )
     {
+
+_printf("@@@ _load_writable_segments() : cannot seek\n");
+
         _fat_close( fd );
         return 1;
+
     }
     if ( _fat_read( fd, (unsigned int)buf, 4096, 0 ) < 0 )
     {
+
+_printf("@@@ _load_writable_segments() : cannot read\n");
+
         _fat_close( fd );
         return 1;
@@ -307 +344 @@
 #if GIET_DEBUG_EXEC
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _load_writable_segments() : P[%d,%d,%d] "
-        "loaded Elf-Header\n", x , y , p );
+_printf("\n[DEBUG EXEC] _load_writable_segments() at cycle %d\n"
+        "P[%d,%d,%d] loaded Elf-Header\n",
+        _get_proctime() , x , y , p );
 #endif
 
@@ -330 +368 @@
 #if GIET_DEBUG_EXEC
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _load_writable_segments() : P[%d,%d,%d] "
-        "loaded Program-Header-Table\n", x , y , p );
+_printf("\n[DEBUG EXEC] _load_writable_segments() at cycle %d\n"
+        "P[%d,%d,%d] loaded Program-Header-Table\n",
+        _get_proctime() , x , y , p );
 #endif
 
@@ -384 +423 @@
 #if GIET_DEBUG_EXEC
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _load_writable_segments() : P[%d,%d,%d] "
-        "loaded segment %x\n", x , y , p , vbase );
+_printf("\n[DEBUG EXEC] _load_writable_segments() at cycle %d\n"
+        "P[%d,%d,%d] loaded segment %x\n",
+        _get_proctime() , x , y , p , vbase );
 #endif
         }
@@ -416 +456 @@
 unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _sys_exec_application() : P[%d,%d,%d] "
-        "enters for %s at cycle %d\n", x, y, p, name, _get_proctime() );
+_printf("\n[DEBUG EXEC] _sys_exec_application() at cycle %d\n"
+        "P[%d,%d,%d] enters for vspace %s\n",
+        _get_proctime() , x, y, p, name );
 #endif
 
@@ -430 +471 @@
 #if GIET_DEBUG_EXEC 
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _sys_exec_application() : P[%d,%d,%d] "
-        "found vspace %s at cycle  %d\n", x, y, p, name, _get_proctime() );
+_printf("\n[DEBUG EXEC] _sys_exec_application() at cycle %d\n"
+        "P[%d,%d,%d] found vspace %s\n",
+        _get_proctime() , x, y, p, name );
 #endif
             // reload writable segments
@@ -438 +480 @@
                 _printf("[GIET ERROR] _sys_exec_application() : "
                         "can't load data segment for vspace %s\n", name );
-                return GIET_SYSCALL_CANNOT_LOAD_DATA_SEGMENT;
+                return SYSCALL_CANNOT_LOAD_DATA_SEGMENT;
             }
  
 #if GIET_DEBUG_EXEC 
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _sys_exec_application() : P[%d,%d,%d] "
-        "load segments for vspace %s at cycle  %d\n", x, y, p, name, _get_proctime() );
+_printf("\n[DEBUG EXEC] _sys_exec_application() at cycle %d\n"
+        "P[%d,%d,%d] loaded all writable segments for vspace %s\n",
+        _get_proctime() , x, y, p, name );
 #endif
             // scan threads in vspace with three goals :
@@ -474 +517 @@
                             "thread %s already active in vspace %s\n",
                             thread[thread_id].name, name );
-                    return GIET_SYSCALL_THREAD_ALREADY_ACTIVE;
+                    return SYSCALL_THREAD_ALREADY_ACTIVE;
                 }
                 
@@ -499 +542 @@
 #if GIET_DEBUG_EXEC 
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _sys_exec_application() : P[%d,%d,%d] "
-        "initialise thread %s at cycle  %d\n",
-        x, y, p, thread[thread_id].name, _get_proctime() );
-#endif
-            }  // end loop on vspace threads
+_printf("\n[DEBUG EXEC] _sys_exec_application() at cycle %d\n"
+        "P[%d,%d,%d] initialise thread %s in vspace %s\n",
+        _get_proctime() , x, y, p, thread[thread_id].name , name );
+#endif
+            }  // end loop on threads
 
             // activate main thread
@@ -514 +557 @@
                 _printf("\n[GIET ERROR] in _sys_exec_application() : "
                         "main not found in vspace %s\n", name );
-                return GIET_SYSCALL_MAIN_NOT_FOUND;
+                return SYSCALL_MAIN_NOT_FOUND;
             }
              
-#if GIET_DEBUG_EXEC 
-if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _sys_exec_application() : P[%d,%d,%d] "
-        "lauched %s at cycle %d\n", x, y, p, name, _get_proctime() );
-#endif
-            return GIET_SYSCALL_OK;
+            _printf("\n[GIET WARNING] application %s launched : %d threads\n",
+                    name , max-min );
+
+            return SYSCALL_OK;
         }
     }  // end of loop on vspaces
@@ -529 +570 @@
     _printf("\n[GIET ERROR] in _sys_exec_application() : "
             "vspace %s not found\n", name );
-    return GIET_SYSCALL_VSPACE_NOT_FOUND;
+    return SYSCALL_VSPACE_NOT_FOUND;
 
 }  // end _sys_exec_application()
@@ -551 +592 @@
 unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _sys_kill_application() P[%d,%d,%d] "
-        "enters at cycle %d for %s\n", x, y, p, _get_proctime() , name );
+_printf("\n[DEBUG EXEC] _sys_kill_application() at cycle %d\n"
+        "P[%d,%d,%d] enters for vspace %s\n",
+        _get_proctime() , x , y , p , name );
 #endif
 
@@ -560 +602 @@
         _printf("\n[GIET ERROR] in _sys_kill_application() : "
                 "%s application cannot be killed\n", name );
-        return GIET_SYSCALL_APPLI_CANNOT_BE_KILLED;
+        return SYSCALL_APPLI_CANNOT_BE_KILLED;
     }
 
@@ -587 +629 @@
             } 
 
-#if GIET_DEBUG_EXEC 
-if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _sys_kill_application() P[%d,%d,%d] "
-        "kill %s at cycle %d\n", x, y, p, name, _get_proctime() );
-#endif
-
-            return GIET_SYSCALL_OK;
+            _printf("\n[GIET WARNING] application %s killed / %d threads\n",
+                    name , max-min );
+
+            return SYSCALL_OK;
         }
     }  // en loop on vspaces
@@ -599 +638 @@
     _printf("\n[GIET ERROR] in _sys_kill_application() : "
             "application %s not found\n", name );
-    return GIET_SYSCALL_VSPACE_NOT_FOUND;
+    return SYSCALL_VSPACE_NOT_FOUND;
 
 }  // end _sys_kill_application()
@@ -605 +644 @@
 
 
-//////////////////////////////
-int _sys_applications_status()
+//////////////////////////////////////////
+int _sys_applications_status( char* name )
 {
     mapping_header_t *  header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
@@ -613 +652 @@
     mapping_cluster_t * cluster = _get_cluster_base(header);
 
-    unsigned int thread_id;
-    unsigned int vspace_id;
-
-    // scan all vspaces
+    unsigned int thread_id;   // thread index in mapping
+    unsigned int vspace_id;   // vspace index in mapping
+
+    // scan vspaces
     for( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
     {
-        _user_printf("\n*** vspace %s\n", vspace[vspace_id].name );
-
-        // scan all threads in vspace
-        unsigned int min = vspace[vspace_id].thread_offset ;
-        unsigned int max = min + vspace[vspace_id].threads ;
-        for ( thread_id = min ; thread_id < max ; thread_id++ )
+        if ( (name == NULL) || (_strcmp(vspace[vspace_id].name , name ) == 0) )
         {
-            unsigned int         clusterid = thread[thread_id].clusterid;
-            unsigned int         p         = thread[thread_id].proclocid;
-            unsigned int         x         = cluster[clusterid].x;
-            unsigned int         y         = cluster[clusterid].y;
-            unsigned int         ltid      = thread[thread_id].ltid;
-            static_scheduler_t*  psched    = (static_scheduler_t*)_schedulers[x][y][p];
-            unsigned int         norun     = psched->context[ltid].slot[CTX_NORUN_ID];
-            unsigned int         tty       = psched->context[ltid].slot[CTX_TTY_ID];
-            unsigned int         current   = psched->current;
-
-            if ( current == ltid )
-            _user_printf(" - thread %s / P[%d,%d,%d] / ltid = %d / "
-                         "TTY = %d / norun = %x : running\n", 
-                         thread[thread_id].name, x, y, p, ltid, tty, norun );
-            else if ( norun == 0 )
-            _user_printf(" - thread %s / P[%d,%d,%d] / ltid = %d / "
-                         "TTY = %d / norun = %x : runable\n", 
-                         thread[thread_id].name, x, y, p, ltid, tty, norun);
-            else
-            _user_printf(" - thread %s / P[%d,%d,%d] / ltid = %d / "
-                         "TTY = %d / norun = %x : blocked\n", 
-                         thread[thread_id].name, x, y, p, ltid, tty, norun);
+            _user_printf("\n*** vspace %s\n", vspace[vspace_id].name );
+
+            // scan all threads in vspace
+            unsigned int min = vspace[vspace_id].thread_offset ;
+            unsigned int max = min + vspace[vspace_id].threads ;
+            for ( thread_id = min ; thread_id < max ; thread_id++ )
+            {
+                unsigned int         clusterid = thread[thread_id].clusterid;
+                unsigned int         p         = thread[thread_id].proclocid;
+                unsigned int         x         = cluster[clusterid].x;
+                unsigned int         y         = cluster[clusterid].y;
+                unsigned int         ltid      = thread[thread_id].ltid;
+                static_scheduler_t*  psched    = (static_scheduler_t*)_schedulers[x][y][p];
+                unsigned int         norun     = psched->context[ltid].slot[CTX_NORUN_ID];
+                unsigned int         tty       = psched->context[ltid].slot[CTX_TTY_ID];
+                unsigned int         current   = psched->current;
+
+                if ( current == ltid )
+                _user_printf(" - thread %s / P[%d,%d,%d] / ltid = %d / "
+                             "TTY = %d / norun = %x : running\n", 
+                             thread[thread_id].name, x, y, p, ltid, tty, norun );
+                else if ( norun == 0 )
+                _user_printf(" - thread %s / P[%d,%d,%d] / ltid = %d / "
+                             "TTY = %d / norun = %x : runable\n", 
+                             thread[thread_id].name, x, y, p, ltid, tty, norun);
+                else
+                _user_printf(" - thread %s / P[%d,%d,%d] / ltid = %d / "
+                             "TTY = %d / norun = %x : blocked\n", 
+                             thread[thread_id].name, x, y, p, ltid, tty, norun);
+            }
         }
     }
     _user_printf("\n");
-    return GIET_SYSCALL_OK;
+
+    return SYSCALL_OK;
 }  // end _sys_applications_status()
 
@@ -672 +715 @@
                 "attr argument not supported\n" );
         
-        return GIET_SYSCALL_PTHREAD_ARGUMENT_NOT_SUPPORTED;
+        return SYSCALL_PTHREAD_ARGUMENT_NOT_SUPPORTED;
     }
 
@@ -691 +734 @@
 
 #if GIET_DEBUG_EXEC 
+unsigned int gpid       = _get_procid();
+unsigned int cluster_xy = gpid >> P_WIDTH;
+unsigned int p          = gpid & ((1<<P_WIDTH)-1);
+unsigned int x          = cluster_xy >> Y_WIDTH;
+unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _sys_pthread_create() : enters at cycle %d"
-        " for vspace %s / entry = %x\n",
-        _get_proctime() , vspace[vspace_id].name , (unsigned int)function );
+_printf("\n[DEBUG EXEC] _sys_pthread_create() at cycle %d\n"
+        "P[%d,%d,%d] enters for vspace %s / entry = %x\n",
+        _get_proctime() , x , y , p , vspace[vspace_id].name , (unsigned int)function );
 #endif
 
@@ -747 +795 @@
 #if GIET_DEBUG_EXEC 
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] exit _sys_pthread_create() at cycle %d : thread %x launched\n",
-        _get_proctime() , trdid);
-#endif
-        return GIET_SYSCALL_OK;
+_printf("\n[DEBUG EXEC] _sys_pthread_create() at cycle %d\n"
+        "P[%d,%d,%d] exit : thread %x launched in vspace %s\n",
+        _get_proctime() , x , y , p , trdid , vspace[vspace_id].name );
+#endif
+        return SYSCALL_OK;
     }
     else         // no matching thread found
@@ -758 +807 @@
                 (unsigned int)function , vspace[vspace_id].name );
         
-        return GIET_SYSCALL_THREAD_NOT_FOUND;
+        return SYSCALL_THREAD_NOT_FOUND;
     }
 
@@ -774 +823 @@
                 "ptr argument not supported, must be NULL\n" );
         
-        return GIET_SYSCALL_PTHREAD_ARGUMENT_NOT_SUPPORTED;
-    }
-
+        return SYSCALL_PTHREAD_ARGUMENT_NOT_SUPPORTED;
+    }
+
+    // get calling thread vspace
+    unsigned int  caller_vspace = _get_context_slot( CTX_VSID_ID );
                 
 #if GIET_DEBUG_EXEC 
+unsigned int gpid       = _get_procid();
+unsigned int cluster_xy = gpid >> P_WIDTH;
+unsigned int p          = gpid & ((1<<P_WIDTH)-1);
+unsigned int x          = cluster_xy >> Y_WIDTH;
+unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] enters _sys_pthread_join() at cycle %d for thread %x\n",
-        _get_proctime() , trdid );
-#endif
-
+_printf("\n[DEBUG EXEC] _sys_pthread_join() at cycle %d\n"
+        "P[%d,%d,%d] enters for thread %x in vspace %d\n",
+        _get_proctime() , x , y , p , trdid , caller_vspace );
+#endif
+
+    // get target thread indexes from trdid
+    unsigned int cx   = (trdid>>24) & 0xFF;
+    unsigned int cy   = (trdid>>16) & 0xFF;
+    unsigned int lpid = (trdid>>8 ) & 0xFF;
+    unsigned int ltid = (trdid    ) & 0xFF;
+
+    // get target thread scheduler, vspace and registered trdid
+    static_scheduler_t*  psched   = _schedulers[cx][cy][lpid];
+    unsigned int target_vspace    = psched->context[ltid].slot[CTX_VSID_ID];
+    unsigned int registered_trdid = psched->context[ltid].slot[CTX_TRDID_ID];
+
+    // check trdid
+    if ( trdid != registered_trdid )
+    {
+       _printf("\nerror in _sys_pthread_join() : "
+               "trdid = %x / registered_trdid = %x\n",
+               trdid , registered_trdid );
+
+       return SYSCALL_UNCOHERENT_THREAD_CONTEXT;
+    }
+   
+    // check calling thread and target thread in same vspace
+    if ( caller_vspace != target_vspace )
+    {
+       _printf("\n[GIET ERROR] in _sys_pthread_join() : "
+               " calling thread and target thread not in same vspace\n");
+
+       return SYSCALL_NOT_IN_SAME_VSPACE;
+    }
+
+    // get target thread state
+    unsigned int* pnorun = &psched->context[ltid].slot[CTX_NORUN_ID];
+
+    asm volatile ( "2000:                      \n"                         
+                   "move  $11,  %0             \n"   /* $11 <= pnorun        */
+                   "lw    $11,  0($11)         \n"   /* $11 <= norun         */
+                   "andi  $11,  $11,    1      \n"   /* $11 <= norun & 0x1   */
+                   "beqz  $11,  2000b          \n"   
+                   :
+                   : "r" (pnorun)
+                   : "$11" );
+
+#if GIET_DEBUG_EXEC 
+if ( _get_proctime() > GIET_DEBUG_EXEC )
+_printf("\n[DEBUG EXEC] _sys_pthread_join() at cycle %d\n"
+        "P[%d,%d,%d] exit for thread %x in vspace %d\n",
+        _get_proctime() , x , y , p , trdid , caller_vspace );
+#endif
+
+    return SYSCALL_OK;
+
+}  // end _sys_pthread_join()
+                       
+
+////////////////////////////////////////
+int _sys_pthread_kill( pthread_t  trdid,
+                       int        signal )
+{
     // get calling thread vspace
     unsigned int  caller_vspace = _get_context_slot( CTX_VSID_ID );
+
+#if GIET_DEBUG_EXEC 
+unsigned int gpid       = _get_procid();
+unsigned int cluster_xy = gpid >> P_WIDTH;
+unsigned int p          = gpid & ((1<<P_WIDTH)-1);
+unsigned int x          = cluster_xy >> Y_WIDTH;
+unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
+if ( _get_proctime() > GIET_DEBUG_EXEC )
+_printf("\n[DEBUG EXEC] _sys_pthread_kill() at cycle %d\n"
+        "P[%d,%d,%d] enters for thread %x in vspace %d\n",
+        _get_proctime() , x , y , p , trdid , caller_vspace );
+#endif
+
 
     // get and check target thread indexes from trdid
@@ -794 +922 @@
 
     // get target thread scheduler, vspace and registered trdid
-    static_scheduler_t*  psched   = _schedulers[cx][cy][lpid];
-    unsigned int target_vspace    = psched->context[ltid].slot[CTX_VSID_ID];
+    static_scheduler_t*  psched       = _schedulers[cx][cy][lpid];
+    unsigned int target_vspace        = psched->context[ltid].slot[CTX_VSID_ID];
     unsigned int registered_trdid = psched->context[ltid].slot[CTX_TRDID_ID];
 
@@ -801 +929 @@
     if ( trdid != registered_trdid )
     {
-       _printf("\nerror in _sys_pthread_join() : "
-               "trdid = %x / registered_trdid = %x\n",
-               trdid , registered_trdid );
-
-       return GIET_SYSCALL_UNCOHERENT_THREAD_CONTEXT;
+       _printf("\n[GIET ERROR] in _sys_pthread_kill() : trdid = %x"
+               " / registered_trdid = %x\n", trdid , registered_trdid );
+       return SYSCALL_UNCOHERENT_THREAD_CONTEXT;
     }
    
@@ -811 +937 @@
     if ( caller_vspace != target_vspace )
     {
-       _printf("\n[GIET ERROR] in _sys_pthread_join() : "
-               " calling thread and target thread not in same vspace\n");
-
-       return GIET_SYSCALL_NOT_IN_SAME_VSPACE;
-    }
-
-    // get target thread state
-    unsigned int* pnorun = &psched->context[ltid].slot[CTX_NORUN_ID];
-
-    asm volatile ( "2000:                      \n"                         
-                   "move  $11,  %0             \n"   /* $11 <= ptr           */
-                   "lw    $11,  0($11)         \n"   /* $11 <= M[ptr]        */
-                   "andi  $11,  $11,    1      \n"   /* $11 <= norun & 0x1   */
-                   "beqz  $11,  2000b          \n"   
-                   :
-                   : "r" (pnorun)
-                   : "$11" );
-
-    return GIET_SYSCALL_OK;
-
-}  // end _sys_pthread_join()
-                       
-
-////////////////////////////////////////
-int _sys_pthread_kill( pthread_t  trdid,
-                       int        signal )
-{
-    // get calling thread vspace
-    unsigned int  caller_vspace = _get_context_slot( CTX_VSID_ID );
-
-    // get and check target thread indexes from trdid
-    unsigned int cx   = (trdid>>24) & 0xFF;
-    unsigned int cy   = (trdid>>16) & 0xFF;
-    unsigned int lpid = (trdid>>8 ) & 0xFF;
-    unsigned int ltid = (trdid    ) & 0xFF;
-
-    // get target thread scheduler, vspace and registered trdid
-    static_scheduler_t*  psched       = _schedulers[cx][cy][lpid];
-    unsigned int target_vspace        = psched->context[ltid].slot[CTX_VSID_ID];
-    unsigned int registered_trdid = psched->context[ltid].slot[CTX_TRDID_ID];
-
-    // check trdid
-    if ( trdid != registered_trdid )
-    {
-       _printf("\n[GIET ERROR] in _sys_pthread_kill() : trdid = %x"
-               " / registered_trdid = %x\n", trdid , registered_trdid );
-       return GIET_SYSCALL_UNCOHERENT_THREAD_CONTEXT;
-    }
-   
-    // check calling thread and target thread in same vspace
-    if ( caller_vspace != target_vspace )
-    {
        _printf("\n[GIET ERROR] in _sys_pthread_kill() : not in same vspace\n");
-       return GIET_SYSCALL_NOT_IN_SAME_VSPACE;
+       return SYSCALL_NOT_IN_SAME_VSPACE;
     }
 
@@ -873 +947 @@
     }
 
-    return GIET_SYSCALL_OK;
+#if GIET_DEBUG_EXEC 
+if ( _get_proctime() > GIET_DEBUG_EXEC )
+_printf("\n[DEBUG EXEC] _sys_pthread_kill() at cycle %d\n"
+        "P[%d,%d,%d] exit for thread %x in vspace %d\n",
+        _get_proctime() , x , y , p , trdid , caller_vspace );
+#endif
+
+    return SYSCALL_OK;
 
 }  // end _sys_pthread_kill()
@@ -881 +962 @@
 int _sys_pthread_exit( void* string ) 
 {
-    unsigned int date       = _get_proctime();
-
     mapping_header_t * header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
     mapping_vspace_t * vspace  = _get_vspace_base(header);
@@ -893 +972 @@
     if ( string == NULL )
     {
-        _printf("\n[GIET WARNING] Exit thread %x in vspace %s at cycle %d\n",
-                trdid , vspace[vsid].name , date );
+        _printf("\n[GIET WARNING] Exit thread %x in vspace %s\n",
+                trdid , vspace[vsid].name );
     }
     else
     {
-        _printf("\n[GIET WARNING] Exit thread %x in vspace %s at cycle %d\n"
+        _printf("\n[GIET WARNING] Exit thread %x in vspace %s\n"
                 "               Cause : %s\n\n",
-                trdid , vspace[vsid].name , date , (char*) string );
+                trdid , vspace[vsid].name , (char*) string );
     }
     
@@ -915 +994 @@
     _ctx_switch();
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 
 }  // end _sys_pthread_exit()
@@ -928 +1007 @@
     _it_restore( &save_sr );
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }
 
@@ -938 +1017 @@
 
 #if GIET_DEBUG_EXEC 
+unsigned int gpid       = _get_procid();
+unsigned int cluster_xy = gpid >> P_WIDTH;
+unsigned int p          = gpid & ((1<<P_WIDTH)-1);
+unsigned int x          = cluster_xy >> Y_WIDTH;
+unsigned int y          = cluster_xy & ((1<<Y_WIDTH)-1);
 if ( _get_proctime() > GIET_DEBUG_EXEC )
-_printf("\n[DEBUG EXEC] _sys_pthread_control() at cycle %d : "
-        "enter for vspace %s / thread %s / command = %d\n",
-        _get_proctime() , vspace_name, thread_name, command );
+_printf("\n[DEBUG EXEC] _sys_pthread_control() at cycle %d\n"
+        "P[%d,%d,%d] enter for vspace %s / thread %s / command = %d\n",
+        _get_proctime() , x , y , p , vspace_name, thread_name, command );
 #endif
 
@@ -964 +1048 @@
     }
 
-    if ( found == 0 ) return GIET_SYSCALL_VSPACE_NOT_FOUND;
+    if ( found == 0 ) return SYSCALL_VSPACE_NOT_FOUND;
 
     // search thread name in vspace to get thread index: tid
@@ -980 +1064 @@
     }
 
-    if ( found == 0 ) return GIET_SYSCALL_THREAD_NOT_FOUND;
-
-    // get thread coordinates
+    if ( found == 0 ) return SYSCALL_THREAD_NOT_FOUND;
+
+    // get target thread coordinates
     unsigned int cid  = thread[tid].clusterid;
-    unsigned int x    = cluster[cid].x;
-    unsigned int y    = cluster[cid].y;
-    unsigned int p    = thread[tid].proclocid;
+    unsigned int cx   = cluster[cid].x;
+    unsigned int cy   = cluster[cid].y;
+    unsigned int cp   = thread[tid].proclocid;
     unsigned int ltid = thread[tid].ltid;
 
-    static_scheduler_t* psched = _schedulers[x][y][p];
+    // get target thread scheduler
+    static_scheduler_t* psched = _schedulers[cx][cy][cp];
 
     // check trdid and vsid
-    unsigned int trdid = x<<24 | y<<16 | p<<8 | ltid;
+    unsigned int trdid = cx<<24 | cy<<16 | cp<<8 | ltid;
     if ( (psched->context[ltid].slot[CTX_TRDID_ID] != trdid) ||
          (psched->context[ltid].slot[CTX_VSID_ID]  != vsid) )
-        return GIET_SYSCALL_UNCOHERENT_THREAD_CONTEXT;
+    {
+        return SYSCALL_UNCOHERENT_THREAD_CONTEXT;
+    }
 
     // execute command
@@ -1001 +1088 @@
     {
         _atomic_or ( &psched->context[ltid].slot[CTX_NORUN_ID],  NORUN_MASK_THREAD );
-        return GIET_SYSCALL_OK;
+        return SYSCALL_OK;
     }
     else if ( command == THREAD_CMD_RESUME )
     {
         _atomic_and( &psched->context[ltid].slot[CTX_NORUN_ID], ~NORUN_MASK_THREAD );
-        return GIET_SYSCALL_OK;
+        return SYSCALL_OK;
     }
     else if ( command == THREAD_CMD_CONTEXT )
@@ -1046 +1133 @@
                       psched->context[ltid].slot[CTX_CMA_TX_ID],
                       psched->context[ltid].slot[CTX_CMA_FB_ID] );
-        return GIET_SYSCALL_OK;
+        return SYSCALL_OK;
     }
     else
     {
-        return GIET_SYSCALL_ILLEGAL_THREAD_COMMAND_TYPE;
+        return SYSCALL_ILLEGAL_THREAD_COMMAND_TYPE;
     }
 
@@ -1115 +1202 @@
 
 #if GIET_DEBUG_COPROC
-_printf("\n[GIET DEBUG COPROC] _sys_coproc_alloc() in cluster[%d,%d]\n"
-        "  coproc_info = %x / cluster_xy = %x\n",
-        x , y , *coproc_info , cluster_xy );
-#endif
-        return GIET_SYSCALL_OK;
+_printf("\n[DEBUG COPROC] _sys_coproc_alloc() at cycle %d\n"
+        "coproc_info = %x / cluster_xy = %x\n",
+        _get_proctime() , *coproc_info , cluster_xy );
+#endif
+        return SYSCALL_OK;
     }
     else
     {
-         _printf("\n[GIET_ERROR] in _sys_coproc_alloc(): no coprocessor "
-                 " with type %d available in cluster[%d,%d]\n",
+         _printf("\n[GIET_ERROR] in _sys_coproc_alloc(): "
+                 "no coprocessor with type %d in cluster[%d,%d]\n",
                  coproc_type , x , y );
-        return GIET_SYSCALL_COPROCESSOR_NOT_FOUND;
+
+        return SYSCALL_COPROCESSOR_NOT_FOUND;
     }
 }  // end _sys_coproc_alloc()
@@ -1133 +1221 @@
 int _sys_coproc_release( unsigned int coproc_reg_index )
 {
-    // processor coordinates
-    unsigned int procid = _get_procid();
-    unsigned int x      = procid >> (Y_WIDTH + P_WIDTH);
-    unsigned int y      = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
-    unsigned int p      = procid & ((1<<P_WIDTH)-1);
-    
+    // get thread trdid
+    unsigned int trdid = _get_thread_trdid();
+
     // get coprocessor coordinates
     unsigned int cluster_xy = _get_context_slot( CTX_COPROC_ID );
+
     if ( cluster_xy > 0xFF )
     {
          _printf("\n[GIET_ERROR] in _sys_coproc_release(): "
-                 "no coprocessor allocated to thread running on P[%d,%d,%d]\n",
-                 x , y , p ); 
-         return GIET_SYSCALL_COPROCESSOR_NOT_FOUND;
+                 "no coprocessor allocated to thread %x\n", trdid );
+
+         return SYSCALL_COPROCESSOR_NON_ALLOCATED;
     }
 
@@ -1171 +1257 @@
 
 #if GIET_DEBUG_COPROC
-_printf("\n[GIET DEBUG COPROC] _sys_coproc_release() in cluster[%d,%d]\n",
-        cx, cy );
-#endif
-
-    return GIET_SYSCALL_OK;
+_printf("\n[DEBUG COPROC] _sys_coproc_release() at cycle %d\n"
+        "thread %x release coprocessor in cluster[%d,%d]\n", cx, cy );
+#endif
+
+    return SYSCALL_OK;
 }  // end _sys_coproc_release()
 
@@ -1182 +1268 @@
                               giet_coproc_channel_t*  desc )
 {
-    // processor coordinates
-    unsigned int procid = _get_procid();
-    unsigned int x      = procid >> (Y_WIDTH + P_WIDTH);
-    unsigned int y      = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
-    unsigned int p      = procid & ((1<<P_WIDTH)-1);
-    
+    // get thread trdid
+    unsigned int trdid = _get_thread_trdid();
+
     // get coprocessor coordinates
     unsigned int cluster_xy = _get_context_slot( CTX_COPROC_ID );
+
     if ( cluster_xy > 0xFF )
     {
          _printf("\n[GIET_ERROR] in _sys_coproc_channel_init(): "
-                 "no coprocessor allocated to thread running on P[%d,%d,%d]\n",
-                 x , y , p ); 
-         return GIET_SYSCALL_COPROCESSOR_NOT_FOUND;
+                 "no coprocessor allocated to thread %x\n", trdid );
+
+         return SYSCALL_COPROCESSOR_NON_ALLOCATED;
     }
 
@@ -1205 +1289 @@
     {
          _printf("\n[GIET_ERROR] in _sys_coproc_channel_init(): "
-                 " illegal mode\n");
-         return GIET_SYSCALL_COPROCESSOR_ILLEGAL_MODE;
+                 "illegal mode\n");
+
+         return SYSCALL_COPROCESSOR_ILLEGAL_MODE;
     }
 
@@ -1258 +1343 @@
 
 #if GIET_DEBUG_COPROC
-_printf("\n[GIET DEBUG COPROC] _sys_coproc_channel_init() for coproc[%d,%d]\n"
-        " channel =  %d / mode = %d / buffer_size = %d\n"
+_printf("\n[DEBUG COPROC] _sys_coproc_channel_init() at cycle %d\n"
+        "cluster[%d,%d] / channel = %d / mode = %d / buffer_size = %d\n"
         " buffer_paddr = %l / mwmr_paddr = %l / lock_paddr = %l\n",
-        x , y , channel , mode , size ,
+        _get_proctime() , x , y , channel , mode , size ,
         buffer_paddr, mwmr_paddr, lock_paddr );
 #endif
         
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 } // end _sys_coproc_channel_init()
 
@@ -1271 +1356 @@
 int _sys_coproc_run( unsigned int coproc_reg_index )
 {
-    // processor coordinates
-    unsigned int procid = _get_procid();
-    unsigned int x      = procid >> (Y_WIDTH + P_WIDTH);
-    unsigned int y      = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
-    unsigned int p      = procid & ((1<<P_WIDTH)-1);
-    
+    // get thread trdid
+    unsigned int trdid = _get_thread_trdid();
+
     // get coprocessor coordinates
     unsigned int cluster_xy = _get_context_slot( CTX_COPROC_ID );
+
     if ( cluster_xy > 0xFF )
     {
          _printf("\n[GIET_ERROR] in _sys_coproc_run(): "
-                 "no coprocessor allocated to thread running on P[%d,%d,%d]\n",
-                 x , y , p ); 
-         return -1111;
+                 "no coprocessor allocated to thread %d\n", trdid );
+
+         return SYSCALL_COPROCESSOR_NON_ALLOCATED;
     }
 
@@ -1308 +1391 @@
         else if ( temp != mode )
         {
-            _printf("\n[GIET_ERROR] P[%d,%d,%d] in _sys_coproc_run() for coprocessor[%d,%d]\n"
-                    "  all channels don't have the same mode\n", x , y , p , cx , cy );
-            return -1111;
+            _printf("\n[GIET_ERROR] in _sys_coproc_run(): "
+                    "channels don't have same mode in coprocessor[%d,%d]\n", cx , cy );
+
+            return SYSCALL_COPROCESSOR_ILLEGAL_MODE;
         }
     }
@@ -1329 +1413 @@
 #if GIET_DEBUG_COPROC
 if ( mode == MODE_MWMR )
-_printf("\n[GIET DEBUG COPROC] _sys_coproc_run() P[%d,%d,%d] starts coprocessor[%d,%d]\n"
-        "   MODE_MWMR at cycle %d\n", x , y , p , cx , cy , _get_proctime() );
+_printf("\n[DEBUG COPROC] _sys_coproc_run() at cycle %d\n"
+        "thread %x starts coprocessor[%d,%d] in  MODE_MWMR\n", 
+        _get_proctime() , trdid , cx , cy );
 else
-_printf("\n[GIET DEBUG COPROC] _sys_coproc_run() P[%d,%d,%d] starts coprocessor[%d,%d]\n"
-        "   MODE_DMA_NO_IRQ at cycle %d\n", x , y , p , cx , cy , _get_proctime() );
-#endif
-
-        return GIET_SYSCALL_OK;
+_printf("\n[DEBUG COPROC] _sys_coproc_run() at cycle %d\n"
+        "thread %x starts coprocessor[%d,%d] in  MODE_DMA_NO_IRQ\n", 
+        _get_proctime() , trdid , cx , cy );
+#endif
+
+        return SYSCALL_OK;
     }
     ///////////////////////////////////////////////////////////////////////////
     else                                // mode == MODE_DMA_IRQ => descheduling
     {
-        // set _coproc_trdid 
-        unsigned int ltid = _get_thread_ltid();
+        // set _coproc_trdid
+        unsigned int gpid         = _get_procid();
+        unsigned int x            = gpid >> (Y_WIDTH+P_WIDTH);
+        unsigned int y            = (gpid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
+        unsigned int p            = gpid & ((1<<P_WIDTH)-1);
+        unsigned int ltid         = _get_thread_ltid();
         _coproc_trdid[cluster_id] = (x<<24) + (y<<16) + (p<<8) + ltid;
 
@@ -1358 +1448 @@
 
 #if GIET_DEBUG_COPROC
-_printf("\n[GIET DEBUG COPROC] _sys_coproc_run() P[%d,%d,%d] starts coprocessor[%d,%d]\n"
-        "   MODE_DMA_IRQ at cycle %d\n", x , y , p , cx , cy , _get_proctime() );
+_printf("\n[DEBUG COPROC] _sys_coproc_run() at cycle %d\n"
+        "thread %x starts coprocessor[%d,%d] in  MODE_DMA_IRQ\n", 
+        _get_proctime() , trdid , cx , cy );
 #endif
 
@@ -1366 +1457 @@
 
 #if GIET_DEBUG_COPROC
-_printf("\n[GIET DEBUG COPROC] _sys_coproc_run() P[%d,%d,%d] resume\n"
-        "  coprocessor[%d,%d] completion at cycle %d\n", 
-        x , y , p , cx , cy , _get_proctime() );
+_printf("\n[DEBUG COPROC] _sys_coproc_run() at cycle %d\n"
+        "thread %x resume after coprocessor[%d,%d] completion\n", 
+        _get_proctime() , trdid , cx , cy );
 #endif
 
@@ -1382 +1473 @@
 int _sys_coproc_completed()
 {
-    // processor coordinates
-    unsigned int procid = _get_procid();
-    unsigned int x      = procid >> (Y_WIDTH + P_WIDTH);
-    unsigned int y      = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1);
-    unsigned int p      = procid & ((1<<P_WIDTH)-1);
-    
+    // get thread trdid
+    unsigned int trdid = _get_thread_trdid();
+
     // get coprocessor coordinates
     unsigned int cluster_xy = _get_context_slot( CTX_COPROC_ID );
+
     if ( cluster_xy > 0xFF )
     {
          _printf("\n[GIET_ERROR] in _sys_coproc_completed(): "
-                 "no coprocessor allocated to thread running on P[%d,%d,%d]\n",
-                 x , y , p ); 
-         return -1111;
+                 "no coprocessor allocated to thread %x\n", trdid );
+
+         return SYSCALL_COPROCESSOR_NON_ALLOCATED;
     }
 
@@ -1413 +1502 @@
         unsigned int status;
 
-        // get status for all channels, and signal all reported errors
+        // get status for all channels, and signal reported errors
         for ( channel = 0 ; channel < (nb_to +nb_from) ; channel++ )
         {
             do
             {
-                status = _mwr_get_channel_register( cluster_xy , channel , MWR_CHANNEL_STATUS );
+                status = _mwr_get_channel_register( cluster_xy, channel,
+                                                    MWR_CHANNEL_STATUS );
                 if ( status == MWR_CHANNEL_ERROR_DATA )
                 {
-                    _printf("\n[GIET_ERROR] in _sys_coproc_completed()"
-                            " / channel %d / DATA_ERROR\n", channel );
+                    _printf("\n[GIET_ERROR] in _sys_coproc_completed(): "
+                            "channel %d / DATA_ERROR\n", channel );
                     error = 1;
-                    break;
                 }
                 else if ( status == MWR_CHANNEL_ERROR_LOCK )
@@ -1431 +1520 @@
                             " / channel %d / LOCK_ERROR\n", channel );
                     error = 1;
-                    break;
                 }
                 else if ( status == MWR_CHANNEL_ERROR_DESC )
@@ -1438 +1526 @@
                             " / channel %d / DESC_ERROR\n", channel );
                     error = 1;
-                    break;
                 }
-            } while ( status == MWR_CHANNEL_BUSY );
+            } 
+            while ( status == MWR_CHANNEL_BUSY );
 
             // reset channel
-            _mwr_set_channel_register( cluster_xy , channel , MWR_CHANNEL_RUNNING , 0 ); 
+            _mwr_set_channel_register( cluster_xy, channel,
+                                       MWR_CHANNEL_RUNNING , 0 ); 
 
         }  // end for channels
 
+        if ( error )
+        {
+            return SYSCALL_COPROCESSOR_ILLEGAL_MODE;
+        }
+        else
+        {
+
 #if GIET_DEBUG_COPROC
-_printf("\n[GIET DEBUG COPROC] _sys_coproc_completed() for coprocessor[%d,%d] error = %d\n", 
-        cx , cy , error );
-#endif
-
-        return error;
+_printf("\n[DEBUG COPROC] _sys_coproc_completed() at cycle %d\n"
+        "coprocessor[%d,%d] successfully completes operation for thread %d\n", 
+        cx , cy , trdid );
+#endif
+            return SYSCALL_OK;
+        }
     }
     else  // mode == MODE_MWMR or MODE_DMA_IRQ
     {
-        _printf("\n[GIET ERROR] sys_coproc_completed() should not be called for "
-                "coprocessor[%d,%d] running in MODE_MWMR or MODE_DMA_IRQ\n", cx , cy );
-        return 1;
+        _printf("\n[GIET ERROR] in sys_coproc_completed(): "
+                "coprocessor[%d,%d] is not running in MODE_DMA_NO_IRQ\n", cx , cy );
+
+        return SYSCALL_COPROCESSOR_ILLEGAL_MODE;
     }
 } // end _sys_coproc_completed()
@@ -1481 +1579 @@
         _printf("\n[GIET_ERROR] in _sys_tty_alloc() : "
                 "TTY channel already allocated to thread %x\n", trdid );
-        return -1111;
+        return SYSCALL_CHANNEL_ALREADY_ALLOCATED;
     }
 
@@ -1504 +1602 @@
         _printf("\n[GIET_ERROR] in _sys_tty_alloc() : "
                 "no TTY channel available for thread %x\n", trdid );
-        return -1111;
+        return SYSCALL_NO_CHANNEL_AVAILABLE;
     }
 
@@ -1546 +1644 @@
     }
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }  // end _sys_tty_alloc()
 
 //////////////////////
-int _sys_tty_release()     // NOTE: not a syscall
+int _sys_tty_release()     // NOTE: not a syscall: used by _ctx_kill_thread()
 {
     unsigned int channel = _get_context_slot( CTX_TTY_ID );
@@ -1559 +1657 @@
         _printf("\n[GIET_ERROR] in _sys_tty_release() : "
                 "TTY channel already released for thread %x\n", trdid );
-        return -1111;
+
+        return SYSCALL_CHANNEL_ALREADY_ALLOCATED;
     }
 
@@ -1574 +1673 @@
     }
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }  // end sys_tty_release()
 
@@ -1586 +1685 @@
     // compute and check tty channel
     if( channel == 0xFFFFFFFF )  channel = _get_context_slot(CTX_TTY_ID);
-    if( channel >= NB_TTY_CHANNELS ) return -1111;
+
+    if( channel >= NB_TTY_CHANNELS )
+    {
+        _printf("\n[GIET_ERROR] in _sys_tty_write() : "
+                "no TTY channel allocated for thread %x\n", _get_thread_trdid() );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
+    }
 
     // write string to TTY channel
@@ -1612 +1718 @@
     // compute and check tty channel
     if( channel == 0xFFFFFFFF )  channel = _get_context_slot(CTX_TTY_ID);
-    if( channel >= NB_TTY_CHANNELS ) return -1111;
+
+    if( channel >= NB_TTY_CHANNELS )
+    {
+        _printf("\n[GIET_ERROR] in _sys_tty_read() : "
+                "no TTY channel allocated for thread %x\n", _get_thread_trdid() );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
+    }
 
     unsigned int save_sr;
@@ -1676 +1789 @@
         _printf("\n[GIET_ERROR] in _sys_tim_alloc() : "
                 "TIMER channel already allocated to thread %x\n", trdid );
-        return -1111;
+
+        return SYSCALL_CHANNEL_ALREADY_ALLOCATED;
     }
 
@@ -1690 +1804 @@
         _printf("\n[GIET_ERROR] in _sys_tim_alloc() : "
                 "no TIMER channel available for thread %x\n", trdid );
-        return -1111;
+
+        return SYSCALL_NO_CHANNEL_AVAILABLE;
     }
 
@@ -1707 +1822 @@
     _set_context_slot( CTX_TIM_ID, channel );
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 
 #else
 
-    _printf("\n[GIET ERROR] in _sys_tim_alloc() : NB_TIM_CHANNELS = 0\n");
-    return -1111;
+    _printf("\n[GIET ERROR] in _sys_tim_alloc(): NB_TIM_CHANNELS == 0\n");
+
+    return SYSCALL_NO_CHANNEL_AVAILABLE;
 
 #endif
@@ -1719 +1835 @@
 
 //////////////////////
-int _sys_tim_release()     // NOTE: not a syscall
+int _sys_tim_release()     // NOTE: not a syscall: used by _ctx_kill_thread()
 {
 
@@ -1729 +1845 @@
     {
         unsigned int trdid = _get_thread_trdid();
-        _printf("\n[GIET_ERROR] in _sys_tim_release() : "
+        _printf("\n[GIET_ERROR] in _sys_tim_release(): "
                 "TIMER channel already released for thread %x\n", trdid );
-        return -1111;
+
+        return SYSCALL_CHANNEL_ALREADY_ALLOCATED;
     }
 
@@ -1746 +1863 @@
     }
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 
 #else
 
-    _printf("\n[GIET ERROR] in _sys_tim_release() : NB_TIM_CHANNELS = 0\n");
-    return -1111;
+    _printf("\n[GIET ERROR] in _sys_tim_release(): NB_TIM_CHANNELS = 0\n");
+
+    return SYSCALL_NO_CHANNEL_AVAILABLE;
 
 #endif
@@ -1764 +1882 @@
     // get timer index
     unsigned int channel = _get_context_slot( CTX_TIM_ID );
+
     if ( channel >= NB_TIM_CHANNELS )
     {
-        _printf("\n[GIET_ERROR] in _sys_tim_start() : not enough TIM channels\n");
-        return -1111;
+        _printf("\n[GIET_ERROR] in _sys_tim_start(): not enough TIM channels\n");
+
+        return SYSCALL_NO_CHANNEL_AVAILABLE;
     }
 
@@ -1773 +1893 @@
     _timer_start( channel, period );
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 
 #else
 
     _printf("\n[GIET ERROR] in _sys_tim_start() : NB_TIM_CHANNELS = 0\n");
-    return -1111;
+
+    return SYSCALL_NO_CHANNEL_AVAILABLE;
 
 #endif
@@ -1791 +1912 @@
     // get timer index
     unsigned int channel = _get_context_slot( CTX_TIM_ID );
+
     if ( channel >= NB_TIM_CHANNELS )
     {
         _printf("\n[GIET_ERROR] in _sys_tim_stop() : illegal timer index\n");
-        return -1111;
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
 
@@ -1800 +1923 @@
     _timer_stop( channel );
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 
 #else
 
     _printf("\n[GIET ERROR] in _sys_tim_stop() : NB_TIM_CHANNELS = 0\n");
-    return -1111;
+
+    return SYSCALL_NO_CHANNEL_AVAILABLE;
 
 #endif
@@ -1838 +1962 @@
         _printf("\n[GIET_ERROR] in _sys_nic_alloc() "
                 "xmax or ymax argument too large for thread %x\n", trdid );
-        return -1111;
+
+        return SYSCALL_ILLEGAL_XY_ARGUMENTS;
     }
 
@@ -1861 +1986 @@
         _printf("\n[GIET_ERROR] in _sys_nic_alloc() : "
                 "no NIC channel available for thread %x\n", trdid );
-        return -1111;
+
+        return SYSCALL_NO_CHANNEL_AVAILABLE;
     }
 
@@ -1877 +2003 @@
         if ( is_rx )  _nic_rx_channel_alloc[nic_channel] = 0;
         else          _nic_tx_channel_alloc[nic_channel] = 0;
-        return -1111;
+
+        return SYSCALL_NO_CHANNEL_AVAILABLE;
     }
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Thread %d enters sys_nic_alloc() at cycle %d\n"
-        "  nic_channel = %d / cma_channel = %d\n",
-        trdid , _get_proctime() , nic_channel , cma_channel );
+_printf("\n[DEBUG NIC] sys_nic_alloc() at cycle %d\n"
+        "thread %d get nic_channel = %d / cma_channel = %d\n",
+        _get_proctime() , trdid , nic_channel , cma_channel );
 #endif
 
@@ -1910 +2037 @@
                 _nic_rx_channel_alloc[nic_channel] = 0;
                 _cma_channel_alloc[cma_channel]    = 0;
-                return -1111;
+
+                return SYSCALL_CHANNEL_ALREADY_ALLOCATED;
             }
             else
@@ -1927 +2055 @@
                 _nic_tx_channel_alloc[nic_channel] = 0;
                 _cma_channel_alloc[cma_channel]    = 0;
-                return -1111;
+
+                return SYSCALL_CHANNEL_ALREADY_ALLOCATED;
             }
             else
@@ -1971 +2100 @@
             {
                 _printf("\n[GIET_ERROR] in _sys_nic_alloc() : "
-                        "not enough kenel heap in cluster[%d,%d]\n", cx, cy );
-                return -1111;
+                        "not enough kernel heap in cluster[%d,%d]\n", cx, cy );
+
+                return SYSCALL_OUT_OF_KERNEL_HEAP_MEMORY;
             }
 
@@ -1982 +2112 @@
             {
                 _printf("\n[GIET ERROR] in _sys_nic_alloc() : "
-                        "container address of cluster[%d,%d] not aligned\n", cx, cy);
-                return -1111;
+                        "container address in cluster[%d,%d] not aligned\n", cx, cy);
+
+                return SYSCALL_ADDRESS_NON_ALIGNED;
             }
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_alloc()\n"
-        " allocates in cluster[%d,%d]:\n"
-        " - container vaddr = %x / paddr = %l\n",
-        thread , cx , cy , vaddr, cont_paddr );
+_printf("\n[DEBUG NIC] _sys_nic_alloc() at cycle %d\n"
+        "thread %x allocates a container in cluster[%d,%d] / vaddr = %x / paddr = %l\n",
+        -get_proctime() , trdid , cx , cy , vaddr, cont_paddr );
 #endif
 
@@ -2001 +2131 @@
                 _printf("\n[GIET_ERROR] in _sys_nic_alloc() : "
                         "not enough kernel heap in cluster[%d,%d]\n", cx, cy );
-                return -1111;
+
+                return SYSCALL_OUT_OF_KERNEL_HEAP_MEMORY;
             }
 
@@ -2011 +2142 @@
             {
                 _printf("\n[GIET ERROR] in _sys_nic_alloc() : "
-                        "status address of cluster[%d,%d] not aligned\n", cx, cy);
-                return -1111;
+                        "status address in cluster[%d,%d] not aligned\n", cx, cy);
+
+                return SYSCALL_ADDRESS_NON_ALIGNED;
             }
 
@@ -2034 +2166 @@
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_alloc()\n"
-        " - status vaddr = %x / paddr = %l\n"
-        " Buffer descriptor = %l\n",
-        thread, vaddr, sts_paddr,
+_printf("\n[DEBUG NIC] _sys_nic_alloc() at cycle %d\n"
+        "thread %x allocates a status in cluster[%d,%d] / vaddr = %x / paddr = %l\n"
+        "   descriptor = %l\n",
+        _get_proctime() , trdid , cx , cy , vaddr, sts_paddr,
         (unsigned long long)((sts_paddr & 0xFFFFFFFFULL) >> 6) + 
         (((cont_paddr & 0xFFFFFFFFFFFULL) >> 6) << 26) );
@@ -2063 +2195 @@
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_alloc() get kernel chbuf\n"
-        "  vaddr = %x / paddr = %l\n",
-        thread , vaddr , ker_chbuf_pbase );
+_printf("\n[DEBUG NIC] _sys_nic_alloc() at cycle %d\n"
+        "thread %x initialise kernel chbuf / vaddr = %x / paddr = %l\n",
+        _get_proctime() , trdid , vaddr , ker_chbuf_pbase );
 #endif
 
@@ -2082 +2214 @@
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_alloc() get NIC chbuf : paddr = %l\n",
-        thread , nic_chbuf_pbase );
+_printf("\n[DEBUG NIC] _sys_nic_alloc() at cycle %d\n"
+        "thread %x get NIC chbuf paddr = %l\n",
+        _get_proctime() , trdid , nic_chbuf_pbase );
 #endif
 
@@ -2110 +2243 @@
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d exit _sys_nic_alloc() at cycle %d\n",
-        thread, _get_proctime() );
-#endif
-
-    return GIET_SYSCALL_OK;
+_printf("\n[DEBUG NIC] _sys_nic_alloc() at cycle %d\n"
+        "thread %x exit\n", 
+        _get_proctime() , trdid );
+#endif
+
+    return SYSCALL_OK;
 } // end _sys_nic_alloc()
 
 
 //////////////////////////////////////////
-int _sys_nic_release( unsigned int is_rx )     // NOTE: not a syscall
+int _sys_nic_release( unsigned int is_rx )     // NOTE: not a syscall: used by _ctx_kill_thread()
 {
     unsigned int trdid = _get_thread_trdid();
@@ -2136 +2270 @@
             _printf("\n[GIET ERROR] in _sys_nic_release() : "
                     "NIC_RX channel already released for thread %x\n", trdid );
-            return -1111;
+
+            return SYSCALL_CHANNEL_NON_ALLOCATED;
         }
         if ( (cma_channel >= NB_CMA_CHANNELS) )
@@ -2142 +2277 @@
             _printf("\n[GIET ERROR] in _sys_nic_release() : "
                     "CMA_RX channel already released for thread %x\n", trdid );
-            return -1111;
+
+            return SYSCALL_CHANNEL_NON_ALLOCATED;
         }
 
@@ -2166 +2302 @@
             _printf("\n[GIET ERROR] in _sys_nic_release() : "
                     "NIC_TX channel already released for thread %x\n", trdid );
-            return -1111;
+
+            return SYSCALL_CHANNEL_NON_ALLOCATED;
         }
         if ( (cma_channel >= NB_CMA_CHANNELS) )
@@ -2172 +2309 @@
             _printf("\n[GIET ERROR] in _sys_nic_release() : "
                     "CMA_TX channel already released for thread %x\n", trdid );
-            return -1111;
+
+            return SYSCALL_CHANNEL_NON_ALLOCATED;
         }
 
@@ -2188 +2326 @@
     }
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }  // end sys_nic_release()
 
@@ -2213 +2351 @@
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Thread %x in _sys_nic_start() at cycle %d\n"
-        "  get NIC channel = %d / CMA channel = %d\n",
-        trdid, _get_proctime(), nic_channel, cma_channel );
+_printf("\n[DEBUG NIC] _sys_nic_start() at cycle %d\n"
+        "thread %x enter / NIC channel = %d / CMA channel = %d\n",
+        _get_proctime() , trdid , nic_channel, cma_channel );
 #endif
 
@@ -2241 +2379 @@
 
 #if GIET_DEBUG_NIC
-    _printf("\n[GIET DEBUG NIC] Task %d exit _sys_nic_start() at cycle %d\n",
-            trdid , _get_proctime() );
-#endif
-
-    return GIET_SYSCALL_OK;
+    _printf("\n[DEBUG NIC] _sys_nic_start() at cycle %d\n"
+            "thread %d exit\n",
+            _get_proctime() , trdid );
+#endif
+
+    return SYSCALL_OK;
 }  // end _sys_nic_start()
 
@@ -2258 +2397 @@
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d enters _sys_nic_move() at cycle %d\n",
-        trdid , _get_proctime() );
+_printf("\n[DEBUG NIC] _sys_nic_move() at cycle %d\n",
+        "thread %x enters\n",
+        _get_proctime() , trdid );
 #endif
 
@@ -2270 +2410 @@
     {
         _printf("\n[GIET_ERROR] in _sys_nic_move() : "
-                "illegal NIC channel index for thread %x\n", trdid );
-        return -1111;
+                "NIC channel non allocated for thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
 
@@ -2289 +2430 @@
     
     // check processor coordinates / (xmax,ymax)
-    if ( cx >= xmax )
-    {
-        _printf("\n[GIET_ERROR] in _sys_nic_move() : processor X coordinate = %d"
-                " / xmax = %d\n", cx , xmax );
-        return -1111;
-    }
-    if ( cy >= ymax )
-    {
-        _printf("\n[GIET_ERROR] in _sys_nic_move() : processor Y coordinate = %d"
-                " / ymax = %d\n", cy , ymax );
-        return -1111;
+    if ( (cx >= xmax) || (cy >= ymax) )
+    {
+        _printf("\n[GIET_ERROR] in _sys_nic_move(): "
+         "processor coordinates [%d,%d] larger than (xmax,ymax) = [%d,%d]\n",
+         cx , cy , xmax , ymax );
+
+        return SYSCALL_ILLEGAL_XY_ARGUMENTS;
     }
     
@@ -2315 +2452 @@
     if ( (flags & PTE_U) == 0 )
     {
-        _printf("\n[GIET ERROR] in _sys_nic_tx_move() : illegal user buffer address\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _sys_nic_tx_move() : "
+                "buffer address non user accessible\n");
+
+        return SYSCALL_ADDRESS_NON_USER_ACCESSIBLE;
     }
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_move() get user buffer : paddr = %l\n",
-        thread, usr_buf_paddr );
+_printf("\n[DEBUG NIC] _sys_nic_move() at cycle %d\n"
+        "thread %x get user buffer : paddr = %l\n",
+        _get_proctime() , trdid , usr_buf_paddr );
 #endif
 
@@ -2331 +2471 @@
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_move() read ker_buf_desc %d at cycle %d\n"
-        "  kernel buffer descriptor = %l\n",
-        thread, index, _get_proctime(), ker_buf_desc );
+_printf("\n[DEBUG NIC] _sys_nic_move() at cycle %d\n"
+        "thread %x get ker_buf_desc %d / paddr = %l\n",
+        _get_proctime(), trdid , index , ker_buf_desc );
 #endif
 
@@ -2344 +2484 @@
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_move() read ker_buf_sts %d at cycle %d\n"
-        "  paddr = %l / kernel buffer status = %x\n",
-        thread, index, _get_proctime(), ker_sts_paddr, ker_sts );
+_printf("\n[DEBUG NIC] _sys_nic_move() at cycle %d\n"
+        "thread %x get status %d /  paddr = %l / status = %x\n",
+        _get_proctime() , trdid , index , ker_sts_paddr, ker_sts );
 #endif
 
@@ -2368 +2508 @@
                           NIC_CONTAINER_SIZE );
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_move() transfer kernel buffer %l\n"
-        " to user buffer %l at cycle %d\n",
-        thread , ker_buf_paddr , usr_buf_paddr , _get_proctime() );
+_printf("\n[DEBUG NIC] _sys_nic_move() at cycle %d\n"
+        "thread %x transfer kernel buffer %l to user buffer %l\n",
+        _get_proctime() , trdid , ker_buf_paddr , usr_buf_paddr );
 #endif
 
@@ -2385 +2525 @@
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_move() transfer "
-        "user buffer %l to kernel buffer %l at cycle %d\n",
-        thread , usr_buf_paddr , ker_buf_paddr , _get_proctime() );
+_printf("\n[DEBUG NIC] _sys_nic_move() at cycle %d\n"
+        "thread %x transfer user buffer %l to kernel buffer %l\n",
+        _get_proctime() , trdid , usr_buf_paddr , ker_buf_paddr );
 #endif
 
@@ -2400 +2540 @@
 
 #if GIET_DEBUG_NIC
-_printf("\n[GIET DEBUG NIC] Task %d get buffer %d  and exit _sys_nic_move() at cycle %d\n",
-        thread , index , _get_proctime() );
-#endif
-
-    return GIET_SYSCALL_OK;
+_printf("\n[DEBUG NIC] _sys_nic_move() at cycle %d\n"
+        "thread %x exit\n",
+        _get_proctime() , trdid );
+#endif
+
+    return SYSCALL_OK;
 } // end _sys_nic_move()
 
@@ -2432 +2573 @@
     {
         _printf("\n[GIET_ERROR] in _sys_nic_stop() : " 
-                "illegal NIC channel for thread %x\n", trdid );
-        return -1111;
+                "NIC channel non allocated for thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
     if ( cma_channel >= NB_CMA_CHANNELS )
     {
         _printf("\n[GIET_ERROR] in _sys_nic_stop() : "
-                "illegal CMA channel for thread %x\n", trdid );
-        return -1111;
+                "CMA channel non allocated for thread %x\n", trdid );
+ 
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
 
@@ -2450 +2593 @@
     {
          status = _cma_get_register( cma_channel, CHBUF_STATUS );
-    } while ( status ); 
+    } 
+    while ( status ); 
 
     // desactivates the NIC channel
     _nic_channel_stop( nic_channel, is_rx );
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }  // end _sys_nic_stop()
 
@@ -2472 +2616 @@
     {
         _printf("\n[GIET_ERROR] in _sys_nic_clear() : "
-                "illegal NIC channel for thread %x\n", trdid );
-        return -1111;
+                "NIC channel non allocated for thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
 
@@ -2498 +2643 @@
         _nic_set_global_register( NIC_G_NPKT_TX_DISPATCH_BROADCAST , 0 );
     }
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }  // en _sys_nic_clear()
 
@@ -2515 +2660 @@
     {
         _printf("\n[GIET_ERROR] in _sys_nic_stats() : "
-                "illegal NIC channel for thread %x\n", trdid );
-        return -1111;
+                "NIC channel non allocated for thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
 
@@ -2571 +2717 @@
                 broadcast );
     }
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }  // end _sys_nic_stats()
 
@@ -2579 +2725 @@
 //    FBF related syscall handlers
 /////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////
+int _sys_fbf_size( unsigned int* width,
+                   unsigned int* height )
+{
+    if ( USE_FBF == 0 )
+    {
+        *width  = 0;
+        *height = 0;
+    }
+    else
+    {
+        *width  = FBUF_X_SIZE;
+        *height = FBUF_Y_SIZE;
+    }
+
+    return SYSCALL_OK;
+}
+
+////////////////////
+int _sys_fbf_alloc()
+{
+    mapping_header_t  *header   = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
+    mapping_vspace_t  *vspace   = _get_vspace_base(header);
+    mapping_thread_t  *thread   = _get_thread_base(header);
+    
+    // compute number of users
+    unsigned int   vsid  = _get_context_slot(CTX_VSID_ID);
+    unsigned int   users = vspace[vsid].threads;
+
+    // access FBF allocator 
+    // register it in all threads contexts
+    if ( _atomic_test_and_set( &_fbf_alloc , users ) == 0 )     // FBF available   
+    {
+        unsigned int   min   = vspace[vsid].thread_offset;
+        unsigned int   max   = min + users;
+        unsigned int   tid;
+        for ( tid = min ; tid < max ; tid++ )
+        {
+            unsigned int y_size        = header->y_size;
+            unsigned int cid           = thread[tid].clusterid;
+            unsigned int x             = cid / y_size;
+            unsigned int y             = cid % y_size;
+            unsigned int p             = thread[tid].proclocid;
+            unsigned int ltid          = thread[tid].ltid;
+            static_scheduler_t* psched = (static_scheduler_t*)_schedulers[x][y][p];
+            _atomic_or( &psched->context[ltid].slot[CTX_LOCKS_ID] , LOCKS_MASK_FBF ); 
+        }
+        return SYSCALL_OK;
+    }
+    else                                                       // FBF already allocated
+    {
+        return SYSCALL_SHARED_PERIPHERAL_BUSY;
+    }
+}
+
+//////////////////////
+int _sys_fbf_release()    // not a syscall: used by _ctx_kill_thread()
+{
+    // get calling thread scheduler, ltid and trdid
+    static_scheduler_t*  psched = _get_sched();
+    unsigned int         ltid   = _get_thread_ltid();
+    unsigned int         trdid  = _get_thread_trdid();
+
+    if ( (psched->context[ltid].slot[CTX_LOCKS_ID] & LOCKS_MASK_FBF) == 0 )
+    {
+        _printf("\n[GIET ERROR] in _sys_fbf_release() : "
+                "FBF not allocated to thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
+    }
+
+    // decrement FBF allocator 
+    // reset the calling thread context
+    _atomic_increment( &_fbf_alloc , 0xFFFFFFFF );
+    _atomic_and( &psched->context[ltid].slot[CTX_LOCKS_ID] , ~LOCKS_MASK_FBF ); 
+
+    return SYSCALL_OK;   
+}
 
 /////////////////////////////////////////////
@@ -2585 +2810 @@
                          unsigned int length )
 {
+    // get calling thread scheduler, ltid and trdid
+    static_scheduler_t*  psched = _get_sched();
+    unsigned int         ltid   = _get_thread_ltid();
+    unsigned int         trdid  = _get_thread_trdid();
+
+    if ( (psched->context[ltid].slot[CTX_LOCKS_ID] & LOCKS_MASK_FBF) == 0 )
+    {
+        _printf("\n[GIET ERROR] in _sys_fbf_release() : "
+                "FBF not allocated to thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
+    }
+
     char* fbf_address = (char *)SEG_FBF_BASE + offset;
     memcpy( fbf_address, buffer, length);
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }
 
@@ -2596 +2834 @@
                          unsigned int length )
 {
+    // get calling thread scheduler, ltid and trdid
+    static_scheduler_t*  psched = _get_sched();
+    unsigned int         ltid   = _get_thread_ltid();
+    unsigned int         trdid  = _get_thread_trdid();
+
+    if ( (psched->context[ltid].slot[CTX_LOCKS_ID] & LOCKS_MASK_FBF) == 0 )
+    {
+        _printf("\n[GIET ERROR] in _sys_fbf_release() : "
+                "FBF not allocated to thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
+    }
+
     char* fbf_address = (char *)SEG_FBF_BASE + offset;
     memcpy( buffer, fbf_address, length);
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }
 
@@ -2611 +2862 @@
         _printf("\n[GIET ERROR] in _sys_fbf_cma_alloc() : "
                 "CMA channel already allocated for thread %x\n", trdid );
-        return GIET_SYSCALL_OK;
+
+        return SYSCALL_CHANNEL_ALREADY_ALLOCATED;
     }
 
@@ -2624 +2876 @@
     {
         _printf("\n[GIET ERROR] in _sys_fbf_cma_alloc() : no CMA channel available\n");
-        return -1111;
+
+        return SYSCALL_NO_CHANNEL_AVAILABLE;
     }
     else
     {
         _set_context_slot( CTX_CMA_FB_ID, channel );
-        return GIET_SYSCALL_OK;
+
+        return SYSCALL_OK;
     }
 } // end sys_fbf_cma_alloc()
@@ -2642 +2896 @@
     {
         _printf("\n[GIET_ERROR] in _sys_fbf_cma_release() : "
-                "CMA_FB channel already releasedifor thread %x\n", trdid );
-        return -1111;
+                "CMA_FB channel already released for thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
 
@@ -2655 +2910 @@
     _cma_channel_alloc[channel] = 0;
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }
 
@@ -2664 +2919 @@
                            void*        sts1_vaddr )
 {
-#if NB_CMA_CHANNELS > 0
-
     unsigned int       vaddr;           // virtual address
     unsigned int       flags;           // for _v2p_translate()
@@ -2675 +2928 @@
     unsigned long long sts1_paddr;      // buffer 1 status physical address
 
+    // get calling thread scheduler, ltid and trdid
+    static_scheduler_t*  psched = _get_sched();
+    unsigned int         ltid   = _get_thread_ltid();
+    unsigned int         trdid  = _get_thread_trdid();
+
+    // check FBF allocated
+    if ( (psched->context[ltid].slot[CTX_LOCKS_ID] & LOCKS_MASK_FBF) == 0 )
+    {
+        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : "
+                "FBF not allocated to thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
+    }
+
     // get channel index
     unsigned int channel = _get_context_slot( CTX_CMA_FB_ID );
@@ -2680 +2947 @@
     if ( channel >= NB_CMA_CHANNELS )
     {
-        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : CMA channel index too large\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : "
+                "CMA channel non allocated to thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
 
 #if GIET_DEBUG_FBF_CMA
-_printf("\n[FBF_CMA DEBUG] enters _sys_fbf_cma_init_buf()\n"
+_printf("\n[FBF_CMA DEBUG] _sys_fbf_cma_init_buf()\n"
         " - channel           = %d\n"
         " - buf0        vbase = %x\n"
@@ -2702 +2971 @@
          ((unsigned int)buf1_vbase & 0x3F) ) 
     {
-        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : user buffer not aligned\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : "
+                "user buffer not aligned for thread %x\n", trdid );
+
+        return SYSCALL_ADDRESS_NON_ALIGNED;
     }
 
@@ -2710 +2981 @@
          ((unsigned int)sts1_vaddr & 0x3F) )
     {
-        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : user status not aligned\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : "
+                "user status not aligned for thread %x\n", trdid );
+
+        return SYSCALL_ADDRESS_NON_ALIGNED;
     }
 
@@ -2729 +3002 @@
     if ((flags & PTE_U) == 0) 
     {
-        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : buf0 not in user space\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : "
+                "buf0 not in user space for thread %x\n", trdid );
+
+        return SYSCALL_ADDRESS_NON_USER_ACCESSIBLE;
     }
 
@@ -2737 +3012 @@
     if ((flags & PTE_U) == 0) 
     {
-        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : sts0 not in user space\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : "
+                "sts0 not in user space for thread %x\n", trdid);
+
+        return SYSCALL_ADDRESS_NON_USER_ACCESSIBLE;
     }
 
@@ -2750 +3027 @@
     if ((flags & PTE_U) == 0) 
     {
-        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : buf1 not in user space\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : "
+                "buf1 not in user space for thread %x\n", trdid );
+
+        return SYSCALL_ADDRESS_NON_USER_ACCESSIBLE;
     }
 
@@ -2758 +3037 @@
     if ((flags & PTE_U) == 0) 
     {
-        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : sts1 not in user space\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : "
+                "sts1 not in user space for thread %x\n", trdid);
+
+        return SYSCALL_ADDRESS_NON_USER_ACCESSIBLE;
     }
 
@@ -2787 +3068 @@
 #endif
 
-    return GIET_SYSCALL_OK;
-
-#else
-
-    _printf("\n[GIET ERROR] in _sys_fbf_cma_init_buf() : NB_CMA_CHANNELS = 0\n");
-    return -1111;
-
-#endif  
+    return SYSCALL_OK;
+
 } // end sys_fbf_cma_init_buf()
 
@@ -2800 +3075 @@
 int _sys_fbf_cma_start( unsigned int length ) 
 {
-#if NB_CMA_CHANNELS > 0
+    // get calling thread scheduler, ltid and trdid
+    static_scheduler_t*  psched = _get_sched();
+    unsigned int         ltid   = _get_thread_ltid();
+    unsigned int         trdid  = _get_thread_trdid();
+
+    // check FBF allocated
+    if ( (psched->context[ltid].slot[CTX_LOCKS_ID] & LOCKS_MASK_FBF) == 0 )
+    {
+        _printf("\n[GIET ERROR] in _sys_fbf_release() : "
+                "FBF not allocated to thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
+    }
 
     // get channel index
@@ -2807 +3094 @@
     if ( channel >= NB_CMA_CHANNELS )
     {
-        _printf("\n[GIET ERROR] in _fbf_cma_start() : CMA channel index too large\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _fbf_cma_start() : "
+                "CMA channel non allocated\n");
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
 
@@ -2816 +3105 @@
          ( _fbf_chbuf[channel].fbf_desc == 0x0ULL) )
     {
-        _printf("\n[GIET ERROR] in _sys_fbf_cma_start() :\n"
-                "Buffer initialization has not been done\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _sys_fbf_cma_start(): initialization not done\n");
+
+        return SYSCALL_MISSING_INITIALISATION;
     }
 
@@ -2847 +3136 @@
     _cma_set_register( channel, CHBUF_RUN      , 1 );
 
-    return GIET_SYSCALL_OK;
-
-#else
-
-    _printf("\n[GIET ERROR] in _sys_fbf_cma_start() : NB_CMA_CHANNELS = 0\n");
-    return -1111;
-
-#endif
+    return SYSCALL_OK;
+
 } // end _sys_fbf_cma_start()
 
@@ -2860 +3143 @@
 int _sys_fbf_cma_display( unsigned int buffer_index )
 {
-#if NB_CMA_CHANNELS > 0
-
     volatile unsigned int full = 1;
+
+    // get calling thread scheduler, ltid and trdid
+    static_scheduler_t*  psched = _get_sched();
+    unsigned int         ltid   = _get_thread_ltid();
+    unsigned int         trdid  = _get_thread_trdid();
+
+    // check FBF allocated
+    if ( (psched->context[ltid].slot[CTX_LOCKS_ID] & LOCKS_MASK_FBF) == 0 )
+    {
+        _printf("\n[GIET ERROR] in _sys_fbf_release() : "
+                "FBF not allocated to thread %x\n", trdid );
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
+    }
 
     // get channel index
@@ -2870 +3165 @@
     {
         _printf("\n[GIET ERROR] in _sys_fbf_cma_display() : "
-                "CMA channel index too large\n");
-        return -1111;
+                "CMA channel non allocated\n");
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
 
@@ -2951 +3247 @@
     _mmc_sync( fbf_sts_paddr, 4 );
 
-    return GIET_SYSCALL_OK;
-
-#else
-
-    _printf("\n[GIET ERROR] in _sys_fbf_cma_display() : no CMA channel allocated\n");
-    return -1111;
-
-#endif
+    return SYSCALL_OK;
+
 } // end _sys_fbf_cma_display()
 
@@ -2964 +3254 @@
 int _sys_fbf_cma_stop()
 {
-#if NB_CMA_CHANNELS > 0
-
     // get channel index
     unsigned int channel = _get_context_slot( CTX_CMA_FB_ID );
@@ -2971 +3259 @@
     if ( channel >= NB_CMA_CHANNELS )
     {
-        _printf("\n[GIET ERROR] in _sys_fbf_cma_stop() : CMA channel index too large\n");
-        return -1111;
+        _printf("\n[GIET ERROR] in _sys_fbf_cma_stop() : CMA channel non allocated\n");
+
+        return SYSCALL_CHANNEL_NON_ALLOCATED;
     }
 
@@ -2978 +3267 @@
     _cma_set_register( channel, CHBUF_RUN, 0 );
 
-    return GIET_SYSCALL_OK;
-
-#else
-
-    _printf("\n[GIET ERROR] in _sys_fbf_cma_stop() : no CMA channel allocated\n");
-    return -1111;
-
-#endif
+    return SYSCALL_OK;
+
 } // end _sys_fbf_cma_stop()
 
@@ -2997 +3280 @@
 {
     _printf("\n[GIET ERROR] Undefined System Call / EPC = %x\n", _get_epc() );
-    return GIET_SYSCALL_UNDEFINED_SYSTEM_CALL;
+
+    return SYSCALL_UNDEFINED_SYSTEM_CALL;
 }
 
@@ -3011 +3295 @@
     *p = gpid & ((1<<P_WIDTH)-1);
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }
 
@@ -3066 +3350 @@
         *nprocs = 0;
     }
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }
 
@@ -3094 +3378 @@
                 {
                     *vbase = vseg[vseg_id].vbase;
-                    return GIET_SYSCALL_OK;
+                    return SYSCALL_OK;
                 }
             } 
         }
     } 
-    return GIET_SYSCALL_VSEG_NOT_FOUND;
+    return SYSCALL_VSEG_NOT_FOUND;
 }
 
@@ -3127 +3411 @@
                 {
                     *length = vseg[vseg_id].length;
-                    return GIET_SYSCALL_OK;
+                    return SYSCALL_OK;
                 }
             } 
         }
     } 
-    return GIET_SYSCALL_VSEG_NOT_FOUND;
+    return SYSCALL_VSEG_NOT_FOUND;
 }
 
@@ -3146 +3430 @@
     *y = (paddr>>32) & 0xF;
 
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }
 
@@ -3162 +3446 @@
         _printf("\n[GIET ERROR] in _sys_heap_info() : "
                 "illegal (%d,%d) coordinates\n", x , y );
-        return GIET_SYSCALL_ILLEGAL_CLUSTER_COORDINATES;
+        return SYSCALL_ILLEGAL_CLUSTER_COORDINATES;
     }
 
@@ -3201 +3485 @@
         _printf("error in _sys_heap_info() : no heap in cluster (%d,%d)\n", x , y );
     }
-    return GIET_SYSCALL_OK;
+    return SYSCALL_OK;
 }  // end _sys_heap_info()
 

soft/giet_vm/giet_kernel/sys_handler.h

@@ -19 +19 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Define the possible command values for the giet_pthread_control() syscall
+// These define must be synchronized with values in the stdio.c file
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -26 +27 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-// Define the error codes for the thread related syscalls
-///////////////////////////////////////////////////////////////////////////////
-
-#define GIET_SYSCALL_OK                               ( 0 )
-#define GIET_SYSCALL_VSPACE_NOT_FOUND                 (-1 )
-#define GIET_SYSCALL_THREAD_NOT_FOUND                 (-2 )
-#define GIET_SYSCALL_NOT_IN_SAME_VSPACE               (-3 )
-#define GIET_SYSCALL_UNCOHERENT_THREAD_CONTEXT        (-4 )
-#define GIET_SYSCALL_ILLEGAL_THREAD_COMMAND_TYPE      (-5 )
-#define GIET_SYSCALL_CANNOT_LOAD_DATA_SEGMENT         (-6 )
-#define GIET_SYSCALL_THREAD_ALREADY_ACTIVE            (-7 )
-#define GIET_SYSCALL_MAIN_NOT_FOUND                   (-8 )
-#define GIET_SYSCALL_APPLI_CANNOT_BE_KILLED           (-9 )
-#define GIET_SYSCALL_PTHREAD_ARGUMENT_NOT_SUPPORTED   (-10)
-#define GIET_SYSCALL_ILLEGAL_CLUSTER_COORDINATES      (-11)
-#define GIET_SYSCALL_VSEG_NOT_FOUND                   (-12)
-#define GIET_SYSCALL_UNDEFINED_SYSTEM_CALL            (-13)
-#define GIET_SYSCALL_COPROCESSOR_NOT_FOUND            (-14)
-#define GIET_SYSCALL_COPROCESSOR_ILLEGAL_MODE         (-15)
+// Define the error codes for the syscall handlers
+// These define must be synchronized with values in the stdio.c file
+///////////////////////////////////////////////////////////////////////////////
+
+#define SYSCALL_OK                               ( 0 )
+#define SYSCALL_VSPACE_NOT_FOUND                 (-1 )
+#define SYSCALL_THREAD_NOT_FOUND                 (-2 )
+#define SYSCALL_NOT_IN_SAME_VSPACE               (-3 )
+#define SYSCALL_UNCOHERENT_THREAD_CONTEXT        (-4 )
+#define SYSCALL_ILLEGAL_THREAD_COMMAND_TYPE      (-5 )
+#define SYSCALL_CANNOT_LOAD_DATA_SEGMENT         (-6 )
+#define SYSCALL_THREAD_ALREADY_ACTIVE            (-7 )
+#define SYSCALL_MAIN_NOT_FOUND                   (-8 )
+#define SYSCALL_APPLI_CANNOT_BE_KILLED           (-9 )
+#define SYSCALL_PTHREAD_ARGUMENT_NOT_SUPPORTED   (-10)
+#define SYSCALL_ILLEGAL_CLUSTER_COORDINATES      (-11)
+#define SYSCALL_VSEG_NOT_FOUND                   (-12)
+#define SYSCALL_UNDEFINED_SYSTEM_CALL            (-13)
+#define SYSCALL_COPROCESSOR_NOT_FOUND            (-14)
+#define SYSCALL_COPROCESSOR_ILLEGAL_MODE         (-15)
+#define SYSCALL_COPROCESSOR_NON_ALLOCATED        (-16)
+#define SYSCALL_CHANNEL_ALREADY_ALLOCATED        (-17)
+#define SYSCALL_NO_CHANNEL_AVAILABLE             (-18)
+#define SYSCALL_CHANNEL_NON_ALLOCATED            (-19)
+#define SYSCALL_ILLEGAL_XY_ARGUMENTS             (-20)
+#define SYSCALL_OUT_OF_KERNEL_HEAP_MEMORY        (-21)
+#define SYSCALL_ADDRESS_NON_ALIGNED              (-22)
+#define SYSCALL_ADDRESS_NON_USER_ACCESSIBLE      (-23)
+#define SYSCALL_MISSING_INITIALISATION           (-24)
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -123 +134 @@
 extern int _sys_exec_application( char* name );
 
-extern int _sys_applications_status();
+extern int _sys_applications_status( char* name );
 
 /////////////////////////////////////////////////////////////////////////////
@@ -217 +228 @@
 //////////////////////////////////////////////////////////////////////////////
 
+extern int _sys_fbf_size( unsigned int* width,
+                          unsigned int* height );
+
+extern int _sys_fbf_alloc();
+
+extern int _sys_fbf_release();
+
 extern int _sys_fbf_sync_write( unsigned int offset,
                          void*        buffer,
@@ -230 +248 @@
 
 extern int _sys_fbf_cma_init_buf(void*        buf0_vbase, 
-                          void*        buf1_vbase, 
-                          void*        sts0_vaddr,
-                          void*        sts1_vaddr );
+                                 void*        buf1_vbase, 
+                                 void*        sts0_vaddr,
+                                 void*        sts1_vaddr );
 
 extern int _sys_fbf_cma_start( unsigned int length );