Ignore:
Timestamp:
Jun 3, 2017, 4:42:49 PM (5 years ago)
Author:
max@…
Message:

cosmetic, and a few typos

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/mm/mapper.c

    r14 r18  
    105105        page = (page_t *)grdxt_get_first( &mapper->radix , start_index , &found_index );
    106106
    107         if( page != NULL ) 
     107        if( page != NULL )
    108108        {
    109109            // remove page from mapper and release to PPM
     
    127127
    128128    return 0;
    129  
     129
    130130}  // end mapper_destroy()
    131131
     
    147147    page = (page_t *)grdxt_lookup( &mapper->radix , index );
    148148
    149     // test if page available in mapper 
     149    // test if page available in mapper
    150150    if( ( page == NULL) || page_is_flag( page , PG_INLOAD ) )  // page not available            /
    151151    {
     
    167167            req.flags = AF_NONE;
    168168            page = kmem_alloc( &req );
    169      
     169
    170170            if( page == NULL )
    171171            {
     
    190190            rwlock_wr_unlock( &mapper->lock );
    191191
    192             if( error ) 
     192            if( error )
    193193            {
    194194                printk("\n[ERROR] in %s : thread %x cannot insert page in mapper\n",
     
    201201                return NULL;
    202202            }
    203        
     203
    204204            // launch I/O operation to load page from file system
    205205            error = mapper_updt_page( mapper , index , page );
     
    236236                if(  page_is_flag( page , PG_INLOAD ) ) break;
    237237
    238                 // deschedule 
     238                // deschedule
    239239                sched_yield();
    240240            }
    241          
     241
    242242        }
    243243
    244244        return page;
    245245    }
    246     else 
     246    else
    247247    {
    248248         // release lock from READ_MODE
     
    268268        return EIO;
    269269    }
    270        
     270
    271271    // take mapper lock in WRITE_MODE
    272272    rwlock_wr_lock( &mapper->lock );
     
    331331    rwlock_wr_unlock( &mapper->lock );
    332332
    333     // release page lock 
     333    // release page lock
    334334    page_unlock( page );
    335335
     
    339339        return EIO;
    340340    }
    341        
     341
    342342    return 0;
    343343}  // end mapper_updt_page
     
    364364    }
    365365
    366         if( page_is_flag( page , PG_DIRTY ) ) 
     366        if( page_is_flag( page , PG_DIRTY ) )
    367367        {
    368368        // get file system type and inode pointer
     
    388388        rwlock_rd_unlock( &mapper->lock );
    389389
    390         // release page lock 
     390        // release page lock
    391391        page_unlock( page );
    392392
     
    396396            return EIO;
    397397        }
    398    
     398
    399399        // clear dirty bit
    400400                page_undo_dirty( page );
    401401     }
    402        
     402
    403403    return 0;
    404404
     
    408408// This static function is called by the mapper_move fragments() function.
    409409// It moves one fragment between an user buffer and the kernel mapper.
    410 // Implementation Note: It can require access to one or two pages in mapper: 
     410// Implementation Note: It can require access to one or two pages in mapper:
    411411//  [max_page_index == min_page_index]     <=>  fragment fit in one mapper page
    412412//  [max_page index == min_page_index + 1] <=>  fragment spread on two mapper pages
     
    416416                                         fragment_t * fragment )
    417417{
    418     uint32_t   size;                 // number of bytes in fragment 
     418    uint32_t   size;                 // number of bytes in fragment
    419419    cxy_t      buf_cxy;              // cluster identifier for user buffer
    420420    uint8_t  * buf_ptr;              // local pointer on first byte in user buffer
    421    
     421
    422422    xptr_t     xp_buf;               // extended pointer on byte in user buffer
    423423    xptr_t     xp_map;               // extended pointer on byte in kernel mapper
    424424
    425     uint32_t   min_file_offset;      // offset of first byte in file 
    426     uint32_t   max_file_offset;      // offset of last byte in file   
     425    uint32_t   min_file_offset;      // offset of first byte in file
     426    uint32_t   max_file_offset;      // offset of last byte in file
    427427
    428428    uint32_t   first_page_index;     // index of first page in mapper
    429     uint32_t   first_page_offset;    // offset of first byte in first page in mapper   
    430     uint32_t   first_page_size;      // offset of first byte in first page in mapper   
    431 
    432     uint32_t   second_page_index;    // index of last page in mapper   
    433     uint32_t   second_page_offset;   // offset of last byte in last page in mapper   
    434     uint32_t   second_page_size;     // offset of last byte in last page in mapper   
    435  
     429    uint32_t   first_page_offset;    // offset of first byte in first page in mapper
     430    uint32_t   first_page_size;      // offset of first byte in first page in mapper
     431
     432    uint32_t   second_page_index;    // index of last page in mapper
     433    uint32_t   second_page_offset;   // offset of last byte in last page in mapper
     434    uint32_t   second_page_size;     // offset of last byte in last page in mapper
     435
    436436    page_t   * page;                 // pointer on one page descriptor in mapper
    437437    uint8_t  * map_ptr;              // local pointer on first byte in mapper
     
    448448        return EINVAL;
    449449    }
    450    
     450
    451451    // compute offsets of first and last bytes in file
    452452    min_file_offset = fragment->file_offset;
     
    459459    if ( first_page_index == second_page_index )  // only one page in mapper
    460460    {
    461         // compute offset and size for page in mapper 
     461        // compute offset and size for page in mapper
    462462        first_page_offset = min_file_offset & (1<<CONFIG_PPM_PAGE_SHIFT);
    463463        first_page_size   = size;
     
    499499        // compute local pointer on first byte in first page in mapper
    500500        map_ptr = (uint8_t *)ppm_page2base(page) + first_page_offset;
    501    
     501
    502502        // compute extended pointers
    503503        xp_map = XPTR( local_cxy , map_ptr );
     
    517517        // compute offset and size for second page in mapper
    518518        second_page_offset = 0;
    519         second_page_size   = size - first_page_size; 
     519        second_page_size   = size - first_page_size;
    520520
    521521        // get pointer on second page in mapper
     
    526526        // compute local pointer on first byte in second page in mapper
    527527        map_ptr = (uint8_t *)ppm_page2base( page ) + second_page_offset;
    528    
     528
    529529        // compute extended pointers
    530530        xp_map = XPTR( local_cxy , map_ptr );
     
    573573        frags_array = client_frags;
    574574    }
    575     else                           // make a local copy of fragments array 
     575    else                           // make a local copy of fragments array
    576576    {
    577577        hal_remote_memcpy( XPTR( local_cxy , local_frags ) , xp_frags ,
Note: See TracChangeset for help on using the changeset viewer.