Changeset 204 for trunk/kernel/vfs


Ignore:
Timestamp:
Jul 17, 2017, 8:42:59 AM (5 years ago)
Author:
alain
Message:

Bug fix in kernel_init
-This line, and those below, will be ignored--

M params.mk
M kernel_config.h
M Makefile
M hdd/virt_hdd.dmg
M tools/bootloader_tsar/boot.c
M kernel/libk/bits.h
M kernel/libk/elf.c
M kernel/libk/xhtab.c
M kernel/libk/elf.h
M kernel/libk/xhtab.h
M kernel/devices/dev_pic.c
M kernel/mm/vmm.c
M kernel/mm/mapper.c
M kernel/mm/mapper.h
M kernel/vfs/devfs.h
M kernel/vfs/vfs.c
M kernel/vfs/vfs.h
M kernel/vfs/devfs.c
M kernel/kern/chdev.h
M kernel/kern/kernel_init.c
M kernel/kern/process.c
M kernel/kern/process.h
M hal/tsar_mips32/core/hal_remote.c
M hal/tsar_mips32/drivers/soclib_pic.c

Location:
trunk/kernel/vfs
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/vfs/devfs.c

    r188 r204  
    5353/////////////////////////////////////////////
    5454void devfs_ctx_init( devfs_ctx_t * devfs_ctx,
    55                      xptr_t        devfs_root_inode_xp,
     55                     xptr_t        devfs_dev_inode_xp,
    5656                     xptr_t        devfs_external_inode_xp )
    5757{
    58     devfs_ctx->root_inode_xp     = devfs_root_inode_xp;
     58    devfs_ctx->dev_inode_xp      = devfs_dev_inode_xp;
    5959    devfs_ctx->external_inode_xp = devfs_external_inode_xp;
    6060
     
    7474///////////////////////////////////////////////////
    7575void devfs_global_init( xptr_t   parent_inode_xp,
    76                         xptr_t * devfs_root_inode_xp,
     76                        xptr_t * devfs_dev_inode_xp,
    7777                        xptr_t * devfs_external_inode_xp )
    7878{
     
    8686                                     "dev",
    8787                                     NULL,
    88                                      devfs_root_inode_xp );
     88                                     devfs_dev_inode_xp );
    8989
    9090    nolock_assert( (error == 0) , __FUNCTION__ , "cannot create <dev>\n" );
     
    9494                                     INODE_TYPE_DIR,
    9595                                     FS_TYPE_DEVFS,
    96                                      *devfs_root_inode_xp,
    97                                      "dev",
     96                                     *devfs_dev_inode_xp,
     97                                     "external",
    9898                                     NULL,
    9999                                     devfs_external_inode_xp );
     
    102102}
    103103
    104 //////////////////////////////////////////////////
    105 void devfs_local_init( xptr_t devfs_root_inode_xp,
    106                        xptr_t devfs_external_inode_xp )
     104///////////////////////////////////////////////////
     105void devfs_local_init( xptr_t   devfs_dev_inode_xp,
     106                       xptr_t   devfs_external_inode_xp,
     107                       xptr_t * devfs_internal_inode_xp )
    107108{
    108109    char          node_name[16];
     
    110111    cxy_t         chdev_cxy;
    111112    xptr_t        inode_xp;
    112     xptr_t        internal_inode_xp;
    113113    uint32_t      channel;
    114114
     
    118118                             INODE_TYPE_DIR,
    119119                             FS_TYPE_DEVFS,
    120                              devfs_root_inode_xp,
     120                             devfs_dev_inode_xp,
    121121                             node_name,
    122122                             NULL,
    123                              &internal_inode_xp );
    124 
    125     // create ICU chdev inode
    126     chdev_xp = chdev_dir.icu[local_cxy];
    127     if( chdev_xp != XPTR_NULL) 
     123                             devfs_internal_inode_xp );
     124
     125    // create MMC chdev inode
     126    chdev_xp = chdev_dir.mmc[local_cxy];
     127    if( chdev_xp != XPTR_NULL)
    128128    {
    129129        vfs_add_child_in_parent( local_cxy,
    130130                                 INODE_TYPE_DEV,
    131131                                 FS_TYPE_DEVFS,
    132                                  internal_inode_xp,
    133                                  "icu",
    134                                  GET_PTR( chdev_xp ),
    135                                  &inode_xp );
    136     }
    137 
    138     // create MMC chdev inode
    139     chdev_xp = chdev_dir.mmc[local_cxy];
    140     if( chdev_xp != XPTR_NULL)
    141     {
    142         vfs_add_child_in_parent( local_cxy,
    143                                  INODE_TYPE_DEV,
    144                                  FS_TYPE_DEVFS,
    145                                  internal_inode_xp,
     132                                 *devfs_internal_inode_xp,
    146133                                 "mmc",
    147134                                 GET_PTR( chdev_xp ),
     
    159146                                     INODE_TYPE_DEV,
    160147                                     FS_TYPE_DEVFS,
    161                                      internal_inode_xp,
     148                                     *devfs_internal_inode_xp,
    162149                                     node_name,
    163150                                     GET_PTR( chdev_xp ),
  • trunk/kernel/vfs/devfs.h

    r188 r204  
    5151typedef struct devfs_ctx_s
    5252{
    53     xptr_t   root_inode_xp;              /*! extended pointer on DEVFS root inode       */
     53    xptr_t   dev_inode_xp;               /*! extended pointer on DEVFS root inode       */
    5454    xptr_t   external_inode_xp;          /*! extended pointer on DEVFS external inode   */
    5555}
     
    6969 *****************************************************************************************
    7070 * @ devfs_ctx               : local pointer on DEVFS context.
    71  * @ devfs_root_inode_xp     : [out] extended pointer on created <dev> inode.
    72  * @ devfs_external_inode_xp : [out] extended pointer on created <external> inode.
     71 * @ devfs_dev_inode_xp      : [out] extended pointer on <dev> inode.
     72 * @ devfs_external_inode_xp : [out] extended pointer on <external> inode.
    7373 ****************************************************************************************/
    7474void devfs_ctx_init( devfs_ctx_t * devfs_ctx,
    75                      xptr_t        devfs_root_inode_xp,
     75                     xptr_t        devfs_dev_inode_xp,
    7676                     xptr_t        devfs_external_inode_xp );
    7777
     
    9191 *****************************************************************************************
    9292 * @ parent_inode_xp         : extended pointer on the parent VFS inode.
    93  * @ devfs_root_inode_xp     : [out] extended pointer on created <dev> inode.
     93 * @ devfs_dev_inode_xp      : [out] extended pointer on created <dev> inode.
    9494 * @ devfs_external_inode_xp : [out] extended pointer on created <external> inode.
    9595 ****************************************************************************************/
    9696void devfs_global_init( xptr_t   parent_inode_xp,
    97                         xptr_t * devfs_root_inode_xp,
     97                        xptr_t * devfs_dev_inode_xp,
    9898                        xptr_t * devfs_external_inode_xp );
    9999
     
    108108 *    a pseudo-file, linked to the DEVFS "internal" parent directory.
    109109 *****************************************************************************************
    110  * @ devfs_root_inode_xp     : extended pointer on DEVFS root inode.
     110 * @ devfs_dev_inode_xp      : extended pointer on DEVFS root inode.
    111111 * @ devfs_external_inode_xp : extended pointer on DEVFS external inode.
     112 * @ devfs_internal_inode_xp : [out] extended pointer on created <internal> inode.
    112113 ****************************************************************************************/
    113 void devfs_local_init( xptr_t devfs_root_inode_xp,
    114                        xptr_t devfs_external_inode_xp );
     114void devfs_local_init( xptr_t   devfs_dev_inode_xp,
     115                       xptr_t   devfs_external_inode_xp,
     116                       xptr_t * devfs_internal_inode_xp );
    115117                       
    116118#endif  /* _DEVFS_H_ */
  • trunk/kernel/vfs/vfs.c

    r188 r204  
    215215    xlist_root_init( XPTR( local_cxy , &inode->wait_root ) );
    216216
    217     // initialize dentries hash table, if new inode is a directory
    218     if( inode_type == INODE_TYPE_DIR ) xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );
     217    // initialize dentries hash table
     218    xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );
    219219
    220220    // initialize inode locks
     
    329329}
    330330
    331 //////////////////////////////////////////////////////////////////////////////////////////
     331/////////////////////////////////////////
     332void vfs_inode_display( xptr_t inode_xp )
     333{
     334    cxy_t          inode_cxy;
     335    vfs_inode_t  * inode_ptr;
     336    xptr_t         dentry_xp;
     337    cxy_t          dentry_cxy;
     338    vfs_dentry_t * dentry_ptr;
     339   
     340    char           name[CONFIG_VFS_MAX_NAME_LENGTH];
     341
     342    // get inode cluster and local pointer
     343    inode_cxy = GET_CXY( inode_xp );
     344    inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
     345
     346    // get parent dentry
     347    dentry_xp  = hal_remote_lwd( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
     348
     349    // get local copy of name
     350    if( dentry_xp == XPTR_NULL )  // it is the VFS root
     351    {
     352        strcpy( name , "/" );
     353    }
     354    else                          // not the VFS root
     355    {
     356        dentry_cxy = GET_CXY( dentry_xp );
     357        dentry_ptr = (vfs_dentry_t *)GET_PTR( dentry_xp );
     358
     359        hal_remote_strcpy( XPTR( local_cxy  , name ) ,
     360                           XPTR( dentry_cxy , &dentry_ptr->name ) );
     361    }
     362
     363    // display inode header
     364    printk("\n*** inode <%s> / inode_xp = %l / dentry_xp = %l ***\n",
     365           name , inode_xp , dentry_xp );
     366
     367    // display children from xhtab
     368    xhtab_display( XPTR( inode_cxy , &inode_ptr->children ) );
     369
     370}  // end vfs_inode_display()
     371
     372////////////////////////////////////////////////////////////////////////////////////////////
    332373//           Dentry related functions
    333374//////////////////////////////////////////////////////////////////////////////////////////
     
    509550
    510551    vfs_dmsg("\n[INFO] %s : enters for <%s> at cycle %d\n",
    511              __FUNCTION__ , path , hal_get_cycles() );
     552             __FUNCTION__ , path , (uint32_t)hal_time_stamp() );
    512553
    513554    // compute lookup working mode
     
    619660    else if (inode_type == INODE_TYPE_DEV )
    620661    {
    621         // TODO
     662        // TODO  [AG]
    622663        return 0;
    623664    }
     
    628669        return -1;
    629670    }
    630 }  // end vfs_access()
     671}  // end vfs_move()
    631672
    632673//////////////////////////////////////
     
    857898static void vfs_recursive_display( xptr_t   inode_xp,
    858899                                   xptr_t   name_xp,
     900                                   xptr_t   dentry_xp,
    859901                                   uint32_t indent )
    860902{
     
    862904    vfs_inode_t      * inode_ptr;
    863905    vfs_inode_type_t   inode_type;
    864     xptr_t             inode_children_xp;    // extended pointer on children xhtab
    865 
    866     xptr_t             dentry_xp;
    867     cxy_t              dentry_cxy;
    868     vfs_dentry_t     * dentry_ptr;
     906    xptr_t             children_xp;    // extended pointer on children xhtab
     907
     908    xptr_t             child_dentry_xp;
     909    cxy_t              child_dentry_cxy;
     910    vfs_dentry_t     * child_dentry_ptr;
     911    xptr_t             child_inode_xp;
     912    xptr_t             child_dentry_name_xp;
    869913
    870914    char               name[CONFIG_VFS_MAX_NAME_LENGTH];
    871 
    872     xptr_t             child_inode_xp;
    873     xptr_t             dentry_name_xp;
    874915
    875916    char *             indent_str[] = { "",                                  // level 0
     
    905946
    906947    // display inode
    907     printk(" %s %s : %s\n", indent_str[indent], vfs_inode_type_str( inode_type ), name );
     948    printk("%s%s <%s> inode_xp = %l / dentry_xp = %l\n",
     949           indent_str[indent], vfs_inode_type_str( inode_type ),
     950           name , inode_xp , dentry_xp );
    908951
    909952    // scan directory entries 
     
    911954    {
    912955        // get extended pointer on directory entries xhtab
    913         inode_children_xp = hal_remote_lwd( XPTR( inode_cxy , &inode_ptr->children ) );
     956        children_xp =  XPTR( inode_cxy , &inode_ptr->children );
    914957
    915958        // get xhtab lock
    916         xhtab_read_lock( inode_children_xp );
     959        xhtab_read_lock( children_xp );
    917960
    918961        // get first dentry from xhtab
    919         dentry_xp = xhtab_get_first( inode_children_xp );
    920 
    921         while( dentry_xp != XPTR_NULL )
     962        child_dentry_xp = xhtab_get_first( children_xp );
     963
     964        while( child_dentry_xp != XPTR_NULL )
    922965        {
    923966            // get dentry cluster and local pointer
    924             dentry_cxy = GET_CXY( dentry_xp );
    925             dentry_ptr = (vfs_dentry_t *)GET_PTR( dentry_xp );
     967            child_dentry_cxy = GET_CXY( child_dentry_xp );
     968            child_dentry_ptr = (vfs_dentry_t *)GET_PTR( child_dentry_xp );
    926969
    927970            // get extended pointer on child inode
    928             child_inode_xp = hal_remote_lwd( XPTR( dentry_cxy , &dentry_ptr->child_xp ) );
     971            child_inode_xp = hal_remote_lwd( XPTR( child_dentry_cxy,
     972                                                   &child_dentry_ptr->child_xp ) );
    929973
    930974            // get extended pointer on dentry name
    931             dentry_name_xp = XPTR( dentry_cxy , &dentry_ptr->name );
     975            child_dentry_name_xp = XPTR( child_dentry_cxy , &child_dentry_ptr->name );
    932976
    933977            // recursive call on child inode
    934             vfs_recursive_display( child_inode_xp , dentry_name_xp , indent+1 );
     978            vfs_recursive_display( child_inode_xp,
     979                                   child_dentry_name_xp,
     980                                   child_dentry_xp,
     981                                   indent+1 );
    935982
    936983            // get next dentry
    937             dentry_xp = xhtab_get_next( inode_children_xp );
     984            child_dentry_xp = xhtab_get_next( children_xp );
    938985        }
    939986
    940987        // release xhtab lock
    941         xhtab_read_unlock( inode_children_xp );
     988        xhtab_read_unlock( children_xp );
    942989    }
    943990}  // end vfs_recursive_display()
     
    946993void vfs_display( xptr_t inode_xp )
    947994{
    948     xptr_t         name_xp;      // extended pointer on string containing the inode name
     995    xptr_t         name_xp;
    949996    xptr_t         dentry_xp;
    950997    cxy_t          dentry_cxy;
    951998    vfs_dentry_t * dentry_ptr;
    952999
    953 printk("\n@@@ %s enters\n", __FUNCTION__ );
    954 
    9551000    // get target inode cluster and local pointer
    9561001    cxy_t         inode_cxy = GET_CXY( inode_xp );
     
    9771022
    9781023    // print header
    979     printk("\n*** Current VFS content ***\n");
     1024    printk("\n*** VFS ***\n");
    9801025
    9811026    // call recursive function
    982     vfs_recursive_display( inode_xp , name_xp , 0 );
    983 
    984 }  // end vfs_diplay()
     1027    vfs_recursive_display( inode_xp , name_xp , dentry_xp , 0 );
     1028
     1029}  // end vfs_display()
    9851030
    9861031//////////////////////////////////////////////////////////////////////////////////////////
     
    10151060//////////////////////////////////////////////////////////////////////////////////////////
    10161061// This static function is used by the vfs_lookup() function.
    1017 // It takes an extended pointer on a remote inode (parent directory inode), a directory
     1062// It takes an extended pointer on a remote parent directory inode, a directory
    10181063// entry name, and returns an extended pointer on the child inode.
    10191064// It can be used by any thread running in any cluster.
     
    10501095    *child_xp = (xptr_t)hal_remote_lwd( XPTR( dentry_cxy , &dentry_ptr->child_xp ) );
    10511096    return true;
    1052 }
     1097
     1098}  // end vfs_get_child()
    10531099
    10541100//////////////////////////////////////////////////////////////////////////////////////////
     
    10831129    while( (*ptr != 0) && (*ptr !='/') )  *(name++) = *(ptr++);
    10841130
     1131    // set NUL terminating character in name buffer
     1132    *(name++) = 0;
     1133
    10851134    // return last an next
    10861135    if( *ptr == 0 )             // last found character is NUL => last name in path
     
    10951144
    10961145    return 0;
    1097 }
     1146
     1147}  // end vfs_get name_from_path()
    10981148   
    10991149//////////////////////////////////////////////
     
    11221172    error_t            error;
    11231173
    1124     vfs_dmsg("\n[INFO] %s : enters for <%s>\n",
    1125              __FUNCTION__ , pathname );
     1174    vfs_dmsg("\n[INFO] %s : enters for <%s> at cycle %d\n",
     1175             __FUNCTION__ , pathname , (uint32_t)hal_time_stamp() );
    11261176
    11271177    this    = CURRENT_THREAD;
     
    11421192
    11431193    // load from device if one intermediate node not found
    1144     // exit when last name found (i.e. last == true)
     1194    // exit while loop when last name found (i.e. last == true)
    11451195    do
    11461196    {
     
    11481198        vfs_get_name_from_path( current , name , &next , &last );
    11491199
    1150         vfs_dmsg("\n[INFO] %s : looking for node <%s> / last = %d\n",
     1200        vfs_dmsg("\n[INFO] %s : looking for <%s> / last = %d\n",
    11511201                 __FUNCTION__ , name , last );
    11521202
    1153         // search a child dentry matching name for parent inode
     1203        // search a child dentry matching name in parent inode
    11541204        found = vfs_get_child( parent_xp,
    11551205                               name,
     
    11581208        if( found == false ) // child inode not found in inode tree => try to load it
    11591209        {
    1160             vfs_dmsg("\n[INFO] %s : node <%s> not found, try to load it\n",
     1210            vfs_dmsg("\n[INFO] %s : <%s> not found, try to load it\n",
    11611211                     __FUNCTION__ , name );
    11621212
     
    11681218            parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
    11691219
     1220            // get local pointer on parent inode context
     1221            ctx_ptr = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
     1222
    11701223            // get parent inode FS type
    1171             ctx_ptr = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
    1172             fs_type = ctx_ptr->type;
     1224            fs_type = hal_remote_lw( XPTR( parent_cxy , &ctx_ptr->type ) );
    11731225
    11741226            // get child inode type
     
    11791231            cxy_t child_cxy = vfs_cluster_random_select();
    11801232                     
     1233printk("\n@@@ name not found : <%s>\n", name );
     1234
    11811235            // insert a new child dentry/inode in parent inode
    11821236            error = vfs_add_child_in_parent( child_cxy,
     
    11871241                                             name,
    11881242                                             &child_xp );
    1189 
    11901243            if( error )
    11911244            {
     
    11991252        }
    12001253
    1201         vfs_dmsg("\n[INFO] %s : node <%s> found / parent = %l / child = %l / last = %d\n",
     1254vfs_inode_display( child_xp );
     1255
     1256vfs_display( parent_xp );
     1257
     1258        vfs_dmsg("\n[INFO] %s : found <%s> / parent = %l / child = %l / last = %d\n",
    12021259                 __FUNCTION__ , name , parent_xp , child_xp , last );
    12031260
     
    13341391    parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
    13351392
    1336     // get parent inode context local pointer
    1337     parent_ctx = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
    1338 
    1339     // create dentry
     1393    // 1. create dentry
    13401394    if( parent_cxy == local_cxy )      // parent cluster is the local cluster
    13411395    {
     
    13591413        printk("\n[ERROR] in %s : cannot create dentry in cluster %x\n",
    13601414               __FUNCTION__ , parent_cxy );
    1361         return error;
    1362     }
    1363 
    1364     // create child inode TODO : define attr / mode / uid / gid
     1415        return ENOMEM;
     1416    }
     1417
     1418    // 2. create child inode TODO : define attr / mode / uid / gid
    13651419    uint32_t attr = 0;
    13661420    uint32_t mode = 0;
     
    14031457        if( parent_cxy == local_cxy ) vfs_dentry_destroy( dentry );
    14041458        else rpc_vfs_dentry_destroy_client( parent_cxy , dentry );
    1405         return error;
    1406     }
     1459        return ENOMEM;
     1460    }
     1461
     1462    // 3. update extended pointer on inode in dentry
     1463    cxy_t          dentry_cxy = GET_CXY( dentry_xp );
     1464    vfs_dentry_t * dentry_ptr = (vfs_dentry_t *)GET_PTR( dentry_xp );
     1465    hal_remote_swd( XPTR( dentry_cxy , &dentry_ptr->child_xp ) , inode_xp );
    14071466
    14081467    // success : return extended pointer on child inode
     
    14221481error_t vfs_move_page_to_mapper( page_t * page )
    14231482{
    1424     error_t         error = 0;
     1483    error_t error = 0;
    14251484
    14261485    assert( (page != NULL) , __FUNCTION__ , "page pointer is NULL\n" );
  • trunk/kernel/vfs/vfs.h

    r188 r204  
    450450
    451451/******************************************************************************************
     452 * This debug function diplays the name of the inode identified by the <inode_xp>
     453 * argument, and all children names for a directory.
     454 *****************************************************************************************
     455 * @ inode_xp  : extended pointer on the remote inode.
     456 *****************************************************************************************/
     457void vfs_inode_display( xptr_t inode_xp );
     458
     459
     460
     461
     462
     463
     464/******************************************************************************************
    452465 * This function TODO                                                         
    453466 *****************************************************************************************/
     
    617630 * It can be executed by any thread running in any cluster, as this function
    618631 * uses the rpc_dentry_create_client() and rpc_inode_create client() if required.
    619  * - The dentry is created in the cluster containing the existing <parent_xp> inode.
    620  * - the inode and its associated mapper are created in cluster identified by <child_cxy>.
    621  * - The new dentry name is defined by the <name> argument.
    622  * - The new inode and the parent inode can have different FS types.
     632 * This is done in three steps:
     633 * 1) The dentry is created in the cluster containing the existing <parent_xp> inode.
     634 *    The new dentry name is defined by the <name> argument.
     635 * 2) The inode and its associated mapper are created in cluster identified by <child_cxy>.
     636 *    The new inode and the parent inode can have different FS types.
     637 * 3) The "child_xp" field in created dentry (pointing on thecreated inode) is updated.
    623638 ******************************************************************************************
    624639 * @ child_cxy  : target cluster for child inode.
     
    629644 * @ extend     : fs_type_specific inode extension.
    630645 * @ child_xp   : [out] buffer for extended pointer on child inode.
    631  * @ return 0 if success / ENOENT if entry not found in parent directory
     646 * @ return 0 if success / ENOMEM if dentry or inode cannot be created.
    632647 *****************************************************************************************/
    633648error_t vfs_add_child_in_parent( cxy_t              child_cxy,
Note: See TracChangeset for help on using the changeset viewer.