Changeset 204 for trunk/kernel/vfs/vfs.c


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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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" );
Note: See TracChangeset for help on using the changeset viewer.