source: trunk/kernel/mm/mapper.c @ 395

Last change on this file since 395 was 367, checked in by alain, 7 years ago

Change Time unit from cycle to TICK (in millisecond).
Fix several bugs in VFS.

File size: 15.0 KB
RevLine 
[1]1/*
2 * mapper.c - Map memory, file or device in process virtual address space.
3 *
4 * Authors   Mohamed Lamine Karaoui (2015)
5 *           Alain Greiner (2016)
6 *
7 * Copyright (c)  UPMC Sorbonne Universites
8 *
9 * This file is part of ALMOS-MKH.
10 *
11 * ALMOS-MKH is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; version 2.0 of the License.
14 *
15 * ALMOS-MKH is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
[14]25#include <kernel_config.h>
[1]26#include <hal_types.h>
27#include <hal_special.h>
[23]28#include <hal_uspace.h>
[1]29#include <grdxt.h>
30#include <rwlock.h>
31#include <printk.h>
[279]32#include <memcpy.h>
[1]33#include <thread.h>
34#include <core.h>
35#include <process.h>
36#include <kmem.h>
37#include <kcm.h>
38#include <page.h>
39#include <cluster.h>
40#include <vfs.h>
41#include <mapper.h>
42
[246]43//////////////////////////////////////////////
44mapper_t * mapper_create( vfs_fs_type_t type )
[1]45{
46    mapper_t * mapper;
47    kmem_req_t req;
48    error_t    error;
49
50    // allocate memory for associated mapper
[183]51    req.type  = KMEM_MAPPER;
52    req.size  = sizeof(mapper_t);
[1]53    req.flags = AF_KERNEL | AF_ZERO;
[183]54    mapper    = (mapper_t *)kmem_alloc( &req );
[1]55
56    if( mapper == NULL )
57    {
58        printk("\n[ERROR] in %s : no memory for mapper descriptor\n", __FUNCTION__ );
59        return NULL;
60    }
61
62    // initialize refcount & inode
[183]63    mapper->refcount = 0;
[1]64    mapper->inode    = NULL;
65
66    // initialize radix tree
[183]67    error = grdxt_init( &mapper->radix,
[1]68                        CONFIG_VMM_GRDXT_W1,
69                        CONFIG_VMM_GRDXT_W2,
70                        CONFIG_VMM_GRDXT_W3 );
71
72    if( error )
73    {
74        printk("\n[ERROR] in %s : cannot initialize radix tree\n", __FUNCTION__ );
[183]75        req.type  = KMEM_MAPPER;
[1]76        req.ptr   = mapper;
77        kmem_free( &req );
78        return NULL;
79    }
80
[246]81    // initialize mapper type
82    mapper->type = type;
83
[1]84    // initialize mapper lock
[183]85    rwlock_init(  &mapper->lock );
[1]86
87    // initialize waiting threads xlist (empty)
[183]88    xlist_root_init( XPTR( local_cxy , &mapper->wait_root ) );
[1]89
90    // initialize vsegs xlist (empty)
[183]91    xlist_root_init( XPTR( local_cxy , &mapper->vsegs_root ) );
[1]92
93    return mapper;
94
[204]95}  // end mapper_create()
96
[1]97///////////////////////////////////////////
98error_t mapper_destroy( mapper_t * mapper )
99{
100    page_t   * page;
101    uint32_t   found_index = 0;
102    uint32_t   start_index = 0;
103    kmem_req_t req;
104    error_t    error;
105
106    // scan radix three and release all registered pages to PPM
107    do
108    {
109        // get page from radix tree
110        page = (page_t *)grdxt_get_first( &mapper->radix , start_index , &found_index );
111
[18]112        if( page != NULL )
[1]113        {
114            // remove page from mapper and release to PPM
[183]115            error = mapper_release_page( mapper , page );
[1]116
117            if ( error ) return error;
118
119            // update start_key value for next page
120            start_index = found_index;
121        }
122    }
123    while( page != NULL );
124
125    // release the memory allocated to radix-tree itself
126    grdxt_destroy( &mapper->radix );
127
128    // release memory for mapper descriptor
129    req.type = KMEM_MAPPER;
130    req.ptr  = mapper;
131    kmem_free( &req );
132
133    return 0;
[18]134
[204]135}  // end mapper_destroy()
136
[1]137////////////////////////////////////////////
138page_t * mapper_get_page( mapper_t * mapper,
139                          uint32_t   index )
140{
[183]141    kmem_req_t    req;
142    page_t      * page;
143    error_t       error;
[1]144
[246]145    mapper_dmsg("\n[INFO] %s : enters for page %d in mapper %x\n",
[204]146                __FUNCTION__ , index , mapper );
147
[1]148    thread_t * this = CURRENT_THREAD;
149
150    // take mapper lock in READ_MODE
151    rwlock_rd_lock( &mapper->lock );
152
153    // search page in radix tree
154    page = (page_t *)grdxt_lookup( &mapper->radix , index );
155
[18]156    // test if page available in mapper
[183]157    if( ( page == NULL) || page_is_flag( page , PG_INLOAD ) )  // page not available
[1]158    {
[204]159
[1]160        // release the lock in READ_MODE and take it in WRITE_MODE
161        rwlock_rd_unlock( &mapper->lock );
162        rwlock_wr_lock( &mapper->lock );
163
164        // second test on missing page because the page status can have been modified
165        // by another thread, when passing from READ_MODE to WRITE_MODE.
166        // from this point there is no concurrent accesses to mapper.
167
168        page = grdxt_lookup( &mapper->radix , index );
169
[238]170        if ( page == NULL )   // missing page => create it and load it from file system
[1]171        {
[265]172            mapper_dmsg("\n[INFO] %s : missing page => load from device\n", __FUNCTION__ );
[204]173
[1]174            // allocate one page from PPM
175            req.type  = KMEM_PAGE;
176            req.size  = 0;
177            req.flags = AF_NONE;
178            page = kmem_alloc( &req );
[18]179
[1]180            if( page == NULL )
181            {
182                printk("\n[ERROR] in %s : thread %x cannot allocate a page in cluster %x\n",
183                       __FUNCTION__ , this->trdid , local_cxy );
184                rwlock_wr_unlock( &mapper->lock );
185                return NULL;
186            }
187
188            // initialize the page descriptor
189            page_init( page );
190            page_set_flag( page , PG_INIT );
191            page_set_flag( page , PG_INLOAD );
192            page_refcount_up( page );
193            page->mapper = mapper;
194            page->index  = index;
195
196            // insert page in mapper radix tree
197            error = grdxt_insert( &mapper->radix, index , page );
198
199            // release mapper lock from WRITE_MODE
200            rwlock_wr_unlock( &mapper->lock );
201
[18]202            if( error )
[1]203            {
204                printk("\n[ERROR] in %s : thread %x cannot insert page in mapper\n",
205                       __FUNCTION__ , this->trdid );
[23]206                mapper_release_page( mapper , page );
[1]207                page_clear_flag( page , PG_ALL );
208                req.ptr  = page;
209                req.type = KMEM_PAGE;
210                kmem_free(&req);
211                return NULL;
212            }
[18]213
[238]214            // update the mapper and index fields in page descriptor
[330]215            // required by the vfs_move_page_to_mapper()
[238]216            page->mapper = mapper;
217            page->index  = index;
218
[1]219            // launch I/O operation to load page from file system
[367]220            error = vfs_mapper_move_page( page, 
221                                          true );   // to mapper
[1]222
223            if( error )
224            {
225                printk("\n[ERROR] in %s : thread %x cannot load page from device\n",
226                       __FUNCTION__ , this->trdid );
[23]227                mapper_release_page( mapper , page );
[1]228                page_clear_flag( page , PG_ALL );
229                req.ptr  = page;
230                req.type = KMEM_PAGE;
231                kmem_free( &req );
232                return NULL;
233            }
234
235            // reset the page INLOAD flag to make the page available to all readers
236            page_clear_flag( page , PG_INLOAD );
237
238        }
239        else if( page_is_flag( page , PG_INLOAD ) )   // page is loaded by another thread
240        {
241            // release mapper lock from WRITE_MODE
242            rwlock_wr_unlock( &mapper->lock );
243
244            // deschedule to wait load completion
245            while( 1 )
246            {
247                // exit waiting loop when loaded
248                if(  page_is_flag( page , PG_INLOAD ) ) break;
249
[18]250                // deschedule
[296]251                sched_yield( NULL );
[1]252            }
253        }
254    }
[204]255    else                          // page available in mapper
[1]256    {
257
[204]258        rwlock_rd_unlock( &mapper->lock );
[1]259    }
260
[246]261    mapper_dmsg("\n[INFO] %s : exit for page %d in mapper %x / page_desc = %x\n",
262                __FUNCTION__ , index , mapper , page );
[204]263
264    return page;
265
266}  // end mapper_get_page()
267
[1]268///////////////////////////////////////////////
269error_t mapper_release_page( mapper_t * mapper,
270                             page_t   * page )
271{
272    error_t error;
273
274    // lauch IO operation to update page to file system
[238]275    error = vfs_mapper_move_page( page , false );    // from mapper
[1]276
277    if( error )
278    {
279        printk("\n[ERROR] in %s : cannot update file system\n", __FUNCTION__ );
280        return EIO;
281    }
[18]282
[1]283    // take mapper lock in WRITE_MODE
284    rwlock_wr_lock( &mapper->lock );
285
286    // remove physical page from radix tree
[183]287    grdxt_remove( &mapper->radix , page->index );
[1]288
289    // release mapper lock from WRITE_MODE
290    rwlock_wr_unlock( &mapper->lock );
291
292    // release page to PPM
[183]293    kmem_req_t   req;
294    req.type  = KMEM_PAGE;
[1]295    req.ptr   = page;
296    kmem_free( &req );
297
298    return 0;
299
[204]300}  // end mapper_release_page()
301
[313]302///////////////////////////////////////////////////
303error_t mapper_move_user( mapper_t * mapper,
304                          bool_t     to_buffer,
305                          uint32_t   file_offset,
306                          void     * buffer,
307                          uint32_t   size )
[1]308{
[23]309    uint32_t   page_offset;    // first byte to move to/from a mapper page
310    uint32_t   page_count;     // number of bytes to move to/from a mapper page
311    uint32_t   index;          // current mapper page index
312    uint32_t   done;           // number of moved bytes
313    page_t   * page;           // current mapper page descriptor
314    uint8_t  * map_ptr;        // current mapper  address
315    uint8_t  * buf_ptr;        // current buffer  address
[330]316
[265]317    mapper_dmsg("\n[INFO] %s : enters / to_buf = %d / buffer = %x\n",
[204]318                __FUNCTION__ , to_buffer , buffer );
[1]319
[23]320    // compute offsets of first and last bytes in file
321    uint32_t min_byte = file_offset;
322    uint32_t max_byte = file_offset + size -1;
[1]323
[23]324    // compute indexes of pages for first and last byte in mapper
325    uint32_t first = min_byte >> CONFIG_PPM_PAGE_SHIFT;
326    uint32_t last  = max_byte >> CONFIG_PPM_PAGE_SHIFT;
[1]327
[23]328    done = 0;
[1]329
[23]330    // loop on pages in mapper
331    for( index = first ; index <= last ; index++ )
[1]332    {
[183]333        // compute page_offset
[23]334        if( index == first ) page_offset = min_byte & CONFIG_PPM_PAGE_MASK;
335        else                 page_offset = 0;
[1]336
[313]337        // compute number of bytes in page
[23]338        if      ( first == last  ) page_count = size;
339        else if ( index == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
340        else if ( index == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
341        else                       page_count = CONFIG_PPM_PAGE_SIZE;
[1]342
[265]343        mapper_dmsg("\n[INFO] %s : index = %d / offset = %d / count = %d\n",
344                    __FUNCTION__ , index , page_offset , page_count );
345
[23]346        // get page descriptor
347        page = mapper_get_page( mapper , index );
[1]348
349        if ( page == NULL ) return EINVAL;
350
[23]351        // compute pointer in mapper
[315]352        xptr_t base_xp = ppm_page2base( XPTR( local_cxy, page ) );
353        map_ptr = (uint8_t *)GET_PTR( base_xp ) + page_offset;
[1]354
[23]355        // compute pointer in buffer
356        buf_ptr = (uint8_t *)buffer + done;
[1]357
[265]358        mapper_dmsg("\n[INFO] %s : index = %d / buf_ptr = %x / map_ptr = %x\n",
359                    __FUNCTION__ , index , buf_ptr , map_ptr );
360
[1]361        // move fragment
[330]362        if( to_buffer )
[1]363        {
[313]364            hal_copy_to_uspace( buf_ptr , map_ptr , page_count );
[1]365        }
[330]366        else
[1]367        {
368            page_do_dirty( page );
[313]369            hal_copy_from_uspace( map_ptr , buf_ptr , page_count );
[1]370        }
371
[23]372        done += page_count;
[1]373    }
374
[204]375    mapper_dmsg("\n[INFO] %s : exit for buffer %x\n",
376                __FUNCTION__, buffer );
377
[1]378    return 0;
379
[313]380}  // end mapper_move_user()
[204]381
[313]382////////////////////////////////////////////////
383error_t mapper_move_kernel( mapper_t  *  mapper,
384                            bool_t       to_buffer,
385                            uint32_t     file_offset,
386                            xptr_t       buffer_xp,
387                            uint32_t     size )
388{
389    uint32_t   page_offset;    // first byte to move to/from a mapper page
390    uint32_t   page_count;     // number of bytes to move to/from a mapper page
391    uint32_t   index;          // current mapper page index
392    uint32_t   done;           // number of moved bytes
393    page_t   * page;           // current mapper page descriptor
394
395    uint8_t  * src_ptr;        // source buffer local pointer
396    cxy_t      src_cxy;        // source cluster
397    uint8_t  * dst_ptr;        // destination buffer local pointer
398    cxy_t      dst_cxy;        // destination cluster
[330]399
[313]400    mapper_dmsg("\n[INFO] %s : enters / to_buf = %d / buffer = %l / size = %x / cycle %d\n",
401                __FUNCTION__ , to_buffer , buffer_xp , size , hal_time_stamp() );
402
403    // compute offsets of first and last bytes in file
404    uint32_t min_byte = file_offset;
405    uint32_t max_byte = file_offset + size -1;
406
407    // compute indexes for first and last pages in mapper
408    uint32_t first = min_byte >> CONFIG_PPM_PAGE_SHIFT;
409    uint32_t last  = max_byte >> CONFIG_PPM_PAGE_SHIFT;
410
411    // get buffer cluster and local pointer
412    cxy_t     buffer_cxy = GET_CXY( buffer_xp );
413    uint8_t * buffer_ptr = (uint8_t *)GET_PTR( buffer_xp );
414
415    // compute source and destination clusters
416    if( to_buffer )
417    {
418        dst_cxy = buffer_cxy;
419        src_cxy = local_cxy;
420    }
421    else
422    {
423        src_cxy = buffer_cxy;
424        dst_cxy = local_cxy;
425    }
426
427    done = 0;
428
429    // loop on pages in mapper
430    for( index = first ; index <= last ; index++ )
431    {
432        // compute page_offset
433        if( index == first ) page_offset = min_byte & CONFIG_PPM_PAGE_MASK;
434        else                 page_offset = 0;
435
436        // compute number of bytes to move in page
437        if      ( first == last  ) page_count = size;
438        else if ( index == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
439        else if ( index == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
440        else                       page_count = CONFIG_PPM_PAGE_SIZE;
441
442        mapper_dmsg("\n[INFO] %s : page_index = %d / offset = %d / count = %d\n",
443                    __FUNCTION__ , index , page_offset , page_count );
444
445        // get page descriptor
446        page = mapper_get_page( mapper , index );
447
448        if ( page == NULL ) return EINVAL;
449
[315]450        // get page base address
[367]451        xptr_t    base_xp  = ppm_page2base( XPTR( local_cxy , page ) );
452        uint8_t * base_ptr = (uint8_t *)GET_PTR( base_xp );
[330]453
[313]454        // compute source and destination pointers
455        if( to_buffer )
456        {
[315]457            dst_ptr = buffer_ptr + done;
[367]458            src_ptr = base_ptr + page_offset;
[313]459        }
460        else
461        {
[315]462            src_ptr = buffer_ptr + done;
[367]463            dst_ptr = base_ptr + page_offset;
[313]464
465            page_do_dirty( page );
466        }
467
[334]468        mapper_dmsg("\n[INFO] %s : index = %d\n", __FUNCTION__ , index );
[313]469
470        // move fragment
471        hal_remote_memcpy( XPTR( dst_cxy , dst_ptr ), XPTR( src_cxy , src_ptr ), page_count );
[330]472
[313]473        done += page_count;
474    }
475
476    mapper_dmsg("\n[INFO] %s : exit for buffer %l / size = %x / cycle %d\n",
477                __FUNCTION__ , buffer_xp , size , hal_time_stamp() );
478
479    return 0;
480
481}  // end mapper_move_kernel_buffer()
482
Note: See TracBrowser for help on using the repository browser.