Changeset 611 for trunk/kernel/syscalls

Timestamp:

Jan 9, 2019, 3:02:51 PM (5 years ago)

Author:

alain

Message:

Introduce sigificant modifs in VFS to support the <ls> command,
and the . and .. directories entries.

Location:

trunk/kernel/syscalls

Files:

• shared_include/shared_almos.h (modified) (1 diff)
• shared_include/shared_dirent.h (modified) (1 diff)
• shared_include/shared_stat.h (modified) (4 diffs)
• sys_closedir.c (modified) (4 diffs)
• sys_display.c (modified) (3 diffs)
• sys_mmap.c (modified) (3 diffs)
• sys_opendir.c (modified) (6 diffs)
• sys_readdir.c (modified) (3 diffs)
• syscalls.h (modified) (5 diffs)

trunk/kernel/syscalls/shared_include/shared_almos.h

@@ -52 +52 @@
     DISPLAY_DQDT              = 7,
     DISPLAY_BUSYLOCKS         = 8,
+    DISPLAY_MAPPER            = 9,
 }
 display_type_t;

trunk/kernel/syscalls/shared_include/shared_dirent.h

@@ -26 +26 @@
 
 /*******************************************************************************************
- * These two structure defines the informations returned to user by the opendir()
- * function, used by the readdir() function, and released by the closedir() function.
- * - "DIR" describes the complete directory.
- * - "dirent" describes one directory entry.
+ * This enum defines the possible types for a dirent inode in a dirent structure.
+ *
+ * WARNING : these types must be kept consistent with inode types in <vfs.h> file.
+ *           and with types in <shared_stat.h> file.
  ******************************************************************************************/
 
-#define DIRENT_NAME_MAX_LENGTH  56
-#define DIRENT_MAX_NUMBER       63
+typedef enum 
+{
+    DT_REG     = 0,                     /*! regular file                                  */
+    DT_DIR     = 1,                     /*! directory                                     */
+    DT_FIFO    = 2,                     /*! named pipe (FIFO)                             */
+    DT_PIPE    = 3,                     /*! anonymous pipe                                */
+    DT_SOCK    = 4,                     /*! socket                                        */
+    DT_CHR     = 5,                     /*! character device                              */
+    DT_BLK     = 6,                     /*! block device                                  */
+    DT_LNK     = 7,                     /*! symbolic link                                 */
+    DT_UNKNOWN = 8,                     /*! undetermined type                             */
+}
+dirent_type_t;
+
+/*******************************************************************************************
+ * This defines the actual ALMOS-MKH implementation of the DIR user type.
+ ******************************************************************************************/
+
+typedef unsigned int   DIR;
+
+/*******************************************************************************************
+ * This structure defines the informations returned to user by the readdir() syscall.
+ * 
+ * WARNING: sizeof(dirent) must be 64 bytes.
+ ******************************************************************************************/
 
 struct dirent
 {
-    unsigned int   inum;                                /*! inode identifier              */
-    unsigned int   type;                                /*! inode type                    */
-    char           name[DIRENT_NAME_MAX_LENGTH];        /*! directory entry name          */
+    int           d_ino;                                  /*! inode identifier            */
+    int           d_type;                                 /*! inode type                  */
+    char          d_name[48];                             /*! dentry name                 */
+    char          padding[64 - 48 - (2*sizeof(int))];
 };
 
-typedef struct user_directory
-{
-    struct dirent   entry[DIRENT_MAX_NUMBER];
-    unsigned int    current;
-}
-DIR;
-
 #endif

trunk/kernel/syscalls/shared_include/shared_stat.h

@@ -30 +30 @@
  *****************************************************************************************/
 
-typedef struct stat 
+struct stat 
 {
         unsigned int    st_dev;     /*! ID of device containing file                         */
@@ -42 +42 @@
         unsigned int    st_blksize; /*! blocksize for file system I/O                        */
         unsigned int    st_blocks;  /*! number of allocated blocks                           */
-}
-stat_t;
+};
 
 /******************************************************************************************
@@ -52 +51 @@
  *
  * WARNING : these macros must be kept consistent with inode types in <vfs.h> file.
+ *           and with types in <dirent.h> file.
  *****************************************************************************************/
 
@@ -60 +60 @@
 #define  S_ISSOCK(x)  ((((x)>>16) & 0xF) == 4)    /*! it is a socket                     */
 #define  S_ISCHR(x)   ((((x)>>16) & 0xF) == 5)    /*! it is a character device           */
-#define  S_ISLNK(x)   ((((x)>>16) & 0xF) == 6)    /*! it is a symbolic link              */
+#define  S_ISBLK(x)   ((((x)>>16) & 0xF) == 6)    /*! it is a block device               */
+#define  S_ISLNK(x)   ((((x)>>16) & 0xF) == 7)    /*! it is a symbolic link              */
 
 #endif /* _STAT_H_ */

trunk/kernel/syscalls/sys_closedir.c

@@ -1 +1 @@
 /*
- * sys_closedir.c - Close an open directory.
+ * sys_closedir.c - Close an open VFS directory.
  * 
- * Author    Alain Greiner  (2016, 2017)
+ * Author    Alain Greiner  (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -22 +22 @@
  */
 
+#include <kernel_config.h>
 #include <hal_kernel_types.h>
 #include <vfs.h>
@@ -27 +28 @@
 #include <thread.h>
 #include <process.h>
+#include <remote_dir.h>
 #include <errno.h>
 #include <syscalls.h>
@@ -34 +36 @@
 int sys_closedir ( DIR * dirp )
 {
-    printk("\n[ERROR] in %s : not implemented yet\n", __FUNCTION__, dirp );
-    return -1;
+    xptr_t         dir_xp;       // extended pointer on remote_dir_t structure
+
+        thread_t  * this    = CURRENT_THREAD;  // client thread
+        process_t * process = this->process;   // client process
+
+#if (DEBUG_SYS_CLOSEDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_start = hal_get_cycles();
+#endif
+
+#if DEBUG_SYS_CLOSEDIR
+if( DEBUG_SYS_CLOSEDIR < tm_start )
+printk("\n[%s] thread[%x,%x] enter for DIR <%x> / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, dirp, (uint32_t)tm_start );
+#endif
+ 
+    // get extended pointer on kernel remote_dir_t structure from dirp
+    dir_xp  = remote_dir_from_ident( (intptr_t)dirp );
+
+    if( dir_xp == XPTR_NULL )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s / thread[%x,%x] : DIR pointer %x not registered\n",
+__FUNCTION__ , process->pid , this->trdid, dirp );
+#endif
+                this->errno = EINVAL;
+                return -1;
+        }       
+
+    // delete kernel remote_dir_t structure
+    remote_dir_destroy( dir_xp );
+
+    hal_fence();
+
+#if (DEBUG_SYS_CLOSEDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+
+#if DEBUG_SYS_CLOSEDIR
+if( DEBUG_SYS_CLOSEDIR < tm_end )
+printk("\n[%s] thread[%x,%x] exit for DIR <%x> / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, dirp, (uint32_t)tm_end );
+#endif
+ 
+#if CONFIG_INSTRUMENTATION_SYSCALLS
+hal_atomic_add( &syscalls_cumul_cost[SYS_CLOSEDIR] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_CLOSEDIR] , 1 );
+#endif
+
+    return 0;
+
 }  // end sys_closedir()

trunk/kernel/syscalls/sys_display.c

@@ -31 +31 @@
 #include <string.h>
 #include <shared_syscalls.h>
+#include <vfs.h>
+#include <mapper.h>
 
 #include <syscalls.h>
@@ -56 +58 @@
 int sys_display( reg_t  type,
                  reg_t  arg0,
-                 reg_t  arg1 )
+                 reg_t  arg1,
+                 reg_t  arg2 )
 {
 
@@ -278 +281 @@
         thread_display_busylocks( thread_xp );
     }
+    /////////////////////////////////
+    else if( type == DISPLAY_MAPPER )
+    {
+        xptr_t        root_inode_xp;
+        xptr_t        inode_xp;
+        cxy_t         inode_cxy;
+        vfs_inode_t * inode_ptr;
+        xptr_t        mapper_xp;
+        mapper_t    * mapper_ptr;
+
+        char          kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
+
+        char     * path    = (char *)arg0;
+        uint32_t   page_id = (uint32_t)arg1;
+        uint32_t   nbytes  = (uint32_t)arg2;
+
+        // check pathname length
+        if( hal_strlen_from_uspace( path ) >= CONFIG_VFS_MAX_PATH_LENGTH )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : pathname too long\n",
+ __FUNCTION__ );
+#endif
+            this->errno = ENFILE;
+            return -1;
+        }
+
+        // copy pathname in kernel space
+        hal_strcpy_from_uspace( kbuf , path , CONFIG_VFS_MAX_PATH_LENGTH );
+
+        // compute root inode for pathname 
+        if( kbuf[0] == '/' )                        // absolute path
+        {
+            // use extended pointer on VFS root inode
+            root_inode_xp = process->vfs_root_xp;
+        }
+        else                                        // relative path
+        {
+            // 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 );
+
+            // use extended pointer on CWD inode
+            root_inode_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->cwd_xp ) );
+        }
+
+        // get extended pointer on target inode
+        error = vfs_lookup( root_inode_xp,
+                            kbuf,
+                            0,
+                            &inode_xp,
+                            NULL );
+        if( error )
+            {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : cannot found inode <%s>\n",
+__FUNCTION__ , kbuf );
+#endif
+                    this->errno = ENFILE;
+                    return -1;
+            }
+   
+        // get target inode cluster and local pointer
+        inode_cxy = GET_CXY( inode_xp );
+        inode_ptr = GET_PTR( inode_xp );
+
+        // get extended pointer on target mapper
+        mapper_ptr = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
+        mapper_xp  = XPTR( inode_cxy , mapper_ptr );
+
+        // display mapper
+        error = mapper_display_page( mapper_xp , page_id , nbytes , kbuf );
+
+        if( error )
+            {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : cannot display page %d\n",
+__FUNCTION__ , page_id );
+#endif
+                    this->errno = ENFILE;
+                    return -1;
+            }
+    }
     ////
     else 

trunk/kernel/syscalls/sys_mmap.c

@@ -119 +119 @@
     // test mmap type : can be FILE / ANON / REMOTE
 
-    if( (map_anon == false) && (map_remote == false) )   // FILE
+    /////////////////////////////////////////////////////////// MAP_FILE
+    if( (map_anon == false) && (map_remote == false) )   
     {
 
@@ -217 +218 @@
         vseg_cxy  = file_cxy;
     }
-    else if ( map_anon )                                 // MAP_ANON
+    ///////////////////////////////////////////////////////// MAP_ANON
+    else if ( map_anon )                                 
     {
         mapper_xp = XPTR_NULL;
@@ -230 +232 @@
 
     } 
-    else                                                 // MAP_REMOTE
+    /////////////////////////////////////////////////////// MAP_REMOTE
+    else                                                 
     {
         mapper_xp = XPTR_NULL;

trunk/kernel/syscalls/sys_opendir.c

@@ -1 +1 @@
 /*
- * sys_opendir.c - open a directory.
+ * sys_opendir.c - Open a VFS directory.
  * 
  * Author        Alain Greiner (2016,2017,2018)
@@ -22 +22 @@
  */
 
+#include <kernel_config.h>
 #include <hal_kernel_types.h>
 #include <hal_uspace.h>
 #include <thread.h>
 #include <process.h>
+#include <remote_dir.h>
 #include <printk.h>
 #include <errno.h>
+#include <vseg.h>
 #include <vfs.h>
 #include <syscalls.h>
@@ -36 +39 @@
                   DIR  ** dirp )
 {
-    error_t       error;
-    vseg_t      * vseg;                   // for user space checking
-    xptr_t        root_inode_xp;          // extended pointer on path root inode
-
+    error_t        error;
+    xptr_t         root_inode_xp;          // extended pointer on path root inode
+    xptr_t         inode_xp;               // extended pointer on directory inode
+    vfs_inode_t  * inode_ptr;              // local pointer on directory inode
+    cxy_t          inode_cxy;              // directory inode cluster
+    uint32_t       inode_type;             // to check directory inode type
+    xptr_t         dir_xp;                 // extended pointer on remote_dir_t
+    remote_dir_t * dir_ptr;                // local pointer on remote_dir_t
+    cxy_t          dir_cxy;                // remote_dir_t cluster identifier
+    vseg_t       * vseg;                   // for user space checking
+    intptr_t       ident;                  // dirent array pointer in user space                  
     char          kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
         
-        thread_t  * this    = CURRENT_THREAD;
-        process_t * process = this->process;
+        thread_t     * this    = CURRENT_THREAD;  // client thread
+        process_t    * process = this->process;   // client process
 
 #if (DEBUG_SYS_OPENDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
@@ -85 +95 @@
 #endif
 
-    // compute root inode for path 
+    // compute root inode for pathname 
     if( kbuf[0] == '/' )                        // absolute path
     {
@@ -102 +112 @@
     }
 
-/*
-    // call the relevant VFS function ???
-    error = vfs_opendir( root_inode_xp,
-                         kbuf );
+    // get extended pointer on directory inode
+    error = vfs_lookup( root_inode_xp,
+                        kbuf,
+                        0,
+                        &inode_xp,
+                        NULL );
     if( error )
         {
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s / thread[%x,%x] : cannot open directory <%s>\n",
-__FUNCTION__ , process->pid , this->trdid , pathname );
+printk("\n[ERROR] in %s / thread[%x,%x] : cannot found directory <%s>\n",
+__FUNCTION__ , process->pid , this->trdid , kbuf );
 #endif
                 this->errno = ENFILE;
@@ -117 +129 @@
         }
    
-    // copy to user space ???
-*/
+    // check inode type 
+    inode_ptr  = GET_PTR( inode_xp );
+    inode_cxy  = GET_CXY( inode_xp );
+    inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
+
+    if( inode_type != INODE_TYPE_DIR )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s / thread[%x,%x] : cannot found directory <%s>\n",
+__FUNCTION__ , process->pid , this->trdid , kbuf );
+#endif
+                this->errno = ENFILE;
+                return -1;
+        }
+   
+    // allocate, initialize, and register a new remote_dir_t structure
+    // in the calling process reference cluster
+    dir_xp  = remote_dir_create( inode_xp );
+    dir_ptr = GET_PTR( dir_xp );
+    dir_cxy = GET_CXY( dir_xp );
+
+    if( dir_xp == XPTR_NULL )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s / thread[%x,%x] : cannot create remote_dir for <%s>\n",
+__FUNCTION__ , process->pid , this->trdid , kbuf );
+#endif
+                this->errno = ENFILE;
+                return -1;
+        }
+   
+    // get ident from remote_dir structure
+    ident = (intptr_t)hal_remote_lpt( XPTR( dir_cxy , &dir_ptr->ident ) );
+
+    // set ident value in user buffer
+    hal_copy_to_uspace( dirp , &ident , sizeof(intptr_t) );
 
     hal_fence();

trunk/kernel/syscalls/sys_readdir.c

@@ -1 +1 @@
 /*
- * sys_readdir.c - Read one entry from an open directory.
+ * sys_readdir.c - Copy one entry from an open VFS directory to an user buffer.
  *
- * Author    Alain Greiner (2016,2017)
+ * Author    Alain Greiner (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -30 +30 @@
 #include <vfs.h>
 #include <process.h>
+#include <remote_dir.h>
 #include <syscalls.h>
 #include <shared_syscalls.h>
@@ -35 +36 @@
 ///////////////////////////////////////
 int sys_readdir( DIR            * dirp,
-                 struct dirent ** dentp )
+                 struct dirent ** buffer )
 {
-    printk("\n[ERROR] in %s : not implemented yet\n", __FUNCTION__, dirp, dentp );
-    return -1;
+    error_t         error;
+    vseg_t        * vseg;               // for user space checking of buffer
+    xptr_t          dir_xp;             // extended pointer on remote_dir_t structure
+    remote_dir_t  * dir_ptr;            // local pointer on remote_dir_t structure
+    cxy_t           dir_cxy;            // remote_dir_t stucture cluster identifier
+    struct dirent * direntp;            // dirent pointer in user space  
+    uint32_t        entries;            // total number of dirent entries
+    uint32_t        current;            // current dirent index
+
+        thread_t  * this    = CURRENT_THREAD;  // client thread
+        process_t * process = this->process;   // client process
+
+#if (DEBUG_SYS_READDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_start = hal_get_cycles();
+#endif
+
+#if DEBUG_SYS_READDIR
+if( DEBUG_SYS_READDIR < tm_start )
+printk("\n[%s] thread[%x,%x] enter / dirp %x / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, dirp, (uint32_t)tm_start );
+#endif
+ 
+    // check buffer in user space
+    error = vmm_get_vseg( process , (intptr_t)buffer, &vseg );
+
+        if( error )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s / thread[%x,%x] : user buffer %x unmapped\n",
+__FUNCTION__ , process->pid , this->trdid, buffer );
+vmm_display( process , false );
+#endif
+                this->errno = EINVAL;
+                return -1;
+        }       
+
+    // get pointers on remote_dir_t structure from dirp
+    dir_xp  = remote_dir_from_ident( (intptr_t)dirp );
+    dir_ptr = GET_PTR( dir_xp );
+    dir_cxy = GET_CXY( dir_xp );
+
+    if( dir_xp == XPTR_NULL )
+        {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s / thread[%x,%x] : dirp %x not registered\n",
+__FUNCTION__ , process->pid , this->trdid, dirp );
+#endif
+                this->errno = EBADF;
+                return -1;
+        }       
+
+    // get "current" and "entries_nr" values from remote_dir_t structure
+    current = hal_remote_l32( XPTR( dir_cxy , &dir_ptr->current ) );
+    entries = hal_remote_l32( XPTR( dir_cxy , &dir_ptr->entries ) );
+
+    // check "current" index
+    if( current >= entries )
+    {
+        this->errno = 0;
+        return -1;
+    }
+
+    // compute dirent pointer in user space
+    direntp = (struct dirent *)dirp + current;
+
+#if (DEBUG_SYS_READDIR & 1)
+if( DEBUG_SYS_READDIR < tm_start )
+printk("\n[%s] entries = %d / current = %d / direntp = %x\n",
+__FUNCTION__, entries, current, direntp );
+#endif
+
+    // copy dirent pointer to user buffer 
+    hal_copy_to_uspace( buffer, &direntp , sizeof(void *) );
+
+    // update current index in "remote_dir_t" structure
+    hal_remote_atomic_add( XPTR( dir_cxy , &dir_ptr->current ) , 1 );
+
+    hal_fence();
+
+#if (DEBUG_SYS_READDIR || CONFIG_INSTRUMENTATION_SYSCALLS)
+uint64_t     tm_end = hal_get_cycles();
+#endif
+
+#if DEBUG_SYS_READDIR
+if( DEBUG_SYS_READDIR < 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_READDIR] , tm_end - tm_start );
+hal_atomic_add( &syscalls_occurences[SYS_READDIR] , 1 );
+#endif
+
+        return 0;
+
 }  // end sys_readdir()

trunk/kernel/syscalls/syscalls.h

@@ -328 +328 @@
 /****************************************************************************************** 
  * [23] This function open a directory, that must exist in the file system, returning 
- * a DIR pointer on the directory in user space.
- ******************************************************************************************
- * @ pathname   : pathname (can be relative or absolute).
+ * a DIR pointer on the dirent array in user space.
+ ******************************************************************************************
+ * @ pathname   : [in]  pathname (can be relative or absolute).
  * @ dirp       : [out] buffer for pointer on user directory (DIR).
  * @ return 0 if success / returns -1 if failure.
@@ -341 +341 @@
  * next directory entry in the directory identified by the <dirp> argument.
  ******************************************************************************************
- * @ dirp     : user pointer identifying the searched directory.
- * @ dentp    : [out] buffer for pointer on user direntory entry (dirent).
+ * @ dirp     : [in]  user pointer on dirent array identifying the open directory.
+ * @ buffer   : [out] pointer on user buffer for a pointer on dirent in user space.
  * @ return O if success / returns -1 if failure.
  *****************************************************************************************/
 int sys_readdir( DIR            * dirp,
-                 struct dirent ** dentp );
+                 struct dirent ** buffer );
 
 /****************************************************************************************** 
@@ -352 +352 @@
  * all structures associated with the <dirp> pointer.
  ******************************************************************************************
- * @ dirp     : user pointer identifying the directory.
+ * @ dirp     : [in] user pointer on dirent array identifying the open directory.
  * @ return 0 if success / returns -1 if failure.
  *****************************************************************************************/
@@ -575 +575 @@
  * [43] This debug function displays on the kernel terminal TXT0 an user defined string,
  * or the current state of a kernel structure, identified by the <type> argument.
- * The <arg0> and <arg1> arguments depends on the structure type:
+ * The <arg0>, <arg1>, and <arg2> arguments depends on the structure type:
  * - DISPLAY_STRING          : an user defined string
  * - DISPLAY_VMM             : VSL and GPT for a process identified by <pid>.
@@ -583 +583 @@
  * - DISPLAY_VFS             : all files registered in the VFS cache. 
  * - DISPLAY_CHDEV           : all registered channel devices.
- * - DISPLAY_DQDT            : all DQDT nodes.
+ * - DISPLAY_DQDT            : all DQDT nodes curren values.
+ * - DISPLAY_BUSYLOCKS       : all busylocks taken by one thread.
+ * - DISPLAY_MAPPER          : one page of a given mapper.
  ******************************************************************************************
  * type      : [in] type of display 
  * arg0      : [in] type dependant argument.
  * arg1      : [in] type dependant argument.
+ * arg2      : [in] type dependant argument.
  * @ return 0 if success / return -1 if illegal arguments
  *****************************************************************************************/
 int sys_display( reg_t  type,
                  reg_t  arg0,
-                 reg_t  arg1 );
+                 reg_t  arg1,
+                 reg_t  arg2 );
 
 /******************************************************************************************