Changeset 651 for trunk/kernel/syscalls

Timestamp:

Nov 14, 2019, 11:50:09 AM (4 years ago)

Author:

alain

Message:

1) Improve the VMM MMAP allocator: implement the "buddy" algorithm
to allocate only aligned blocks.
2) fix a bug in the pthread_join() / pthread_exit() mmechanism.

Location:

trunk/kernel/syscalls

Files:

• sys_exit.c (modified) (1 diff)
• sys_get_nb_cores.c (modified) (3 diffs)
• sys_lseek.c (modified) (6 diffs)
• sys_mmap.c (modified) (3 diffs)
• sys_thread_cancel.c (modified) (1 diff)
• sys_thread_create.c (modified) (1 diff)
• sys_thread_exit.c (modified) (3 diffs)
• sys_thread_join.c (modified) (14 diffs)
• syscalls.h (modified) (7 diffs)

trunk/kernel/syscalls/sys_exit.c

@@ -108 +108 @@
 __FUNCTION__, pid, this->trdid );
 #endif
-        thread_delete( XPTR( local_cxy , this ) , pid , true );
+        thread_delete( XPTR( local_cxy , this ) , true );    // forced
     }
 

trunk/kernel/syscalls/sys_get_nb_cores.c

@@ -35 +35 @@
 #include <syscalls.h>
 
-////////////////////////////////////
+/////////////////////////////////////
 int sys_get_nb_cores( uint32_t   cxy,
                       uint32_t * ncores )
@@ -51 +51 @@
 #if DEBUG_SYS_GET_NB_CORES
 if( DEBUG_SYS_GET_NB_CORES < tm_start )
-printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid, (uint32_t)tm_start );
+printk("\n[%s] thread[%x,%x] enter  for cluster %x / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, cxy, (uint32_t)tm_start );
 #endif
 
@@ -88 +88 @@
 #if DEBUG_SYS_GET_NB_CORES
 if( DEBUG_SYS_GET_NB_CORES < tm_end )
-printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
-__FUNCTION__ , process->pid, this->trdid, (uint32_t)tm_end );
+printk("\n[%s] thread[%x,%x] exit / ncores %d / cycle %d\n",
+__FUNCTION__ , process->pid, this->trdid, k_ncores, (uint32_t)tm_end );
 #endif
 

trunk/kernel/syscalls/sys_lseek.c

@@ -1 +1 @@
 /*
- * kern/sys_lseek.c - set the read/write offset of an opened file 
+ * kern/sys_lseek.c - Kernel function implementing the lseek system call.
  * 
- * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
- * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * AUthor        Alain Greiner (2016,2017,2018,2019)
+s
+ * Copyright (c) UPMC Sorbonne Universites
  *
- * This file is part of ALMOS-kernel.
+ * This file is part of ALMOS-MKH.
  *
- * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
  *
- * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ -17 +18 @@
  *
  * You should have received a copy of the GNU General Public License
- * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
@@ -31 +32 @@
 #include <process.h>
 
-////////////////////////////////
-int sys_lseek (uint32_t file_id,
-               uint32_t offset,
-               uint32_t whence )
+/////////////////////////////////
+int sys_lseek ( uint32_t file_id,
+                uint32_t offset,
+                uint32_t whence )
 {
         error_t    error;
@@ -43 +44 @@
         process_t * process = this->process;
 
+#if (DEBUG_SYS_LSEEK || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_start = hal_get_cycles();
+#endif
+
+#if DEBUG_SYS_LSEEK
+if( DEBUG_SYS_LSEEK < tm_start )
+printk("\n[%s] thread[%x,%x] enter / file_id %d / offset %d / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, file_id, offset, (uint32_t)tm_start );
+#endif
+
     // check file_id argument
         if( file_id >= CONFIG_PROCESS_FILE_MAX_NR )
         {
-        printk("\n[ERROR] in %s : illegal file descriptor index = %d\n",
-               __FUNCTION__ , file_id );
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : thread[%x,%x] illegal file descriptor index %d\n",
+__FUNCTION__ , process->pid, this->trdid, file_id );
+#endif
                 this->errno = EBADFD;
                 return -1;
@@ -57 +71 @@
     if( file_xp == XPTR_NULL )
     {
-        printk("\n[ERROR] in %s : undefined file descriptor index = %d\n",
-               __FUNCTION__ , file_id );
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : thread[%x,%x] undefined fd_id %d\n",
+__FUNCTION__, process->pid, this->trdid, file_id );
+#endif
                 this->errno = EBADFD;
                 return -1;
     }
 
-        /* FIXME: file may be closed in parallel 
-         * of seek/read/write/mmap ..etc 
-         * so file may be NULL or invalid */
+// FIXME: file may be closed in parallel of seek/read/write/mmap ..etc 
 
     // call relevant VFS function
@@ -72 +87 @@
         if( error )
         {
-        printk("\n[ERROR] in %s : cannot seek file = %d\n",
-               __FUNCTION__ , file_id );
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : thread[%x,%x] cannot seek file_id %d\n",
+__FUNCTION__, process->pid, this->trdid, file_id );
+#endif
                 this->errno = error;
                 return -1;
         }
+
+#if (DEBUG_SYS_LSEEK || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+
+#if DEBUG_SYS_LSEEK
+if( DEBUG_SYS_LSEEK < tm_end )
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__ , process->pid, this->trdid, (uint32_t)tm_end );
+#endif
+
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_LSEEK] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_LSEEK] , 1 );
+#endif
   
         return new_offset;

trunk/kernel/syscalls/sys_mmap.c

@@ -112 +112 @@
     }
 
-    // FIXME handle Copy_On_Write for MAP_PRIVATE...
+// FIXME handle Copy_On_Write for MAP_PRIVATE...
 
     // test mmap type : can be FILE / ANON / REMOTE
@@ -127 +127 @@
 #endif
 
-            // FIXME: handle concurent delete of file by another thread 
+// FIXME: handle concurent delete of file by another thread 
 
                 if( fdid >= CONFIG_PROCESS_FILE_MAX_NR ) 
@@ -164 +164 @@
 #endif
 
-        // get inode pointer & mapper pointer 
-        vfs_inode_t * inode_ptr  = hal_remote_lpt(XPTR(file_cxy , &file_ptr->inode ));
+        // get mapper pointer 
         mapper_t    * mapper_ptr = hal_remote_lpt(XPTR(file_cxy , &file_ptr->mapper));
 
-        // get file size
-                uint32_t size = hal_remote_l32( XPTR( file_cxy , &inode_ptr->size ) );
-
-#if (DEBUG_SYS_MMAP & 1)
-if ( DEBUG_SYS_MMAP < tm_start )
-printk("\n[%s] thread[%x,%x] get file size : %d bytes\n",
-__FUNCTION__, process->pid, this->trdid, size );
-#endif
-
-        // chek offset and length arguments
-                if( (offset + length) > size)
-                {
-
-#if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s: thread[%x,%x] / offset(%d) + len(%d) >= file's size(%d)\n", 
-__FUNCTION__, process->pid, this->trdid, k_attr.offset, k_attr.length, size );
-#endif
-            this->errno = ERANGE;
-            return -1;
-                }
+#if (DEBUG_SYS_MMAP & 1)
+if ( DEBUG_SYS_MMAP < tm_start )
+printk("\n[%s] thread[%x,%x] get file mapper %x\n",
+__FUNCTION__, process->pid, this->trdid, mapper_ptr );
+#endif
 
 /* TODO

trunk/kernel/syscalls/sys_thread_cancel.c

@@ -101 +101 @@
     {
         // block target thread and mark it for delete
-        thread_delete( target_xp , pid , false );
+        thread_delete( target_xp , false );              // not forced
     }
 

trunk/kernel/syscalls/sys_thread_create.c

@@ -154 +154 @@
         else                                        // set default attributes
         {
-        kern_attr.attributes = PT_ATTR_DETACH | PT_ATTR_CLUSTER_DEFINED;
+        kern_attr.attributes = PT_ATTR_CLUSTER_DEFINED;
         child_cxy = dqdt_get_cluster_for_thread( LOCAL_CLUSTER->dqdt_root_xp );
         }

trunk/kernel/syscalls/sys_thread_exit.c

@@ -33 +33 @@
 #include <syscalls.h>
 
-////////////////////////////////////////
-int sys_thread_exit( void * exit_value )
+/////////////////////////////////////////
+int sys_thread_exit( void * exit_status )
 {
+    error_t     error;
+    vseg_t    * vseg;
+
         thread_t  * this      = CURRENT_THREAD;
     trdid_t     trdid     = this->trdid;
     process_t * process   = this->process;
     pid_t       pid       = process->pid;
+    
+    // check exit_value pointer in user space if required
+    if( exit_status != NULL )
+    {
+        error = vmm_get_vseg( process , (intptr_t)exit_status  , &vseg );
 
-    // check exit_value argument
-    if( exit_value != NULL )
-    {
+        if( error )
+            {
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : thread[%x,%x] / exit_value argument %x must be NULL\n",
-__FUNCTION__ , pid, trdid , exit_value );
+printk("\n[ERROR] in %s : exit_status buffer %x unmapped / thread[%x,%x]\n",
+__FUNCTION__, (intptr_t)exit_status, process->pid, this->trdid );
 #endif
-        this->errno = EINVAL;
-        return -1;
+            this->errno = EINVAL;
+                return -1;
+        }
+    }
+
+        // check busylocks
+    uint32_t count = this->busylocks;
+        if( count )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : busylocks count = %d  / thread[%x,%x]\n",
+__FUNCTION__ , count, process->pid, this->trdid );
+#endif
+            this->errno = EINVAL;
+                return -1;
     }
 
     // If calling thread is the main thread, the process must be deleted. 
-    // => delete all process threads and synchronise with parent process.
-    // If calling thread is not the main thread, it must be deleted.
-    // => block the thread and mark it for delete.
-    if( (CXY_FROM_PID( pid ) == local_cxy) && (LTID_FROM_TRDID(trdid) == 0) )
+    // => delete all process threads and synchronize with parent process.
+    // If calling thread is not the main thread, only this thread must be deleted.
+    // => register exit_status in thread descriptor, block the thread, 
+    //    mark it for delete, and synchronize with joining thread. 
+
+    if( (CXY_FROM_PID( pid ) == local_cxy) && (LTID_FROM_TRDID(trdid) == 0) )  // main
     {
 
@@ -69 +92 @@
         sys_exit( 0 );
     }
-    else
+    else                                                             // not the main
     {
 
@@ -78 +101 @@
 __FUNCTION__ , pid , trdid , (uint32_t)tm_start );
 #endif
+        // register exit_status in thread descriptor
+        this->exit_status = exit_status;
+
         // block calling thread and mark it for delete,
-        thread_delete( XPTR( local_cxy , this ) , pid , false );
+        thread_delete( XPTR( local_cxy , this ) , false );   // not forced
 
         // deschedule

trunk/kernel/syscalls/sys_thread_join.c

@@ -1 +1 @@
 /*
- * sys_thread_join.c - passive wait on the end of a given thread.
+ * sys_thread_join.c - wait termination of of an attached thread.
  * 
  * Authors    Alain Greiner (2016,2017,2018,2019)
@@ -26 +26 @@
 #include <hal_special.h>
 #include <hal_irqmask.h>
+#include <hal_uspace.h>
 #include <thread.h>
 #include <vmm.h>
@@ -37 +38 @@
 ///////////////////////////////////////
 int sys_thread_join ( trdid_t    trdid,
-                      void    ** exit_value )
+                      void    ** exit_status )
 {
+    error_t       error;
     reg_t         save_sr;
     xptr_t        target_xp;
@@ -47 +49 @@
     xptr_t        target_flags_xp;
     xptr_t        target_join_xp_xp;
+    xptr_t        target_exit_status_xp;
     xptr_t        killer_xp;
     xptr_t        joining_xp;
     thread_t    * joining_ptr;
     process_t   * process;
+    vseg_t      * vseg;
+    void        * status;
 
     // get joining thread pointers
@@ -62 +67 @@
 
 #if DEBUG_SYS_THREAD_JOIN
-uint64_t     tm_start;
-uint64_t     tm_end;
-tm_start = hal_get_cycles();
+uint64_t  tm_start = hal_get_cycles();
 if( DEBUG_SYS_THREAD_JOIN < tm_start )
-printk("\n[DBG] %s : joining thread[%x,%x] enter / target thread[%x,%x] / cycle %d\n",
+printk("\n[%s] joining thread[%x,%x] enter / target thread[%x,%x] / cycle %d\n",
 __FUNCTION__ , process->pid, joining_ptr->trdid,
 process->pid, trdid, (uint32_t)tm_start );
@@ -77 +80 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : illegal trdid argument %x\n",
-__FUNCTION__, trdid );
+printk("\n[ERROR] in %s : illegal trdid argument %x / joining thread[%x,%x]\n",
+__FUNCTION__, trdid, joining_ptr->process->pid, joining_ptr-trdid );
 #endif
                 joining_ptr->errno = EINVAL;
@@ -84 +87 @@
         }
 
-    // check exit_value argument
-        if( exit_value != NULL )
+    // check exit_value argument in user space
+    error = vmm_get_vseg( process , (intptr_t)exit_status  , &vseg );
+        if( error )
         {
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : exit_value argument must be NULL\n",
-__FUNCTION__ );
+printk("\n[ERROR] in %s : exit_status argument %x not mapped / joining thread[%x,%x]\n",
+__FUNCTION__, exit_status, joining_ptr->process->pid, joining_ptr-trdid );
 #endif
                 joining_ptr->errno = EINVAL;
@@ -101 +105 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : this thread (%x) == target thread(%x)\n",
-__FUNCTION__, joining_ptr->trdid, trdid );
+printk("\n[ERROR] in %s : joinig thread[%x,%x] == target thread\n",
+__FUNCTION__, joining_ptr->process->pid, joining_ptr->trdid );
 #endif
         joining_ptr->errno = EDEADLK;
@@ -116 +120 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : target thread %x not found\n",
-__FUNCTION__, trdid );
+printk("\n[ERROR] in %s : target thread[%x,%x] not found / joining_thread[%x,%x]\n",
+__FUNCTION__, process->pid, trdid, joining_ptr->process->pid, joining_ptr-trdid );
 #endif
         joining_ptr->errno = ESRCH;
@@ -124 +128 @@
 
     // get extended pointers on various fields in target thread
-    target_join_lock_xp = XPTR( target_cxy , &target_ptr->join_lock );
-    target_flags_xp     = XPTR( target_cxy , &target_ptr->flags );
-    target_join_xp_xp   = XPTR( target_cxy , &target_ptr->join_xp );
+    target_join_lock_xp   = XPTR( target_cxy , &target_ptr->join_lock );
+    target_flags_xp       = XPTR( target_cxy , &target_ptr->flags );
+    target_join_xp_xp     = XPTR( target_cxy , &target_ptr->join_xp );
+    target_exit_status_xp = XPTR( target_cxy , &target_ptr->exit_status );
 
     // check target thread joinable
@@ -133 +138 @@
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : target thread %x not joinable\n", __FUNCTION__, trdid );
+printk("\n[ERROR] in %s : target thread[%x,‰x] not attached / joining thread[%x,%x]\n",
+__FUNCTION__, process->pid, trdid, joining_ptr->process->pid, joining_ptr-trdid );
 #endif
         joining_ptr->errno = EINVAL; 
@@ -146 +152 @@
 
     // test the kill_done flag from the target thread
-    if( hal_remote_l32( target_flags_xp ) & THREAD_FLAG_KILL_DONE )  // killer thread is first
-    {
+    if( hal_remote_l32( target_flags_xp ) & THREAD_FLAG_KILL_DONE )  // killer is first
+    {
+        // get exit_status from target thread
+        status = (void*)hal_remote_lpt( target_exit_status_xp );
+
         // get pointers on killer thread
         killer_xp  = (xptr_t)hal_remote_l64( target_join_xp_xp );
@@ -159 +168 @@
         // release the lock protecting join      
         remote_busylock_release( target_join_lock_xp );
-
-#if DEBUG_SYS_THREAD_JOIN
-tm_end = hal_get_cycles();
-if( DEBUG_SYS_THREAD_JOIN < tm_end )
-printk("\n[DBG] %s : joining thread[%x,%x] exit / target thread[%x,%x] completed / cycle %d\n",
-__FUNCTION__, process->pid, joining_ptr->trdid, process->pid, trdid, (uint32_t)tm_end );
-#endif
-
-    }
-    else                                                          // joining thread is first
+    }
+    else                                                          // joining is first
     {
         // set the join_done flag in target thread
@@ -184 +185 @@
 #if DEBUG_SYS_THREAD_JOIN 
 if( DEBUG_SYS_THREAD_JOIN < tm_start )
-printk("\n[DBG] %s : joining thread[%x,%x] deschedules / target thread[%x,%x] not completed\n",
+printk("\n[%s] joining thread[%x,%x] deschedules / target thread[%x,%x] not completed\n",
 __FUNCTION__ , process->pid, joining_ptr->trdid, process->pid, trdid );
 #endif
         // deschedule
         sched_yield( "joining thread waiting killer thread" );
+
+        // returns exit_status from joining thread
+        status = joining_ptr->exit_status;
+    }
     
+    // returns exit_status to user space
+    hal_copy_to_uspace( exit_status,
+                        XPTR( local_cxy , &status ),
+                        sizeof( void* ) );
+
+    // restore IRQs
+    hal_restore_irq( save_sr );
+
+    hal_fence();
+
+#if (DEBUG_SYS_THREAD_JOIN || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_THREAD_JOIN] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_THREAD_JOIN] , 1 );
+#endif
+
 #if DEBUG_SYS_THREAD_JOIN 
 tm_end = hal_get_cycles();
 if( DEBUG_SYS_THREAD_JOIN < tm_end )
-printk("\n[DBG] %s : joining thread[%x,%x] exit / target thread[%x,%x] completed / cycle %d\n",
+printk("\n[%s] joining thread[%x,%x] exit / target thread[%x,%x] completed / cycle %d\n",
 __FUNCTION__ , process->pid, joining_ptr->trdid, process->pid, trdid, (uint32_t)tm_end );
 #endif
 
-    }
-
-    // restore IRQs
-    hal_restore_irq( save_sr );
-
     return 0;
 

trunk/kernel/syscalls/syscalls.h

@@ -37 +37 @@
 
 /****************************************************************************************** 
- * [0] This function terminates the execution of the calling user thread, 
- * and makes the exit_value pointer available to any successful pthread_join() with the 
+ * [0] This function terminates the execution of the calling user thread, and makes 
+ * the <exit_status> pointer available to any successful pthread_join() with the 
  * terminating thread.
- * It actually set the THREAD_SIG_EXIT signal, set the THREAD_BLOCKED_GLOBAL bit in the
- * thread descriptor and deschedule.
- * The thread will be detached from its process, and the memory allocated to the thread
- * descriptor will be released later by the scheduler.
- ******************************************************************************************
- * @ exit_vallue  : pointer to be returned to joining thread if thread is attached.
+ * - If the calling thread is the main thread, it calls the sys_exit() function to delete
+ *   completely the user process.  
+ * - if the calling thread is not the main thread, it registers the <exit_status> pointer
+ *   in the thread descriptor, and calls the thread_delete() function, that will set the
+ *   THREAD_SIG_EXIT signal, set the THREAD_BLOCKED_GLOBAL bit in thread descriptor, and 
+ *   deschedules. All memory allocated to the thread is released later by the scheduler.
+ *   If the thread is in "detached" mode, the thread_delete() function implements
+ *   the synchonisation with the joining thread.
+ ******************************************************************************************
+ * @ exit_status  : pointer to be returned to joining thread if thread is attached.
  * @ return 0 if success / return -1 if all locks not released or illegal argument.
  *****************************************************************************************/
-int sys_thread_exit( void * exit_value );
+int sys_thread_exit( void * exit_status );
 
 /****************************************************************************************** 
@@ -222 +226 @@
  ******************************************************************************************
  * @ attr       : pointer on attributes structure.
- * @ return 0 if success / return -1 if failure.
+ * @ returns 0 if success / returns -1 if failure.
  *****************************************************************************************/
 int sys_mmap( mmap_attr_t * attr );
@@ -234 +238 @@
  * @ buf      : buffer virtual address in user space.
  * @ count    : number of bytes.
- * @ return number of bytes actually read if success / returns -1 if failure.
+ * @ returns number of bytes actually read if success / returns -1 if failure.
  *****************************************************************************************/
 int sys_read( uint32_t   file_id,
@@ -251 +255 @@
  * @ buf      : buffer virtual address in user space.
  * @ count    : number of bytes.
- * @ return number of bytes actually written if success / returns -1 if failure.
+ * @ returns number of bytes actually written if success / returns -1 if failure.
  *****************************************************************************************/
 int sys_write( uint32_t   file_id,
@@ -258 +262 @@
 
 /****************************************************************************************** 
- * [16] This function repositions the offset of the file descriptor identified by <file_id>,
- * according to the operation type defined by the <whence> argument.
+ * [16] This function repositions the offset of the file descriptor identified by the
+ * <file_id> argument, according to the operation type defined by the <whence> argument.
  ******************************************************************************************
  * @ file_id  : open file index in fd_array.
  * @ offset   : used to compute new offset value.
  * @ whence   : operation type (see below).
- * @ return 0 if success / returns -1 if failure.
+ * @ returns new offset value if success / returns -1 if failure.
  *****************************************************************************************/
 int sys_lseek( xptr_t    file_id,
@@ -276 +280 @@
  ******************************************************************************************
   file_id   : file descriptor index in fd_array.
- * @ return 0 if success / returns -1 if failure.
+ * @ returns 0 if success / returns -1 if failure.
  *****************************************************************************************/
 int sys_close( uint32_t file_id );
@@ -289 +293 @@
  ******************************************************************************************
  * @ pathname   : pathname (can be relative or absolute).
- * @ return 0 if success / returns -1 if failure.
+ * @ returns 0 if success / returns -1 if failure.
  *****************************************************************************************/
 int sys_unlink( char * pathname );