Changeset 23 for trunk/kernel/syscalls/sys_open.c

Timestamp:

Jun 18, 2017, 10:06:41 PM (7 years ago)

Author:

alain

Message:

Introduce syscalls.

File:

• trunk/kernel/syscalls/sys_open.c (modified) (3 diffs)

trunk/kernel/syscalls/sys_open.c

@@ -1 +1 @@
 /*
- * 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 +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 +38 @@
                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;
 }