Ignore:
Timestamp:
Dec 3, 2018, 12:20:18 PM (5 years ago)
Author:
alain
Message:

Improve the FAT32 file system to support cat, rm, cp commands.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/kernel/mm/mapper.c

    r581 r606  
    11/*
    2  * mapper.c - Map memory, file or device in process virtual address space.
     2 * mapper.c - Kernel cache for FS files or directories implementation.
    33 *
    44 * Authors   Mohamed Lamine Karaoui (2015)
    … …  
    5050    error_t    error;
    5151
    52     // allocate memory for associated mapper
     52    // allocate memory for mapper
    5353    req.type  = KMEM_MAPPER;
    5454    req.size  = sizeof(mapper_t);
    … …  
    6767
    6868    // initialize radix tree
    69     error = grdxt_init( &mapper->radix,
    70                         CONFIG_VMM_GRDXT_W1,
    71                         CONFIG_VMM_GRDXT_W2,
    72                         CONFIG_VMM_GRDXT_W3 );
     69    error = grdxt_init( &mapper->rt,
     70                        CONFIG_MAPPER_GRDXT_W1,
     71                        CONFIG_MAPPER_GRDXT_W2,
     72                        CONFIG_MAPPER_GRDXT_W3 );
    7373
    7474    if( error )
    … …  
    8585
    8686    // initialize mapper lock
    87     rwlock_init(  &mapper->lock , LOCK_MAPPER_STATE );
     87    remote_rwlock_init( XPTR( local_cxy , &mapper->lock ) , LOCK_MAPPER_STATE );
    8888
    8989    // initialize waiting threads xlist (empty)
    … …  
    9797}  // end mapper_create()
    9898
    99 ///////////////////////////////////////////
    100 error_t mapper_destroy( mapper_t * mapper )
     99////////////////////////////////////////
     100void mapper_destroy( mapper_t * mapper )
    101101{
    102102    page_t   * page;
    … …  
    104104    uint32_t   start_index = 0;
    105105    kmem_req_t req;
    106     error_t    error;
    107 
    108     // scan radix three and release all registered pages to PPM
     106
     107    // scan radix tree
    109108    do
    110109    {
    111110        // get page from radix tree
    112         page = (page_t *)grdxt_get_first( &mapper->radix , start_index , &found_index );
    113 
     111        page = (page_t *)grdxt_get_first( &mapper->rt , start_index , &found_index );
     112
     113        // release registered pages to PPM
    114114        if( page != NULL )
    115115        {
    116116            // remove page from mapper and release to PPM
    117             error = mapper_release_page( mapper , page );
    118 
    119             if ( error ) return error;
     117            mapper_release_page( mapper , page );
    120118
    121119            // update start_key value for next page
    … …  
    125123    while( page != NULL );
    126124
    127     // release the memory allocated to radix-tree itself
    128     grdxt_destroy( &mapper->radix );
     125    // release the memory allocated to radix tree itself
     126    grdxt_destroy( &mapper->rt );
    129127
    130128    // release memory for mapper descriptor
    … …  
    133131    kmem_free( &req );
    134132
    135     return 0;
    136 
    137133}  // end mapper_destroy()
    138134
    139 ////////////////////////////////////////////
    140 page_t * mapper_get_page( mapper_t * mapper,
    141                           uint32_t   index )
    142 {
    143     kmem_req_t    req;
    144     page_t      * page;
     135////////////////////////////////////////////////////
     136xptr_t  mapper_remote_get_page( xptr_t    mapper_xp,
     137                                uint32_t  page_id )
     138{
    145139    error_t       error;
     140    mapper_t    * mapper_ptr;
     141    cxy_t         mapper_cxy;
     142    xptr_t        lock_xp;        // extended pointer on mapper lock
     143    xptr_t        page_xp;        // extended pointer on searched page descriptor
     144    xptr_t        rt_xp;          // extended pointer on radix tree in mapper
     145
     146    thread_t * this = CURRENT_THREAD;
     147
     148    // get mapper cluster and local pointer
     149    mapper_ptr = GET_PTR( mapper_xp );
     150    mapper_cxy = GET_CXY( mapper_xp );
    146151
    147152#if DEBUG_MAPPER_GET_PAGE
    148153uint32_t cycle = (uint32_t)hal_get_cycles();
     154char          name[CONFIG_VFS_MAX_NAME_LENGTH];
     155vfs_inode_t * inode = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
     156vfs_inode_get_name( XPTR( mapper_cxy , inode ) , name );
    149157if( DEBUG_MAPPER_GET_PAGE < cycle )
    150 printk("\n[DBG] %s : thread %x enter for page %d / mapper %x / cycle %d\n",
    151 __FUNCTION__ , CURRENT_THREAD , index , mapper , cycle );
    152 #endif
    153 
    154     thread_t * this = CURRENT_THREAD;
     158printk("\n[%s] thread [%x,%x] enter for page %d of <%s> / cycle %d\n",
     159__FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
     160#endif
    155161
    156162    // check thread can yield
    157163    thread_assert_can_yield( this , __FUNCTION__ );
    158164
     165    // build extended pointer on mapper lock and mapper rt
     166    lock_xp  = XPTR( mapper_cxy , &mapper_ptr->lock );
     167    rt_xp    = XPTR( mapper_cxy , &mapper_ptr->rt );
     168
    159169    // take mapper lock in READ_MODE
    160     rwlock_rd_acquire( &mapper->lock );
     170    remote_rwlock_rd_acquire( lock_xp );
    161171
    162172    // search page in radix tree
    163     page = (page_t *)grdxt_lookup( &mapper->radix , index );
    164 
    165     // test if page available in mapper
    166     if( ( page == NULL) || page_is_flag( page , PG_INLOAD ) )  // page not available
    167     {
    168 
     173    page_xp  = grdxt_remote_lookup( rt_xp , page_id );
     174
     175    // test mapper miss
     176    if( page_xp == XPTR_NULL )                  // miss => try to handle it
     177    {
    169178        // release the lock in READ_MODE and take it in WRITE_MODE
    170         rwlock_rd_release( &mapper->lock );
    171         rwlock_wr_acquire( &mapper->lock );
    172 
    173         // second test on missing page because the page status can have been modified
     179        remote_rwlock_rd_release( lock_xp );
     180        remote_rwlock_wr_acquire( lock_xp );
     181
     182        // second test on missing page because the page status can be modified
    174183        // by another thread, when passing from READ_MODE to WRITE_MODE.
    175184        // from this point there is no concurrent accesses to mapper.
    176 
    177         page = grdxt_lookup( &mapper->radix , index );
    178 
    179         if ( page == NULL )   // missing page => create it and load it from file system
     185        page_xp = grdxt_remote_lookup( rt_xp , page_id );
     186
     187        if ( page_xp == XPTR_NULL )  // miss confirmed => handle it
    180188        {
    181189
    182190#if (DEBUG_MAPPER_GET_PAGE & 1)
    183191if( DEBUG_MAPPER_GET_PAGE < cycle )
    184 printk("\n[DBG] %s : missing page => load from device\n", __FUNCTION__ );
    185 #endif
    186             // allocate one page from PPM
    187             req.type  = KMEM_PAGE;
    188             req.size  = 0;
    189             req.flags = AF_NONE;
    190             page = kmem_alloc( &req );
    191 
    192             if( page == NULL )
     192printk("\n[%s] missing page => load it from IOC device\n", __FUNCTION__ );
     193#endif
     194            if( mapper_cxy == local_cxy )   // mapper is local
    193195            {
    194                 printk("\n[ERROR] in %s : thread %x cannot allocate a page in cluster %x\n",
    195                        __FUNCTION__ , this->trdid , local_cxy );
    196                 rwlock_wr_release( &mapper->lock );
    197                 return NULL;
     196                 error = mapper_handle_miss( mapper_ptr,
     197                                             page_id,
     198                                             &page_xp );
     199            }
     200            else
     201            {
     202                 rpc_mapper_handle_miss_client( mapper_cxy,
     203                                                mapper_ptr,
     204                                                page_id,
     205                                                &page_xp,
     206                                                &error );
    198207            }
    199208
    200             // initialize the page descriptor
    201             page_init( page );
    202             page_set_flag( page , PG_INIT | PG_INLOAD );
    203             page_refcount_up( page );
    204             page->mapper = mapper;
    205             page->index  = index;
    206 
    207             // insert page in mapper radix tree
    208             error = grdxt_insert( &mapper->radix, index , page );
    209 
    210             // release mapper lock from WRITE_MODE
    211             rwlock_wr_release( &mapper->lock );
    212 
    213             if( error )
     209            if ( error )
    214210            {
    215                 printk("\n[ERROR] in %s : thread %x cannot insert page in mapper\n",
    216                        __FUNCTION__ , this->trdid );
    217                 mapper_release_page( mapper , page );
    218                 page_clear_flag( page , PG_ALL );
    219                 req.ptr  = page;
    220                 req.type = KMEM_PAGE;
    221                 kmem_free(&req);
    222                 return NULL;
    223             }
    224 
    225             // launch I/O operation to load page from file system
    226             error = vfs_mapper_move_page( page,
    227                                           true );   // to mapper
    228             if( error )
    229             {
    230                 printk("\n[ERROR] in %s : thread %x cannot load page from device\n",
    231                        __FUNCTION__ , this->trdid );
    232                 mapper_release_page( mapper , page );
    233                 page_clear_flag( page , PG_ALL );
    234                 req.ptr  = page;
    235                 req.type = KMEM_PAGE;
    236                 kmem_free( &req );
    237                 return NULL;
    238             }
    239 
    240             // reset the page INLOAD flag to make the page available to all readers
    241             page_clear_flag( page , PG_INLOAD );
    242         }
    243         else if( page_is_flag( page , PG_INLOAD ) )   // page is loaded by another thread
    244         {
    245             // release mapper lock from WRITE_MODE
    246             rwlock_wr_release( &mapper->lock );
    247 
    248             // wait load completion
    249             while( page_is_flag( page , PG_INLOAD ) == false )
    250             {
    251                 // deschedule without blocking
    252                 sched_yield("waiting page loading");
     211                printk("\n[ERROR] in %s : thread[%x,%x] cannot handle mapper miss\n",
     212                __FUNCTION__ , this->process->pid, this->trdid );
     213                remote_rwlock_wr_release( lock_xp );
     214                return XPTR_NULL;
    253215            }
    254216        }
    255     }
    256     else                          // page available in mapper
    257     {
    258         rwlock_rd_release( &mapper->lock );
     217       
     218        // release mapper lock from WRITE_MODE
     219        remote_rwlock_wr_release( lock_xp );
     220    }
     221    else                                              // hit
     222    {
     223        // release mapper lock from READ_MODE
     224        remote_rwlock_rd_release( lock_xp );
    259225    }
    260226
    … …  
    262228cycle = (uint32_t)hal_get_cycles();
    263229if( DEBUG_MAPPER_GET_PAGE < cycle )
    264 printk("\n[DBG] %s : thread %x exit for page %d / ppn %x / cycle %d\n",
    265 __FUNCTION__, CURRENT_THREAD, index, ppm_page2ppn(XPTR(local_cxy, page)), cycle );
    266 #endif
    267 
    268     return page;
    269 
    270 }  // end mapper_get_page()
    271 
    272 ///////////////////////////////////////////////
    273 error_t mapper_release_page( mapper_t * mapper,
    274                              page_t   * page )
    275 {
    276     error_t error;
    277 
    278     // lauch IO operation to update page to file system
    279     error = vfs_mapper_move_page( page , false );    // from mapper
     230printk("\n[%s] thread[%x,%x] exit for page %d of <%s> / ppn %x / cycle %d\n",
     231__FUNCTION__, this->process->pid, this->trdid,
     232page_id, name, ppm_page2ppn( page_xp ), cycle );
     233#endif
     234
     235    return page_xp;
     236
     237}  // end mapper_remote_get_page()
     238
     239//////////////////////////////////////////////
     240error_t mapper_handle_miss( mapper_t * mapper,
     241                            uint32_t   page_id,
     242                            xptr_t   * page_xp )
     243{
     244    kmem_req_t   req;
     245    page_t     * page;
     246    error_t      error;
     247
     248    thread_t * this = CURRENT_THREAD;
     249
     250#if DEBUG_MAPPER_HANDLE_MISS
     251uint32_t cycle = (uint32_t)hal_get_cycles();
     252char          name[CONFIG_VFS_MAX_NAME_LENGTH];
     253vfs_inode_t * inode = mapper->inode;
     254vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
     255if( DEBUG_MAPPER_HANDLE_MISS < cycle )
     256printk("\n[%s] enter for page %d in <%s> / cycle %d\n",
     257__FUNCTION__, page_id, name, cycle );
     258if( DEBUG_MAPPER_HANDLE_MISS & 1 )
     259grdxt_display( &mapper->rt , name );
     260#endif
     261
     262    // allocate one page from the mapper cluster
     263    req.type  = KMEM_PAGE;
     264    req.size  = 0;
     265    req.flags = AF_NONE;
     266    page = kmem_alloc( &req );
     267
     268    if( page == NULL )
     269    {
     270        printk("\n[ERROR] in %s : thread [%x,%x] cannot allocate page in cluster %x\n",
     271        __FUNCTION__ , this->process->pid, this->trdid , local_cxy );
     272        return -1;
     273    }
     274
     275    // initialize the page descriptor
     276    page_init( page );
     277    page_set_flag( page , PG_INIT );
     278    page_refcount_up( page );
     279    page->mapper = mapper;
     280    page->index  = page_id;
     281
     282    // insert page in mapper radix tree
     283    error = grdxt_insert( &mapper->rt , page_id , page );
    280284
    281285    if( error )
    282286    {
    283         printk("\n[ERROR] in %s : cannot update file system\n", __FUNCTION__ );
    284         return EIO;
    285     }
     287        printk("\n[ERROR] in %s : thread[%x,%x] cannot insert page in mapper\n",
     288        __FUNCTION__ , this->process->pid, this->trdid );
     289        mapper_release_page( mapper , page );
     290        req.ptr  = page;
     291        req.type = KMEM_PAGE;
     292        kmem_free(&req);
     293        return -1;
     294    }
     295
     296    // launch I/O operation to load page from device to mapper
     297    error = vfs_fs_move_page( XPTR( local_cxy , page ) , true );
     298
     299    if( error )
     300    {
     301        printk("\n[ERROR] in %s : thread[%x,%x] cannot load page from device\n",
     302        __FUNCTION__ , this->process->pid, this->trdid );
     303        mapper_release_page( mapper , page );
     304        req.ptr  = page;
     305        req.type = KMEM_PAGE;
     306        kmem_free( &req );
     307        return -1;
     308    }
     309
     310    // set extended pointer on allocated page
     311    *page_xp = XPTR( local_cxy , page );
     312
     313#if DEBUG_MAPPER_HANDLE_MISS
     314cycle = (uint32_t)hal_get_cycles();
     315if( DEBUG_MAPPER_HANDLE_MISS < cycle )
     316printk("\n[%s] exit for page %d in <%s> / ppn %x / cycle %d\n",
     317__FUNCTION__, page_id, name, ppm_page2ppn( *page_xp ), cycle );
     318if( DEBUG_MAPPER_HANDLE_MISS & 1 )
     319grdxt_display( &mapper->rt , name );
     320#endif
     321
     322    return 0;
     323
     324}  // end mapper_handle_miss()
     325
     326////////////////////////////////////////////
     327void mapper_release_page( mapper_t * mapper,
     328                          page_t   * page )
     329{
     330    // build extended pointer on mapper lock
     331    xptr_t mapper_lock_xp = XPTR( local_cxy , &mapper->lock );
    286332
    287333    // take mapper lock in WRITE_MODE
    288     rwlock_wr_acquire( &mapper->lock );
     334    remote_rwlock_wr_acquire( mapper_lock_xp );
    289335
    290336    // remove physical page from radix tree
    291     grdxt_remove( &mapper->radix , page->index );
     337    grdxt_remove( &mapper->rt , page->index );
    292338
    293339    // release mapper lock from WRITE_MODE
    294     rwlock_wr_release( &mapper->lock );
     340    remote_rwlock_wr_release( mapper_lock_xp );
    295341
    296342    // release page to PPM
    … …  
    300346    kmem_free( &req );
    301347
    302     return 0;
    303 
    304348}  // end mapper_release_page()
    305349
    306 ///////////////////////////////////////////////////
     350////////////////////////////////////////////
    307351error_t mapper_move_user( mapper_t * mapper,
    308352                          bool_t     to_buffer,
    … …  
    311355                          uint32_t   size )
    312356{
     357    xptr_t     mapper_xp;      // extended pointer on local mapper
    313358    uint32_t   page_offset;    // first byte to move to/from a mapper page
    314359    uint32_t   page_count;     // number of bytes to move to/from a mapper page
    315     uint32_t   index;          // current mapper page index
     360    uint32_t   page_id;        // current mapper page index
    316361    uint32_t   done;           // number of moved bytes
    317     page_t   * page;           // current mapper page descriptor
    318     uint8_t  * map_ptr;        // current mapper  address
    319     uint8_t  * buf_ptr;        // current buffer  address
     362    xptr_t     page_xp;        // extended pointer on current mapper page descriptor
    320363
    321364#if DEBUG_MAPPER_MOVE_USER
    322 uint32_t cycle = (uint32_t)hal_get_cycles();
     365uint32_t   cycle = (uint32_t)hal_get_cycles();
     366thread_t * this  = CURRENT_THREAD;
    323367if( DEBUG_MAPPER_MOVE_USER < cycle )
    324 printk("\n[DBG] %s : thread %x enter / to_buf %d / buffer %x / cycle %d\n",
    325 __FUNCTION__ , CURRENT_THREAD , to_buffer , buffer , cycle );
    326 #endif
     368printk("\n[%s] thread[%x,%x] : to_buf %d / buffer %x / size %d / offset %d / cycle %d\n",
     369__FUNCTION__, this->process->pid, this->trdid,
     370to_buffer, buffer, size, file_offset, cycle );
     371#endif
     372
     373    // build extended pointer on mapper
     374    mapper_xp = XPTR( local_cxy , mapper );
    327375
    328376    // compute offsets of first and last bytes in file
    329377    uint32_t min_byte = file_offset;
    330     uint32_t max_byte = file_offset + size -1;
     378    uint32_t max_byte = file_offset + size - 1;
    331379
    332380    // compute indexes of pages for first and last byte in mapper
    … …  
    334382    uint32_t last  = max_byte >> CONFIG_PPM_PAGE_SHIFT;
    335383
    336     done = 0;
    337 
    338     // loop on pages in mapper
    339     for( index = first ; index <= last ; index++ )
    340     {
    341         // compute page_offset
    342         if( index == first ) page_offset = min_byte & CONFIG_PPM_PAGE_MASK;
    343         else                 page_offset = 0;
    344 
    345         // compute number of bytes in page
    346         if      ( first == last  ) page_count = size;
    347         else if ( index == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
    348         else if ( index == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
    349         else                       page_count = CONFIG_PPM_PAGE_SIZE;
    350 
    351384#if (DEBUG_MAPPER_MOVE_USER & 1)
    352385if( DEBUG_MAPPER_MOVE_USER < cycle )
    353 printk("\n[DBG] %s : index = %d / offset = %d / count = %d\n",
    354 __FUNCTION__ , index , page_offset , page_count );
    355 #endif
    356 
    357         // get page descriptor
    358         page = mapper_get_page( mapper , index );
    359 
    360         if ( page == NULL ) return EINVAL;
     386printk("\n[%s] first_page %d / last_page %d\n", __FUNCTION__, first, last );
     387#endif
     388
     389    done = 0;
     390
     391    // loop on pages in mapper
     392    for( page_id = first ; page_id <= last ; page_id++ )
     393    {
     394        // compute page_offset
     395        if( page_id == first ) page_offset = min_byte & CONFIG_PPM_PAGE_MASK;
     396        else                   page_offset = 0;
     397
     398        // compute number of bytes in page
     399        if      ( first   == last  ) page_count = size;
     400        else if ( page_id == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
     401        else if ( page_id == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
     402        else                         page_count = CONFIG_PPM_PAGE_SIZE;
     403
     404#if (DEBUG_MAPPER_MOVE_USER & 1)
     405if( DEBUG_MAPPER_MOVE_USER < cycle )
     406printk("\n[%s] page_id = %d / page_offset = %d / page_count = %d\n",
     407__FUNCTION__ , page_id , page_offset , page_count );
     408#endif
     409
     410        // get extended pointer on page descriptor
     411        page_xp = mapper_remote_get_page( mapper_xp , page_id );
     412
     413        if ( page_xp == XPTR_NULL ) return -1;
    361414
    362415        // compute pointer in mapper
    363         xptr_t base_xp = ppm_page2base( XPTR( local_cxy, page ) );
    364         map_ptr = (uint8_t *)GET_PTR( base_xp ) + page_offset;
     416        xptr_t    base_xp = ppm_page2base( page_xp );
     417        uint8_t * map_ptr = (uint8_t *)GET_PTR( base_xp ) + page_offset;
    365418
    366419        // compute pointer in buffer
    367         buf_ptr = (uint8_t *)buffer + done;
     420        uint8_t * buf_ptr = (uint8_t *)buffer + done;
    368421
    369422        // move fragment
    370423        if( to_buffer )
    371424        {
    372             hal_copy_to_uspace( buf_ptr , map_ptr , page_count );
     425            hal_copy_to_uspace( buf_ptr , map_ptr , page_count ); 
    373426        }
    374427        else
    375428        {
    376             ppm_page_do_dirty( page );
    377             hal_copy_from_uspace( map_ptr , buf_ptr , page_count );
     429            ppm_page_do_dirty( page_xp );
     430            hal_copy_from_uspace( map_ptr , buf_ptr , page_count ); 
    378431        }
    379432
    … …  
    384437cycle = (uint32_t)hal_get_cycles();
    385438if( DEBUG_MAPPER_MOVE_USER < cycle )
    386 printk("\n[DBG] %s : thread %x exit / to_buf %d / buffer %x / cycle %d\n",
    387 __FUNCTION__ , CURRENT_THREAD , to_buffer , buffer , cycle );
     439printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
     440__FUNCTION__, this->process->pid, this->trdid, cycle );
    388441#endif
    389442
    … …  
    393446
    394447////////////////////////////////////////////////
    395 error_t mapper_move_kernel( mapper_t  *  mapper,
    396                             bool_t       to_buffer,
    397                             uint32_t     file_offset,
    398                             xptr_t       buffer_xp,
    399                             uint32_t     size )
     448error_t mapper_move_kernel( xptr_t    mapper_xp,
     449                            bool_t    to_buffer,
     450                            uint32_t  file_offset,
     451                            xptr_t    buffer_xp,
     452                            uint32_t  size )
    400453{
    401454    uint32_t   page_offset;    // first byte to move to/from a mapper page
    402455    uint32_t   page_count;     // number of bytes to move to/from a mapper page
    403     uint32_t   index;          // current mapper page index
     456    uint32_t   page_id;        // current mapper page index
    404457    uint32_t   done;           // number of moved bytes
    405     page_t   * page;           // current mapper page descriptor
     458    xptr_t     page_xp;        // extended pointer on current mapper page descriptor
    406459
    407460    uint8_t  * src_ptr;        // source buffer local pointer
    … …  
    412465    // get buffer cluster and local pointer
    413466    cxy_t     buffer_cxy = GET_CXY( buffer_xp );
    414     uint8_t * buffer_ptr = (uint8_t *)GET_PTR( buffer_xp );
     467    uint8_t * buffer_ptr = GET_PTR( buffer_xp );
     468
     469    // get mapper cluster
     470    cxy_t     mapper_cxy = GET_CXY( mapper_xp );
    415471
    416472#if DEBUG_MAPPER_MOVE_KERNEL
    417 uint32_t cycle = (uint32_t)hal_get_cycles();
     473uint32_t   cycle = (uint32_t)hal_get_cycles();
     474thread_t * this  = CURRENT_THREAD;
    418475if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
    419 printk("\n[DBG] %s : thread %x enter / to_buf %d / buf_cxy %x / buf_ptr %x / cycle %d\n",
    420 __FUNCTION__ , CURRENT_THREAD , to_buffer , buffer_cxy , buffer_ptr , cycle );
     476printk("\n[%s] thread[%x,%x] enter / to_buf %d / buf_cxy %x / buf_ptr %x / cycle %d\n",
     477__FUNCTION__, this->process->pid, this->trdid, to_buffer, buffer_cxy, buffer_ptr, cycle );
    421478#endif
    422479
    … …  
    431488#if (DEBUG_MAPPER_MOVE_KERNEL & 1)
    432489if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
    433 printk("\n[DBG] %s : first_page %d / last_page %d\n", __FUNCTION__, first, last );
     490printk("\n[%s] first_page %d / last_page %d\n", __FUNCTION__, first, last );
    434491#endif
    435492
    … …  
    438495    {
    439496        dst_cxy = buffer_cxy;
    440         src_cxy = local_cxy;
     497        src_cxy = mapper_cxy;
    441498    }
    442499    else
    443500    {
    444501        src_cxy = buffer_cxy;
    445         dst_cxy = local_cxy;
     502        dst_cxy = mapper_cxy;
    446503    }
    447504
    … …  
    449506
    450507    // loop on pages in mapper
    451     for( index = first ; index <= last ; index++ )
     508    for( page_id = first ; page_id <= last ; page_id++ )
    452509    {
    453510        // compute page_offset
    454         if( index == first ) page_offset = min_byte & CONFIG_PPM_PAGE_MASK;
    455         else                 page_offset = 0;
     511        if( page_id == first ) page_offset = min_byte & CONFIG_PPM_PAGE_MASK;
     512        else                   page_offset = 0;
    456513
    457514        // compute number of bytes to move in page
    458         if      ( first == last  ) page_count = size;
    459         else if ( index == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
    460         else if ( index == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
    461         else                       page_count = CONFIG_PPM_PAGE_SIZE;
     515        if      ( first == last  )   page_count = size;
     516        else if ( page_id == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
     517        else if ( page_id == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
     518        else                         page_count = CONFIG_PPM_PAGE_SIZE;
    462519
    463520#if (DEBUG_MAPPER_MOVE_KERNEL & 1)
    464521if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
    465 printk("\n[DBG] %s : page_index = %d / offset = %d / bytes = %d\n",
    466 __FUNCTION__ , index , page_offset , page_count );
    467 #endif
    468 
    469         // get page descriptor
    470         page = mapper_get_page( mapper , index );
    471 
    472         if ( page == NULL ) return EINVAL;
     522printk("\n[%s] page_id = %d / offset = %d / bytes = %d\n",
     523__FUNCTION__ , page_id , page_offset , page_count );
     524#endif
     525
     526        // get extended pointer on page descriptor
     527        page_xp = mapper_remote_get_page( mapper_xp , page_id );
     528
     529        if ( page_xp == XPTR_NULL ) return -1;
    473530
    474531        // get page base address
    475         xptr_t    base_xp  = ppm_page2base( XPTR( local_cxy , page ) );
     532        xptr_t    base_xp  = ppm_page2base( page_xp );
    476533        uint8_t * base_ptr = (uint8_t *)GET_PTR( base_xp );
    477534
    … …  
    487544            dst_ptr = base_ptr + page_offset;
    488545
    489             ppm_page_do_dirty( page );
     546            ppm_page_do_dirty( page_xp );
    490547        }
    491548
    … …  
    499556cycle = (uint32_t)hal_get_cycles();
    500557if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
    501 printk("\n[DBG] %s : thread %x exit / to_buf %d / buf_cxy %x / buf_ptr %x / cycle %d\n",
    502 __FUNCTION__ , CURRENT_THREAD , to_buffer , buffer_cxy , buffer_ptr , cycle );
     558printk("\n[%s] thread[%x,%x] exit / to_buf %d / buf_cxy %x / buf_ptr %x / cycle %d\n",
     559__FUNCTION__, this->process->pid, this->trdid, to_buffer, buffer_cxy, buffer_ptr, cycle );
    503560#endif
    504561
    … …  
    507564}  // end mapper_move_kernel()
    508565
     566///////////////////////////////////////////////////
     567error_t mapper_remote_get_32( xptr_t     mapper_xp,
     568                              uint32_t   word_id,
     569                              uint32_t * p_value )
     570{
     571    uint32_t   page_id;      // page index in file
     572    uint32_t   local_id;     // word index in page
     573    xptr_t     page_xp;      // extended pointer on searched page descriptor
     574    xptr_t     base_xp;      // extended pointer on searched page base
     575
     576   
     577    // get page index and local word index
     578    page_id  = word_id >> 10;
     579    local_id = word_id & 0x3FF;
     580
     581    // get page containing the searched word
     582    page_xp  = mapper_remote_get_page( mapper_xp , page_id );
     583
     584    if( page_xp == XPTR_NULL )  return -1;
     585   
     586    // get page base
     587    base_xp = ppm_page2base( page_xp );
     588
     589    // get the value from mapper
     590    *p_value = hal_remote_l32( base_xp + (local_id<<2) );
     591
     592    return 0;
     593
     594}  // end mapper_remote_get_32()
     595
     596///////////////////////////////////////////////////
     597error_t mapper_remote_set_32( xptr_t     mapper_xp,
     598                              uint32_t   word_id,
     599                              uint32_t   value )
     600{
     601   
     602    uint32_t   page_id;      // page index in file
     603    uint32_t   local_id;     // word index in page
     604    xptr_t     page_xp;      // extended pointer on searched page descriptor
     605    xptr_t     base_xp;      // extended pointer on searched page base
     606
     607    // get page index and local vord index
     608    page_id  = word_id >> 10;
     609    local_id = word_id & 0x3FF;
     610
     611    // get page containing the searched word
     612    page_xp  = mapper_remote_get_page( mapper_xp , page_id );
     613
     614    if( page_xp == XPTR_NULL ) return -1;
     615
     616    // get page base
     617    base_xp = ppm_page2base( page_xp );
     618
     619    // set value to mapper
     620    hal_remote_s32( (base_xp + (local_id << 2)) , value );
     621
     622    // set the dirty flag
     623    ppm_page_do_dirty( page_xp );
     624
     625    return 0;
     626
     627}  // end mapper_remote_set_32()
     628
     629
Note: See TracChangeset for help on using the changeset viewer.