Index: trunk/kernel/syscalls/sys_open.c
===================================================================
--- trunk/kernel/syscalls/sys_open.c	(revision 1)
+++ trunk/kernel/syscalls/sys_open.c	(revision 23)
@@ -1,15 +1,16 @@
 /*
- * kern/sys_open.c - open a named file
+ * sys_open.c - open a file.
  * 
- * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
- * Copyright (c) 2011,2012 UPMC Sorbonne Universites
+ * Author        Alain Greiner (2016,2017)
  *
- * This file is part of ALMOS-kernel.
+ * Copyright (c) UPMC Sorbonne Universites
  *
- * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * 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,15 +18,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
  */
 
+#include <kernel_config.h>
+#include <hal_types.h>
+#include <hal_uspace.h>
 #include <errno.h>
 #include <thread.h>
+#include <printk.h>
 #include <vfs.h>
-#include <sys-vfs.h>
 #include <process.h>
-#include <spinlock.h>
-#include <cpu-trace.h>
+#include <remote_spinlock.h>
+#include <remote_rwlock.h>
 
 ///////////////////////////////////
@@ -34,47 +38,77 @@
                uint32_t   mode )
 {
-	CPU_HW_TRACE(sys_open);
 
-	error_t            err;
-	struct vfs_file_s  file;   
-	struct ku_obj      ku_path;
-	thread_t         * this     = current_thread;
-	process_t        * process  = current_process;
-	uint32_t           fd       = (uint32_t)-1;
+	error_t        error;
+	xptr_t         file_xp;                          // extended pointer on vfs_file_t
+	uint32_t       file_id;                          // file descriptor index
+    uint32_t       length;                           // pathname length (bytes)
+    char           kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
 
-	cpu_trace_write(current_cpu, sys_open);
+	thread_t     * this     = CURRENT_THREAD;
+	process_t    * process  = this->process;
 
-	if( process_fd_aray_full( process ) )
+	if( pathname == NULL )
 	{
-		this->info.errno = ENFILE;
-        CPU_HW_TRACE(sys_open);
-        return fd;
+        printk("\n[ERROR] in %s : pathname is NULL\n", __FUNCTION__ );
+		this->errno = EINVAL;
+		return -1;
+	}	
+
+    // check fd_array not full
+	if( process_fd_array_full() )
+	{
+        printk("\n[ERROR] in %s : file descriptor array full for process %x\n",
+               __FUNCTION__ , process->pid );
+		this->errno = ENFILE;
+        return -1;
 	}
    
-	if( VFS_IS( flags , VFS_O_DIRECTORY ) ) VFS_SET( flags , VFS_DIR );
+    // get pathname length
+    length = hal_strlen_from_uspace( pathname );
 
-	KU_BUFF( ku_path , pathname );
+    if( length >= CONFIG_VFS_MAX_PATH_LENGTH )
+    {
+        printk("\n[ERROR] in %s : pathname too long\n", __FUNCTION__ );
+		this->errno = ENFILE;
+        return -1;
+    }
+ 
+	// get pathname copy in kernel space
+    hal_copy_from_uspace( kbuf, pathname, length );
 
-    // get the cwd lock
-	rwlock_rdlock( &process->cwd_lock );
+    // get cluster and local pointer on reference process
+    xptr_t      ref_xp  = process->ref_xp;
+    process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
+    cxy_t       ref_cxy = GET_CXY( ref_xp );
+
+    // get extended pointer on cwd inode
+    xptr_t cwd_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_cwd_xp ) );
    
-	err = vfs_open( &process->vfs_cwd , &ku_path , flags , mode , &file );
-	if( err )
+    // get the cwd lock in read mode from reference process
+	remote_rwlock_rd_lock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+
+    // call the relevant VFS function
+	error = vfs_open( cwd_xp,
+                      kbuf,
+                      flags,
+                      mode,
+                      &file_xp,
+                      &file_id );
+
+    // release the cwd lock
+	remote_rwlock_rd_unlock( XPTR( ref_cxy , &ref_ptr->cwd_lock ) );
+
+	if( error )
 	{
-		this->info.errno = (err < 0 ) ? -err : err;
-	    rwlock_unlock( &process->cwd_lock );
-	    CPU_HW_TRACE(sys_open);
-	    return fd;
-	}
-	
-	err = process_fd_set( process , &file , &fd );
-	if( err )
-	{
-		vfs_close(&file, NULL);
-		this->info.errno = err;
+        printk("\n[ERROR] in %s : cannot create file descriptor\n", __FUNCTION__ );
+		this->errno = ENFILE;
+	    return -1;
 	}
 
-	rwlock_unlock( &process->cwd_lock );
-	CPU_HW_TRACE(sys_open);
-	return fd;
+    // update local fd_array
+    remote_spinlock_lock( XPTR( local_cxy , &process->fd_array.lock ) );
+	process->fd_array.array[file_id] = file_xp;
+    remote_spinlock_unlock( XPTR( local_cxy , &process->fd_array.lock ) );
+
+	return file_id;
 }
