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

Last change on this file since 533 was 457, checked in by alain, 4 years ago

This version modifies the exec syscall and fixes a large number of small bugs.
The version number has been updated (0.1)

File size: 15.7 KB
Line 
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,2017,2018)
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
25#include <kernel_config.h>
26#include <hal_kernel_types.h>
27#include <hal_special.h>
28#include <hal_uspace.h>
29#include <grdxt.h>
30#include <rwlock.h>
31#include <printk.h>
32#include <memcpy.h>
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
43//////////////////////////////////////////////
44mapper_t * mapper_create( vfs_fs_type_t type )
45{
46    mapper_t * mapper;
47    kmem_req_t req;
48    error_t    error;
49
50    // allocate memory for associated mapper
51    req.type  = KMEM_MAPPER;
52    req.size  = sizeof(mapper_t);
53    req.flags = AF_KERNEL | AF_ZERO;
54    mapper    = (mapper_t *)kmem_alloc( &req );
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
63    mapper->refcount = 0;
64    mapper->inode    = NULL;
65
66    // initialize radix tree
67    error = grdxt_init( &mapper->radix,
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__ );
75        req.type  = KMEM_MAPPER;
76        req.ptr   = mapper;
77        kmem_free( &req );
78        return NULL;
79    }
80
81    // initialize mapper type
82    mapper->type = type;
83
84    // initialize mapper lock
85    rwlock_init(  &mapper->lock );
86
87    // initialize waiting threads xlist (empty)
88    xlist_root_init( XPTR( local_cxy , &mapper->wait_root ) );
89
90    // initialize vsegs xlist (empty)
91    xlist_root_init( XPTR( local_cxy , &mapper->vsegs_root ) );
92
93    return mapper;
94
95}  // end mapper_create()
96
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
112        if( page != NULL )
113        {
114            // remove page from mapper and release to PPM
115            error = mapper_release_page( mapper , page );
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;
134
135}  // end mapper_destroy()
136
137////////////////////////////////////////////
138page_t * mapper_get_page( mapper_t * mapper,
139                          uint32_t   index )
140{
141    kmem_req_t    req;
142    page_t      * page;
143    error_t       error;
144
145#if DEBUG_MAPPER_GET_PAGE
146uint32_t cycle = (uint32_t)hal_get_cycles();
147if( DEBUG_MAPPER_GET_PAGE < cycle )
148printk("\n[DBG] %s : thread %x enter for page %d / mapper %x / cycle %d\n",
149__FUNCTION__ , CURRENT_THREAD , index , mapper , cycle );
150#endif
151
152    thread_t * this = CURRENT_THREAD;
153
154    // take mapper lock in READ_MODE
155    rwlock_rd_lock( &mapper->lock );
156
157    // search page in radix tree
158    page = (page_t *)grdxt_lookup( &mapper->radix , index );
159
160    // test if page available in mapper
161    if( ( page == NULL) || page_is_flag( page , PG_INLOAD ) )  // page not available
162    {
163
164        // release the lock in READ_MODE and take it in WRITE_MODE
165        rwlock_rd_unlock( &mapper->lock );
166        rwlock_wr_lock( &mapper->lock );
167
168        // second test on missing page because the page status can have been modified
169        // by another thread, when passing from READ_MODE to WRITE_MODE.
170        // from this point there is no concurrent accesses to mapper.
171
172        page = grdxt_lookup( &mapper->radix , index );
173
174        if ( page == NULL )   // missing page => create it and load it from file system
175        {
176
177#if (DEBUG_MAPPER_GET_PAGE & 1)
178if( DEBUG_MAPPER_GET_PAGE < cycle )
179printk("\n[DBG] %s : missing page => load from device\n", __FUNCTION__ );
180#endif
181            // allocate one page from PPM
182            req.type  = KMEM_PAGE;
183            req.size  = 0;
184            req.flags = AF_NONE;
185            page = kmem_alloc( &req );
186
187            if( page == NULL )
188            {
189                printk("\n[ERROR] in %s : thread %x cannot allocate a page in cluster %x\n",
190                       __FUNCTION__ , this->trdid , local_cxy );
191                rwlock_wr_unlock( &mapper->lock );
192                return NULL;
193            }
194
195            // initialize the page descriptor
196            page_init( page );
197            page_set_flag( page , PG_INIT | PG_INLOAD );
198            page_refcount_up( page );
199            page->mapper = mapper;
200            page->index  = index;
201
202            // insert page in mapper radix tree
203            error = grdxt_insert( &mapper->radix, index , page );
204
205            // release mapper lock from WRITE_MODE
206            rwlock_wr_unlock( &mapper->lock );
207
208            if( error )
209            {
210                printk("\n[ERROR] in %s : thread %x cannot insert page in mapper\n",
211                       __FUNCTION__ , this->trdid );
212                mapper_release_page( mapper , page );
213                page_clear_flag( page , PG_ALL );
214                req.ptr  = page;
215                req.type = KMEM_PAGE;
216                kmem_free(&req);
217                return NULL;
218            }
219
220            // launch I/O operation to load page from file system
221            error = vfs_mapper_move_page( page, 
222                                          true );   // to mapper
223            if( error )
224            {
225                printk("\n[ERROR] in %s : thread %x cannot load page from device\n",
226                       __FUNCTION__ , this->trdid );
227                mapper_release_page( mapper , page );
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        else if( page_is_flag( page , PG_INLOAD ) )   // page is loaded by another thread
239        {
240            // release mapper lock from WRITE_MODE
241            rwlock_wr_unlock( &mapper->lock );
242
243            // wait load completion
244            while( 1 )
245            {
246                // exit waiting loop when loaded
247                if( page_is_flag( page , PG_INLOAD ) == false ) break;
248
249                // deschedule
250                sched_yield("waiting page loading");
251            }
252        }
253    }
254    else                          // page available in mapper
255    {
256        rwlock_rd_unlock( &mapper->lock );
257    }
258
259#if DEBUG_MAPPER_GET_PAGE
260cycle = (uint32_t)hal_get_cycles();
261if( DEBUG_MAPPER_GET_PAGE < cycle )
262printk("\n[DBG] %s : thread %x exit for page %d / ppn %x / cycle %d\n",
263__FUNCTION__, CURRENT_THREAD, index, ppm_page2ppn(XPTR(local_cxy, page)), cycle );
264#endif
265
266    return page;
267
268}  // end mapper_get_page()
269
270///////////////////////////////////////////////
271error_t mapper_release_page( mapper_t * mapper,
272                             page_t   * page )
273{
274    error_t error;
275
276    // lauch IO operation to update page to file system
277    error = vfs_mapper_move_page( page , false );    // from mapper
278
279    if( error )
280    {
281        printk("\n[ERROR] in %s : cannot update file system\n", __FUNCTION__ );
282        return EIO;
283    }
284
285    // take mapper lock in WRITE_MODE
286    rwlock_wr_lock( &mapper->lock );
287
288    // remove physical page from radix tree
289    grdxt_remove( &mapper->radix , page->index );
290
291    // release mapper lock from WRITE_MODE
292    rwlock_wr_unlock( &mapper->lock );
293
294    // release page to PPM
295    kmem_req_t   req;
296    req.type  = KMEM_PAGE;
297    req.ptr   = page;
298    kmem_free( &req );
299
300    return 0;
301
302}  // end mapper_release_page()
303
304///////////////////////////////////////////////////
305error_t mapper_move_user( mapper_t * mapper,
306                          bool_t     to_buffer,
307                          uint32_t   file_offset,
308                          void     * buffer,
309                          uint32_t   size )
310{
311    uint32_t   page_offset;    // first byte to move to/from a mapper page
312    uint32_t   page_count;     // number of bytes to move to/from a mapper page
313    uint32_t   index;          // current mapper page index
314    uint32_t   done;           // number of moved bytes
315    page_t   * page;           // current mapper page descriptor
316    uint8_t  * map_ptr;        // current mapper  address
317    uint8_t  * buf_ptr;        // current buffer  address
318
319#if DEBUG_MAPPER_MOVE_USER
320uint32_t cycle = (uint32_t)hal_get_cycles();
321if( DEBUG_MAPPER_MOVE_USER < cycle )
322printk("\n[DBG] %s : thread %x enter / to_buf %d / buffer %x / cycle %d\n",
323__FUNCTION__ , CURRENT_THREAD , to_buffer , buffer , cycle );
324#endif
325
326    // compute offsets of first and last bytes in file
327    uint32_t min_byte = file_offset;
328    uint32_t max_byte = file_offset + size -1;
329
330    // compute indexes of pages for first and last byte in mapper
331    uint32_t first = min_byte >> CONFIG_PPM_PAGE_SHIFT;
332    uint32_t last  = max_byte >> CONFIG_PPM_PAGE_SHIFT;
333
334    done = 0;
335
336    // loop on pages in mapper
337    for( index = first ; index <= last ; index++ )
338    {
339        // compute page_offset
340        if( index == first ) page_offset = min_byte & CONFIG_PPM_PAGE_MASK;
341        else                 page_offset = 0;
342
343        // compute number of bytes in page
344        if      ( first == last  ) page_count = size;
345        else if ( index == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
346        else if ( index == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
347        else                       page_count = CONFIG_PPM_PAGE_SIZE;
348
349#if (DEBUG_MAPPER_MOVE_USER & 1)
350if( DEBUG_MAPPER_MOVE_USER < cycle )
351printk("\n[DBG] %s : index = %d / offset = %d / count = %d\n",
352__FUNCTION__ , index , page_offset , page_count );
353#endif
354
355        // get page descriptor
356        page = mapper_get_page( mapper , index );
357
358        if ( page == NULL ) return EINVAL;
359
360        // compute pointer in mapper
361        xptr_t base_xp = ppm_page2base( XPTR( local_cxy, page ) );
362        map_ptr = (uint8_t *)GET_PTR( base_xp ) + page_offset;
363
364        // compute pointer in buffer
365        buf_ptr = (uint8_t *)buffer + done;
366
367        // move fragment
368        if( to_buffer )
369        {
370            hal_copy_to_uspace( buf_ptr , map_ptr , page_count );
371        }
372        else
373        {
374            page_do_dirty( page );
375            hal_copy_from_uspace( map_ptr , buf_ptr , page_count );
376        }
377
378        done += page_count;
379    }
380
381#if DEBUG_MAPPER_MOVE_USER
382cycle = (uint32_t)hal_get_cycles();
383if( DEBUG_MAPPER_MOVE_USER < cycle )
384printk("\n[DBG] %s : thread %x exit / to_buf %d / buffer %x / cycle %d\n",
385__FUNCTION__ , CURRENT_THREAD , to_buffer , buffer , cycle );
386#endif
387
388    return 0;
389
390}  // end mapper_move_user()
391
392////////////////////////////////////////////////
393error_t mapper_move_kernel( mapper_t  *  mapper,
394                            bool_t       to_buffer,
395                            uint32_t     file_offset,
396                            xptr_t       buffer_xp,
397                            uint32_t     size )
398{
399    uint32_t   page_offset;    // first byte to move to/from a mapper page
400    uint32_t   page_count;     // number of bytes to move to/from a mapper page
401    uint32_t   index;          // current mapper page index
402    uint32_t   done;           // number of moved bytes
403    page_t   * page;           // current mapper page descriptor
404
405    uint8_t  * src_ptr;        // source buffer local pointer
406    cxy_t      src_cxy;        // source cluster
407    uint8_t  * dst_ptr;        // destination buffer local pointer
408    cxy_t      dst_cxy;        // destination cluster
409
410    // get buffer cluster and local pointer
411    cxy_t     buffer_cxy = GET_CXY( buffer_xp );
412    uint8_t * buffer_ptr = (uint8_t *)GET_PTR( buffer_xp );
413
414#if DEBUG_MAPPER_MOVE_KERNEL
415uint32_t cycle = (uint32_t)hal_get_cycles();
416if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
417printk("\n[DBG] %s : thread %x enter / to_buf %d / buf_cxy %x / buf_ptr %x / cycle %d\n",
418__FUNCTION__ , CURRENT_THREAD , to_buffer , buffer_cxy , buffer_ptr , cycle );
419#endif
420
421    // compute offsets of first and last bytes in file
422    uint32_t min_byte = file_offset;
423    uint32_t max_byte = file_offset + size -1;
424
425    // compute indexes for first and last pages in mapper
426    uint32_t first = min_byte >> CONFIG_PPM_PAGE_SHIFT;
427    uint32_t last  = max_byte >> CONFIG_PPM_PAGE_SHIFT;
428
429#if (DEBUG_MAPPER_MOVE_KERNEL & 1)
430if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
431printk("\n[DBG] %s : first_page %d / last_page %d\n", __FUNCTION__, first, last );
432#endif
433
434    // compute source and destination clusters
435    if( to_buffer )
436    {
437        dst_cxy = buffer_cxy;
438        src_cxy = local_cxy;
439    }
440    else
441    {
442        src_cxy = buffer_cxy;
443        dst_cxy = local_cxy;
444    }
445
446    done = 0;
447
448    // loop on pages in mapper
449    for( index = first ; index <= last ; index++ )
450    {
451        // compute page_offset
452        if( index == first ) page_offset = min_byte & CONFIG_PPM_PAGE_MASK;
453        else                 page_offset = 0;
454
455        // compute number of bytes to move in page
456        if      ( first == last  ) page_count = size;
457        else if ( index == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
458        else if ( index == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
459        else                       page_count = CONFIG_PPM_PAGE_SIZE;
460
461#if (DEBUG_MAPPER_MOVE_KERNEL & 1)
462if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
463printk("\n[DBG] %s : page_index = %d / offset = %d / bytes = %d\n",
464__FUNCTION__ , index , page_offset , page_count );
465#endif
466
467        // get page descriptor
468        page = mapper_get_page( mapper , index );
469
470        if ( page == NULL ) return EINVAL;
471
472        // get page base address
473        xptr_t    base_xp  = ppm_page2base( XPTR( local_cxy , page ) );
474        uint8_t * base_ptr = (uint8_t *)GET_PTR( base_xp );
475
476        // compute source and destination pointers
477        if( to_buffer )
478        {
479            dst_ptr = buffer_ptr + done;
480            src_ptr = base_ptr + page_offset;
481        }
482        else
483        {
484            src_ptr = buffer_ptr + done;
485            dst_ptr = base_ptr + page_offset;
486
487            page_do_dirty( page );
488        }
489
490        // move fragment
491        hal_remote_memcpy( XPTR( dst_cxy , dst_ptr ), XPTR( src_cxy , src_ptr ), page_count );
492
493        done += page_count;
494    }
495
496#if DEBUG_MAPPER_MOVE_KERNEL
497cycle = (uint32_t)hal_get_cycles();
498if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
499printk("\n[DBG] %s : thread %x exit / to_buf %d / buf_cxy %x / buf_ptr %x / cycle %d\n",
500__FUNCTION__ , CURRENT_THREAD , to_buffer , buffer_cxy , buffer_ptr , cycle );
501#endif
502
503    return 0;
504
505}  // end mapper_move_kernel()
506
Note: See TracBrowser for help on using the repository browser.