Changeset 614 for trunk/kernel/fs


Ignore:
Timestamp:
Jan 15, 2019, 1:59:32 PM (6 years ago)
Author:
alain
Message:

1) introduce a dev_ioc_sync_write() function in IOC API,

to improve the DEVFS synchronous update.

2) fix a big bug in both the user_dir_create() and user_dir_destroy()

functions: add an extended pointer on the reference client process
in the function's arguments.

Location:
trunk/kernel/fs
Files:
5 edited

Legend:

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

    r612 r614  
    110110assert( (error == 0) , "cannot create <dev>\n" );
    111111
    112 #if DEBUG_DEVFS_INIT
     112#if DEBUG_DEVFS_GLOBAL_INIT
    113113uint32_t   cycle = (uint32_t)hal_get_cycles();
    114114thread_t * this  = CURRENT_THREAD;
    115 if( DEBUG_DEVFS_INIT < cycle )
     115if( DEBUG_DEVFS_GLOBAL_INIT < cycle )
    116116printk("\n[%s] thread[%x,%x] created <dev> inode / cycle %d\n",
    117117__FUNCTION__, this->process->pid, this->trdid, cycle );
     
    134134assert( (error == 0) , "cannot create <external>\n" );
    135135
    136 #if DEBUG_DEVFS_INIT
    137 cycle = (uint32_t)hal_get_cycles();
    138 if( DEBUG_DEVFS_INIT < cycle )
     136#if DEBUG_DEVFS_GLOBAL_INIT
     137cycle = (uint32_t)hal_get_cycles();
     138if( DEBUG_DEVFS_GLOBAL_INIT < cycle )
    139139printk("\n[%s] thread[%x,%x] created <external> inode / cycle %d\n",
    140140__FUNCTION__, this->process->pid, this->trdid, cycle );
     
    159159    error_t       error;
    160160
     161#if DEBUG_DEVFS_LOCAL_INIT
     162uint32_t   cycle = (uint32_t)hal_get_cycles();
     163thread_t * this  = CURRENT_THREAD;
     164if( DEBUG_DEVFS_LOCAL_INIT < cycle )
     165printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
     166__FUNCTION__, this->process->pid, this->trdid, cycle );
     167#endif
     168
    161169    // create "internal" directory
    162170    snprintf( node_name , 16 , "internal_%x" , local_cxy );
     
    177185assert( (error == 0) , "cannot create <external>\n" );
    178186
    179 #if DEBUG_DEVFS_INIT
    180 uint32_t   cycle = (uint32_t)hal_get_cycles();
    181 thread_t * this  = CURRENT_THREAD;
    182 if( DEBUG_DEVFS_INIT < cycle )
     187#if DEBUG_DEVFS_LOCAL_INIT
     188cycle = (uint32_t)hal_get_cycles();
     189if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    183190printk("\n[%s] thread[%x,%x] created <%s> inode in cluster %x / cycle %d\n",
    184191__FUNCTION__, this->process->pid, this->trdid, node_name, local_cxy, cycle );
     
    209216        hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
    210217       
    211 #if DEBUG_DEVFS_INIT
    212 cycle = (uint32_t)hal_get_cycles();
    213 if( DEBUG_DEVFS_INIT < cycle )
     218#if DEBUG_DEVFS_LOCAL_INIT
     219cycle = (uint32_t)hal_get_cycles();
     220if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    214221printk("\n[%s] thread[%x,%x] created <mmc> inode in cluster %x\n",
    215222__FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
     
    244251            hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
    245252       
    246 #if DEBUG_DEVFS_INIT
    247 cycle = (uint32_t)hal_get_cycles();
    248 if( DEBUG_DEVFS_INIT < cycle )
     253#if DEBUG_DEVFS_LOCAL_INIT
     254cycle = (uint32_t)hal_get_cycles();
     255if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    249256printk("\n[%s] thread [%x,%x] created <dma[%d]> inode in cluster %x\n",
    250257__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
     
    277284            hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
    278285       
    279 #if DEBUG_DEVFS_INIT
    280 cycle = (uint32_t)hal_get_cycles();
    281 if( DEBUG_DEVFS_INIT < cycle )
     286#if DEBUG_DEVFS_LOCAL_INIT
     287cycle = (uint32_t)hal_get_cycles();
     288if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    282289printk("\n[%s] thread[%x,%x] created <iob> inode in cluster %x\n",
    283290__FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
     
    310317            hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
    311318       
    312 #if DEBUG_DEVFS_INIT
    313 cycle = (uint32_t)hal_get_cycles();
    314 if( DEBUG_DEVFS_INIT < cycle )
     319#if DEBUG_DEVFS_LOCAL_INIT
     320cycle = (uint32_t)hal_get_cycles();
     321if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    315322printk("\n[%s] thread[%x,%x] created <pic> inode in cluster %x\n",
    316323__FUNCTION__, this->process->pid, this->trdid, local_cxy, cycle );
     
    345352                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
    346353       
    347 #if DEBUG_DEVFS_INIT
    348 cycle = (uint32_t)hal_get_cycles();
    349 if( DEBUG_DEVFS_INIT < cycle )
     354#if DEBUG_DEVFS_LOCAL_INIT
     355cycle = (uint32_t)hal_get_cycles();
     356if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    350357printk("\n[%s] thread[%x,%x] created <txt_rx[%d]> inode in cluster %x\n",
    351358__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
     
    381388                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
    382389       
    383 #if DEBUG_DEVFS_INIT
    384 cycle = (uint32_t)hal_get_cycles();
    385 if( DEBUG_DEVFS_INIT < cycle )
     390#if DEBUG_DEVFS_LOCAL_INIT
     391cycle = (uint32_t)hal_get_cycles();
     392if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    386393printk("\n[%s] thread[%x,%x] created <txt_tx[%d]> inode in cluster %x\n",
    387394__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
     
    417424                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
    418425       
    419 #if DEBUG_DEVFS_INIT
    420 cycle = (uint32_t)hal_get_cycles();
    421 if( DEBUG_DEVFS_INIT < cycle )
     426#if DEBUG_DEVFS_LOCAL_INIT
     427cycle = (uint32_t)hal_get_cycles();
     428if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    422429printk("\n[%s] thread[%x,%x] created <ioc[%d]> inode in cluster %x\n",
    423430__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
     
    453460                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
    454461       
    455 #if DEBUG_DEVFS_INIT
    456 cycle = (uint32_t)hal_get_cycles();
    457 if( DEBUG_DEVFS_INIT < cycle )
     462#if DEBUG_DEVFS_LOCAL_INIT
     463cycle = (uint32_t)hal_get_cycles();
     464if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    458465printk("\n[%s] thread[%x,%x] created <fbf[%d]> inode in cluster %x\n",
    459466__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
     
    489496                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
    490497 
    491 #if DEBUG_DEVFS_INIT
    492 cycle = (uint32_t)hal_get_cycles();
    493 if( DEBUG_DEVFS_INIT < cycle )
     498#if DEBUG_DEVFS_LOCAL_INIT
     499cycle = (uint32_t)hal_get_cycles();
     500if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    494501printk("\n[%s] thread[%x,%x] created <nic_rx[%d]> inode in cluster %x\n",
    495502__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
     
    525532                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
    526533       
    527 #if DEBUG_DEVFS_INIT
    528 cycle = (uint32_t)hal_get_cycles();
    529 if( DEBUG_DEVFS_INIT < cycle )
     534#if DEBUG_DEVFS_LOCAL_INIT
     535cycle = (uint32_t)hal_get_cycles();
     536if( DEBUG_DEVFS_LOCAL_INIT < cycle )
    530537printk("\n[%s] thread[%x,%x] created <nic_tx[%d]> inode in cluster %x\n",
    531538__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
  • trunk/kernel/fs/fatfs.c

    r612 r614  
    10641064        {
    10651065            // copy the modified page to IOC device
    1066             fatfs_move_page( page_xp , false );   
     1066            fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
    10671067
    10681068            // get the next page in FAT mapper
     
    12171217
    12181218    // copy the modified page to the IOC device
    1219     fatfs_move_page( page_xp , false );   
     1219    fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
    12201220
    12211221#if DEBUG_FATFS_ADD_DENTRY
    12221222cycle = (uint32_t)hal_get_cycles();
    12231223if( DEBUG_FATFS_ADD_DENTRY < cycle )
    1224 printk("\n[%s]  thread[%x,%x] exit / parent %s / child %s / cycle %d\n",
     1224printk("\n[%s]  thread[%x,%x] exit / parent <%s> / child <%s> / cycle %d\n",
    12251225__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
    12261226#endif
     
    13131313
    13141314            // copy the modified page to the IOC device
    1315             fatfs_move_page( page_xp , false );   
     1315            fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
    13161316
    13171317            // get extended pointer on page descriptor from parent directory mapper
     
    13451345
    13461346    // copy the modified page to the IOC device
    1347     fatfs_move_page( page_xp , false );   
     1347    fatfs_move_page( page_xp , IOC_SYNC_WRITE );   
    13481348   
    13491349
     
    13961396    xptr_t     base_xp;          // extended pointer on page base
    13971397    uint8_t  * base;             // local pointer on page base
    1398     uint32_t   attr;             // directory entry ATTR field
    1399     uint32_t   ord;              // directory entry ORD field
     1398    uint8_t    attr;             // directory entry ATTR field
     1399    uint8_t    ord;              // directory entry ORD field
    14001400    uint32_t   seq;              // sequence index
    14011401    uint32_t   lfn       = 0;    // LFN entries number
     
    14221422#if (DEBUG_FATFS_GET_DENTRY & 0x1)
    14231423if( DEBUG_FATFS_GET_DENTRY < cycle )
    1424 mapper_display_page( mapper_xp , page_id , 256 , parent_name );
     1424mapper_display_page( mapper_xp , page_id , 256 );
    14251425#endif
    14261426        // scan this page until end of directory, end of page, or name found
     
    14351435            }
    14361436            else if ( ord == FREE_ENTRY )             // free entry => skip
     1437            {
     1438                offset = offset + 32;
     1439            }
     1440            else if ( attr == 0x28 )                  // volune_id => skip
    14371441            {
    14381442                offset = offset + 32;
     
    15771581assert( (detailed == false), "detailed argument not supported/n");
    15781582
    1579     char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracter from each directory entry
     1583    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracted from each dentry
    15801584
    15811585    char       lfn1[16];           // buffer for one partial cname
     
    15851589    xptr_t     base_xp;            // extended pointer on page base
    15861590    uint8_t  * base;               // local pointer on page base
    1587     uint32_t   attr;               // directory entry ATTR field
    1588     uint32_t   ord;                // directory entry ORD field
     1591    uint8_t    attr;               // directory entry ATTR field
     1592    uint8_t    ord;                // directory entry ORD field
    15891593    uint32_t   seq;                // sequence index
    15901594    uint32_t   lfn       = 0;      // LFN entries number
     
    16091613#if (DEBUG_FATFS_GET_USER_DIR & 0x1)
    16101614if( DEBUG_FATFS_GET_USER_DIR < cycle )
    1611 mapper_display_page( mapper_xp , page_id , 256 , inode_name );
     1615mapper_display_page( mapper_xp , page_id , 256 );
    16121616#endif
    16131617        // loop on NORMAL/LFN (32 bytes) directory entries in this page
     
    16251629            }
    16261630            else if ( ord == FREE_ENTRY )             // free entry => skip
     1631            {
     1632                offset = offset + 32;
     1633            }
     1634            else if ( attr == 0x28 )                  // volune_id => skip
    16271635            {
    16281636                offset = offset + 32;
     
    16931701if( DEBUG_FATFS_GET_USER_DIR < cycle )
    16941702printk("\n[%s]  thread[%x,%x] exit for inode <%s> / %d entries / cycle %d\n",
    1695 __FUNCTION__, this->process->pid, this->trdid, inode_name, entries, cycle );
     1703__FUNCTION__, this->process->pid, this->trdid, inode_name, dirent_id, cycle );
    16961704#endif
    16971705
     
    17561764
    17571765                // move page from mapper to device
    1758                 error = fatfs_move_page( page_xp , false );
     1766                error = fatfs_move_page( page_xp , IOC_WRITE );
    17591767
    17601768                if ( error )  return -1;
     
    18271835#endif
    18281836                // move page from mapper to device
    1829                 error = fatfs_move_page( page_xp , false );
     1837                error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
    18301838
    18311839                if ( error )  return -1;
     
    21322140}  // end fatfs_release_inode()
    21332141
    2134 /////////////////////////////////////////
    2135 error_t fatfs_move_page( xptr_t  page_xp,
    2136                          bool_t  to_mapper )
     2142////////////////////////////////////////////
     2143error_t fatfs_move_page( xptr_t     page_xp,
     2144                         cmd_type_t cmd_type )
    21372145{
    21382146    error_t       error;
     
    21722180 
    21732181        // access device
    2174         if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , 8 );
    2175         else            error = dev_ioc_write( buffer , lba , 8 );     
     2182        if     ( cmd_type == IOC_SYNC_READ  ) error = dev_ioc_sync_read ( buffer , lba , 8 );
     2183        else if( cmd_type == IOC_SYNC_WRITE ) error = dev_ioc_sync_write( buffer , lba , 8 );
     2184        else if( cmd_type == IOC_READ       ) error = dev_ioc_read      ( buffer , lba , 8 );
     2185        else if( cmd_type == IOC_WRITE      ) error = dev_ioc_write     ( buffer , lba , 8 );
     2186        else                                  error = -1;
    21762187
    21772188        if( error ) return EIO;
     
    21792190#if (DEBUG_FATFS_MOVE_PAGE & 0x1)
    21802191if( DEBUG_FATFS_MOVE_PAGE < cycle )
    2181 mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id , "FAT" );
     2192mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id );
    21822193#endif
    21832194
     
    21862197if( DEBUG_FATFS_MOVE_PAGE < cycle )
    21872198{
    2188     if (to_mapper)
     2199    if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
    21892200         printk("\n[%s] thread[%x,%x] load page %d of FAT / cycle %d\n",
    21902201         __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
     
    22302241
    22312242        // access device
    2232         if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , 8 );
    2233         else            error = dev_ioc_write( buffer , lba , 8 );     
     2243        if     ( cmd_type == IOC_SYNC_READ  ) error = dev_ioc_sync_read ( buffer , lba , 8 );
     2244        else if( cmd_type == IOC_SYNC_WRITE ) error = dev_ioc_sync_write( buffer , lba , 8 );
     2245        else if( cmd_type == IOC_READ       ) error = dev_ioc_read      ( buffer , lba , 8 );
     2246        else if( cmd_type == IOC_WRITE      ) error = dev_ioc_write     ( buffer , lba , 8 );
     2247        else                                  error = -1;
    22342248
    22352249        if( error ) return EIO;
     
    22372251#if (DEBUG_FATFS_MOVE_PAGE & 0x1)
    22382252if( DEBUG_FATFS_MOVE_PAGE < cycle )
    2239 char string[CONFIG_VFS_MAX_NAME_LENGTH];
    2240 vfs_inode_get_name( XPTR(page_cxy , inode_ptr) , string );
    2241 mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id , string );
     2253mapper_display_page( XPTR(page_cxy , mapper_ptr) , page_id );
    22422254#endif
    22432255
     
    22462258if(DEBUG_FATFS_MOVE_PAGE < cycle)
    22472259{
    2248     if(to_mapper)
     2260    if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
    22492261        printk("\n[%s] thread[%x,%x] load page %d of <%s> inode / cycle %d\n",
    22502262        __FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
  • trunk/kernel/fs/fatfs.h

    r612 r614  
    2929#include <remote_queuelock.h>
    3030#include <vfs.h>
     31#include <dev_ioc.h>
    3132
    3233
     
    365366 * and copies from mapper to device each page marked as dirty.
    366367 * WARNING : The target <inode> cannot be a directory, because all modifications in a
    367  * directory * are synchronously done on the IOC device by the two fatfs_add_dentry()
     368 * directory are synchronously done on the IOC device by the two fatfs_add_dentry()
    368369 * and fatfs_remove_dentry() functions.
    369370 *****************************************************************************************
     
    451452 *****************************************************************************************
    452453 * @ page_xp   : extended pointer on page descriptor.
    453  * @ to_mapper : true for device->mapper / false for mapper->device
     454 * @ cmd_type  : IOC_READ / IOC_WRITE / IOC_SYNC_READ / IOC_SYNC_WRITE
    454455 * @ return 0 if success / return EIO if error during device access.
    455456 ****************************************************************************************/
    456 error_t fatfs_move_page( xptr_t  page_xp,
    457                          bool_t  to_mapper );
     457error_t fatfs_move_page( xptr_t      page_xp,
     458                         cmd_type_t  cmd_type );
    458459
    459460
  • trunk/kernel/fs/vfs.c

    r612 r614  
    424424uint32_t cycle = (uint32_t)hal_get_cycles();
    425425if( DEBUG_VFS_DENTRY_CREATE < cycle )
    426 printk("\n[%s] thread[%x,%x] enter for <%s> / parent_inode %x / cycle %d\n",
    427 __FUNCTION__, this->process->pid, this->trdid, name, parent, cycle );
     426printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
     427__FUNCTION__, this->process->pid, this->trdid, name, cycle );
    428428#endif
    429429
     
    19461946
    19471947    // display inode
    1948     nolock_printk("%s%s <%s> : inum %d / %d bytes / dirty %d / cxy %x (inode %x / mapper %x)\n",
    1949                   indent_str[indent], vfs_inode_type_str( inode_type ), name,
     1948    nolock_printk("%s<%s> : %s / inum %d / %d bytes / dirty %d / cxy %x / inode %x / mapper %x\n",
     1949                  indent_str[indent], name, vfs_inode_type_str( inode_type ),
    19501950                  inode_inum, inode_size, inode_dirty, inode_cxy, inode_ptr, mapper_ptr );
    19511951
     
    31913191//////////////////////////////////////////////////////////////////////////////////////////
    31923192
    3193 ///////////////////////////////////////////
    3194 error_t vfs_fs_move_page( xptr_t   page_xp,
    3195                           bool_t   to_mapper )
     3193//////////////////////////////////////////////
     3194error_t vfs_fs_move_page( xptr_t      page_xp,
     3195                          cmd_type_t  cmd_type )
    31963196{
    31973197    error_t error = 0;
     
    32133213    if( fs_type == FS_TYPE_FATFS )
    32143214    {
    3215         error = fatfs_move_page( page_xp , to_mapper );
     3215        error = fatfs_move_page( page_xp , cmd_type );
    32163216    }
    32173217    else if( fs_type == FS_TYPE_RAMFS )
  • trunk/kernel/fs/vfs.h

    r612 r614  
    4141#include <ramfs.h>
    4242#include <devfs.h>
     43#include <dev_ioc.h>
    4344
    4445/****  Forward declarations  ***/
     
    408409 * It must called by a local thread. Use the RPC_DENTRY_CREATE if client thread is remote.
    409410 ******************************************************************************************
    410  * @ fs_type    : file system type.
    411  * @ name       : directory entry file/dir name.
     411 * @ fs_type    : [in]  file system type.
     412 * @ name       : [in]  directory entry file/dir name.
    412413 * @ dentry_xp  : [out] buffer for extended pointer on created dentry.
    413414 * @ return 0 if success / return ENOMEM or EINVAL if error.
     
    421422 * allocated to the dentry descriptor.
    422423 * It must be executed by a thread running in the cluster containing the dentry.
    423  * Use the rpc_vfs_dentry_destroy_client() function if required.
     424 * Use the RPC_DENTRY_DESTROY if required.
    424425 ******************************************************************************************
    425  * @ dentry  : local pointer on dentry descriptor.
     426 * @ dentry  : [in] local pointer on dentry descriptor.
    426427 *****************************************************************************************/
    427428void vfs_dentry_destroy( vfs_dentry_t *  dentry ); 
     
    875876
    876877/******************************************************************************************
     878 * This function makes the I/O operation to move one page identified by the <page_xp>
     879 * argument to/from the IOC device from/to the mapper, as defined by <cmd_type>.
     880 * Depending on the file system type, it calls the proper, FS specific function.
     881 * It is used in case of MISS on the mapper, or when a dirty page in the mapper must
     882 * be updated in the File System.
     883 * The mapper pointer is obtained from the page descriptor.
     884 * It can be executed by any thread running in any cluster.
     885 * This function does NOT take any lock.
     886 ******************************************************************************************
     887 * @ page_xp   : extended pointer on page descriptor (for mapper and page_id).
     888 * @ cmd_type  : IOC_READ / IOC_WRITE / IOC_SYNC_READ / IOC_SYNC_WRITE
     889 * @ returns 0 if success / return -1 if device access failure.
     890 *****************************************************************************************/
     891error_t vfs_fs_move_page( xptr_t      page_xp,
     892                          cmd_type_t  cmd_type );
     893
     894/******************************************************************************************
    877895 * This function updates the mapper associated to a directory inode identified by the
    878896 * <parent> argument, to add a new entry identified by the <dentry> argument.
     
    10321050error_t vfs_fs_release_inode( xptr_t  inode_xp );
    10331051
    1034 /******************************************************************************************
    1035  * This function makes the I/O operation to move one page identified by the <page_xp>
    1036  * argument to/from the IOC device from/to the mapper, as defined by <to_mapper>.
    1037  * Depending on the file system type, it calls the proper, FS specific function.
    1038  * It is used in case of MISS on the mapper, or when a dirty page in the mapper must
    1039  * be updated in the File System.
    1040  * The mapper pointer is obtained from the page descriptor.
    1041  * It can be executed by any thread running in any cluster.
    1042  * This function does NOT take any lock.
    1043  ******************************************************************************************
    1044  * @ page_xp   : extended pointer on the page descriptor.
    1045  * @ to_mapper : transfer direction.
    1046  * @ returns 0 if success / return -1 if device access failure.
    1047  *****************************************************************************************/
    1048 error_t vfs_fs_move_page( xptr_t  page_xp,
    1049                           bool_t  to_mapper );
    1050 
    10511052
    10521053#endif  /* _VFS_H_ */
Note: See TracChangeset for help on using the changeset viewer.