Changeset 313 for trunk/kernel/kern


Ignore:
Timestamp:
Aug 2, 2017, 3:24:57 PM (5 years ago)
Author:
alain
Message:

RSeveral modifs in the page-fault handling.

Location:
trunk/kernel/kern
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/kern/rpc.c

    r296 r313  
    7575    &rpc_kcm_free_server,               // 23
    7676    &rpc_mapper_move_buffer_server,     // 24
    77     &rpc_undefined,                     // 25
     77    &rpc_mapper_get_page_server,        // 25
    7878    &rpc_undefined,                     // 26
    7979    &rpc_undefined,                     // 27
     
    9696void rpc_pmem_get_pages_client( cxy_t      cxy,
    9797                                uint32_t   order,      // in
    98                                 error_t  * error,      // out
    99                                 uint32_t * ppn )       // out
     98                                page_t  ** page )      // out
    10099{
    101100    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
     
    114113    rpc_send_sync( cxy , &rpc );
    115114
    116     // get output arguments RPC descriptor
    117     *error  = (error_t)rpc.args[0];     
    118     *ppn    = (uint32_t)rpc.args[1];
     115    // get output arguments from RPC descriptor
     116    *page    = (page_t *)(intptr_t)rpc.args[1];
    119117
    120118    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
     
    124122void rpc_pmem_get_pages_server( xptr_t xp )
    125123{
    126     uint32_t order;  // input
    127     error_t  error;  // output
    128     uint32_t ppn;    // output
    129 
    130124    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
    131125
     
    135129
    136130    // get input arguments from client RPC descriptor
    137     order = hal_remote_lw( XPTR( cxy , &desc->args[0] ) );
     131    uint32_t order = hal_remote_lw( XPTR( cxy , &desc->args[0] ) );
    138132   
    139133    // call local pmem allocator
    140134    page_t * page = ppm_alloc_pages( order );
    141     error = ( page == NULL ) ? ENOMEM : 0;
    142     ppn   = ppm_page2ppn( page );
    143135
    144136    // set output arguments into client RPC descriptor
    145     hal_remote_sw( XPTR( cxy , &desc->args[0] ) , error );
    146     hal_remote_sw( XPTR( cxy , &desc->args[1] ) , ppn );
     137    hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
    147138
    148139    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
     
    13531344                                    bool_t     is_user,       // in
    13541345                                    uint32_t   file_offset,   // in
    1355                                     void     * buffer,        // in
     1346                                    uint64_t  buffer,        // in
    13561347                                    uint32_t   size,          // in
    13571348                                    error_t  * error )        // out
     
    13711362    rpc.args[2] = (uint64_t)is_user;
    13721363    rpc.args[3] = (uint64_t)file_offset;
    1373     rpc.args[4] = (uint64_t)(intptr_t)buffer;
     1364    rpc.args[4] = (uint64_t)buffer;
    13741365    rpc.args[5] = (uint64_t)size;
    13751366
     
    13901381    bool_t     is_user;
    13911382    uint32_t   file_offset;
    1392     void     * buffer;
     1383    void     * user_buffer;
     1384    xptr_t     kern_buffer;
    13931385    uint32_t   size;
    13941386    error_t    error;
     
    14051397    is_user     =                       hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
    14061398    file_offset =                       hal_remote_lwd( XPTR( client_cxy , &desc->args[3] ) );
    1407     buffer      = (void     *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
    14081399    size        =                       hal_remote_lwd( XPTR( client_cxy , &desc->args[5] ) );
    14091400
    14101401    // call local kernel function
    1411     error = mapper_move_buffer( mapper,
    1412                                 to_buffer,
    1413                                 is_user,
    1414                                 file_offset,
    1415                                 buffer,
    1416                                 size );
     1402    if( is_user )
     1403    {
     1404        user_buffer = (void *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
     1405
     1406        error = mapper_move_user_buffer( mapper,
     1407                                         to_buffer,
     1408                                         file_offset,
     1409                                         user_buffer,
     1410                                         size );
     1411    }
     1412    else
     1413    {
     1414        kern_buffer = (xptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[4] ) );
     1415
     1416        error = mapper_move_user_buffer( mapper,
     1417                                         to_buffer,
     1418                                         file_offset,
     1419                                         kern_buffer,
     1420                                         size );
     1421    }
    14171422
    14181423    // set output argument to client RPC descriptor
     
    14211426    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
    14221427}
     1428
     1429/////////////////////////////////////////////////////////////////////////////////////////
     1430// [25]          Marshaling functions attached to RPC_MAPPER_GET_PAGE
     1431/////////////////////////////////////////////////////////////////////////////////////////
     1432
     1433///////////////////////////////////////////////////////
     1434void rpc_mapper_get_page_client( cxy_t             cxy,
     1435                                 struct mapper_s * mapper,     // in
     1436                                 uint32_t          index,      // in
     1437                                 page_t         ** page )      // out
     1438{
     1439    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
     1440
     1441    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
     1442
     1443    // initialise RPC descriptor header
     1444    rpc_desc_t  rpc;
     1445    rpc.index    = RPC_MAPPER_GET_PAGE;
     1446    rpc.response = 1;
     1447
     1448    // set input arguments in RPC descriptor
     1449    rpc.args[0] = (uint64_t)(intptr_t)mapper;
     1450    rpc.args[1] = (uint64_t)index;
     1451
     1452    // register RPC request in remote RPC fifo (blocking function)
     1453    rpc_send_sync( cxy , &rpc );
     1454
     1455    // get output values from RPC descriptor
     1456    *page = (page_t *)(intptr_t)rpc.args[2];
     1457
     1458    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
     1459}
     1460
     1461////////////////////////////////////////////
     1462void rpc_mapper_get_page_server( xptr_t xp )
     1463{
     1464    rpc_dmsg("\n[INFO] %s : enter at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
     1465
     1466    // get client cluster identifier and pointer on RPC descriptor
     1467    cxy_t        cxy  = (cxy_t)GET_CXY( xp );
     1468    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
     1469
     1470    // get input arguments from client RPC descriptor
     1471    mapper_t * mapper = (mapper_t *)(intptr_t)hal_remote_lwd( XPTR( cxy , &desc->args[0] ) );
     1472    uint32_t   index  = (uint32_t)            hal_remote_lwd( XPTR( cxy , &desc->args[1] ) );
     1473   
     1474    // call local pmem allocator
     1475    page_t * page = mapper_get_page( mapper , index );
     1476
     1477    // set output arguments into client RPC descriptor
     1478    hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
     1479
     1480    rpc_dmsg("\n[INFO] %s : completed at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
     1481}
     1482
    14231483
    14241484/***************************************************************************************/
  • trunk/kernel/kern/rpc.h

    r296 r313  
    3535
    3636struct process_s;
     37struct page_s;
    3738struct vseg_s;
    3839struct exec_info_s;
     
    8081    RPC_KCM_FREE               = 23,
    8182    RPC_MAPPER_MOVE_BUFFER     = 24,
     83    RPC_MAPPER_GET_PAGE        = 25,
    8284
    8385    RPC_MAX_INDEX              = 30,
     
    204206/***********************************************************************************
    205207 * [0] The RPC_PMEM_GET_PAGES allocates one or several pages in a remote cluster,
    206  * and returns the PPN of the first allocated page.
     208 * and returns the local pointer on the page descriptor.
    207209 ***********************************************************************************
    208210 * @ cxy     : server cluster identifier
    209211 * @ order   : [in]  ln2( number of requested pages )
    210  * @ error   : [out] error status (0 if success)
    211  * @ ppn     : [out] first physical page number
    212  **********************************************************************************/
    213 void rpc_pmem_get_pages_client( cxy_t      cxy,
    214                                 uint32_t   order,
    215                                 error_t  * error,
    216                                 uint32_t * ppn );
     212 * @ page    : [out] local pointer on page descriptor / NULL if failure
     213 **********************************************************************************/
     214void rpc_pmem_get_pages_client( cxy_t             cxy,
     215                                uint32_t          order,
     216                                struct page_s  ** page );
    217217
    218218void rpc_pmem_get_pages_server( xptr_t xp );
     
    550550
    551551/***********************************************************************************
    552  * [24] The RPC_MAPPER_MOVE_USER is called by the vfs_move() function.
    553  * It allows a client thread to requires a remote mapper to move data to/from
    554  * an user buffer, as specified by the arguments.
     552 * [24] The RPC_MAPPER_MOVE_BUFFER allows a client thread to require a remote
     553 * mapper to move data to/from a kernel or user buffer.
     554 * - It calls the mapper_move_user() function for a - possibly distributed -
     555 *   user buffer identified by a user-space pointer, and casted to uint64_t.
     556 * - It calls the mapper_move_kernel() function for a - possibly remote -
     557 *   kernel buffer identified by an extended pointer, and casted to uint64_t.
     558 * It is used by the vfs_move_user() function to move data between a mapper
     559 * and an user buffer required by a sys_read() or a sys_write().
     560 * It is used by the vmm_get_one_ppn() function to initialise a physical page
     561 * from a .elf file mapper, for a CODE or DATA vseg page fault.
    555562 ***********************************************************************************
    556563 * @ cxy         : server cluster identifier.
    557564 * @ mapper      : [in]  local pointer on mapper
    558  * @ to_buffer   : [in]  move data from buffer to mapper if non zero.
    559  * @ is_user     : [in]  buffer in user space if non zero.
     565 * @ to_buffer   : [in]  move data from mapper to buffer if non zero.
     566 * @ is_user     : [in]  buffer in user space if true
    560567 * @ file_offset : [in]  first byte to move in mapper
    561  * @ buffer      : [in]  pointer on buffer in user space
     568 * @ buffer      : [in]  user space pointer / kernel extended pointer
    562569 * @ size        : [in]  number of bytes to move
    563570 * @ error       : [out] error status (0 if success).
     
    568575                                    bool_t            is_user,
    569576                                    uint32_t          file_offset,
    570                                     void            * buffer,
     577                                    uint64_t          buffer,
    571578                                    uint32_t          size,
    572579                                    error_t         * error );
     
    574581void rpc_mapper_move_buffer_server( xptr_t xp );
    575582
    576 
    577 
     583/***********************************************************************************
     584 * [25] The RPC_MAPPER_GET_PAGE allows a client thread to get the local pointer
     585 * on a remote page descriptor, for a page, identified by the page index in mapper.
     586 * It is used by the vmm_get_one_ppn() function to handle a page fault on
     587 * a FILE type vseg.
     588 ***********************************************************************************
     589 * @ cxy         : server cluster identifier.
     590 * @ mapper      : [in]  local pointer on mapper.
     591 * @ index       : [in]  page index in mapper.
     592 * @ page        : [out] local pointer on page descriptor / NULL if failure.
     593 **********************************************************************************/
     594void rpc_mapper_get_page_client( cxy_t             cxy,
     595                                 struct mapper_s * mapper,
     596                                 uint32_t          index,
     597                                 struct page_s  ** page );
     598
     599void rpc_mapper_get_page_server( xptr_t xp );
    578600
    579601#endif
Note: See TracChangeset for help on using the changeset viewer.