source: trunk/kernel/mm/vseg.c @ 635

Last change on this file since 635 was 635, checked in by alain, 15 months ago

This version is a major evolution: The physical memory allocators,
defined in the kmem.c, ppm.c, and kcm.c files have been modified
to support remote accesses. The RPCs that were previously user
to allocate physical memory in a remote cluster have been removed.
This has been done to cure a dead-lock in case of concurrent page-faults.

This version 2.2 has been tested on a (4 clusters / 2 cores per cluster)
TSAR architecture, for both the "sort" and the "fft" applications.

File size: 6.4 KB
Line 
1/*
2 * vseg.c - virtual segment (vseg) related operations
3 *
4 * Authors   Alain Greiner (2016,2017,2018,2019)
5 *
6 * Copyright (c) UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#include <hal_kernel_types.h>
25#include <hal_special.h>
26#include <hal_remote.h>
27#include <list.h>
28#include <errno.h>
29#include <printk.h>
30#include <bits.h>
31#include <thread.h>
32#include <process.h>
33#include <ppm.h>
34#include <mapper.h>
35#include <vfs.h>
36#include <page.h>
37#include <vmm.h>
38#include <kmem.h>
39#include <vseg.h>
40
41////////////////////////////////////////////////////////////////////////////////////////
42//   global variables for display / must be consistent with enum in "vseg.h"
43////////////////////////////////////////////////////////////////////////////////////////
44
45
46//////////////////////////////////////////
47char * vseg_type_str( uint32_t vseg_type )
48{
49        if     ( vseg_type == VSEG_TYPE_CODE   ) return "CODE";
50        else if( vseg_type == VSEG_TYPE_DATA   ) return "DATA";
51        else if( vseg_type == VSEG_TYPE_STACK  ) return "STAK";
52        else if( vseg_type == VSEG_TYPE_ANON   ) return "ANON";
53        else if( vseg_type == VSEG_TYPE_FILE   ) return "FILE";
54        else if( vseg_type == VSEG_TYPE_REMOTE ) return "REMO";
55        else if( vseg_type == VSEG_TYPE_KCODE  ) return "KCOD";
56        else if( vseg_type == VSEG_TYPE_KDATA  ) return "KDAT";
57        else if( vseg_type == VSEG_TYPE_KDEV   ) return "KDEV";
58    else                                     return "undefined";
59}
60
61///////////////////////////
62vseg_t * vseg_alloc( void )
63{
64    kmem_req_t   req;
65
66    req.type  = KMEM_KCM;
67        req.order = bits_log2( sizeof(vseg_t) );
68        req.flags = AF_KERNEL | AF_ZERO;
69
70    return kmem_alloc( &req );
71}
72
73///////////////////////////////
74void vseg_free( vseg_t * vseg )
75{
76    kmem_req_t  req;
77
78        req.type = KMEM_KCM;
79        req.ptr  = vseg;
80        kmem_free( &req );
81}
82
83///////////////////////////////////
84void vseg_init( vseg_t      * vseg,
85                vseg_type_t   type,
86                    intptr_t      base,
87                uint32_t      size,
88                vpn_t         vpn_base,
89                vpn_t         vpn_size,
90                        uint32_t      file_offset,
91                uint32_t      file_size,
92                xptr_t        mapper_xp,
93                cxy_t         cxy )
94{
95    vseg->type        = type;
96        vseg->min         = base;
97        vseg->max         = base + size;
98    vseg->vpn_base    = vpn_base;
99        vseg->vpn_size    = vpn_size;
100    vseg->file_offset = file_offset;
101    vseg->file_size   = file_size;
102        vseg->mapper_xp   = mapper_xp;
103    vseg->cxy         = cxy;
104
105    // set vseg flags depending on type
106        if     ( type == VSEG_TYPE_CODE )
107    {
108        vseg->flags = VSEG_USER    |
109                      VSEG_EXEC    |
110                      VSEG_CACHE   |
111                      VSEG_PRIVATE ;
112    }
113    else if( type == VSEG_TYPE_STACK )
114    {
115        vseg->flags = VSEG_USER    |
116                      VSEG_WRITE   |
117                      VSEG_CACHE   |
118                      VSEG_PRIVATE ;
119    }
120    else if( type == VSEG_TYPE_DATA )
121    {
122        vseg->flags = VSEG_USER    |
123                      VSEG_WRITE   |
124                      VSEG_CACHE   |
125                      VSEG_DISTRIB ;
126    }
127    else if( type == VSEG_TYPE_REMOTE )
128    {
129        vseg->flags = VSEG_USER    |
130                      VSEG_WRITE   |
131                      VSEG_CACHE   ;
132    }
133    else if( type == VSEG_TYPE_ANON )
134    {
135        vseg->flags = VSEG_USER    |
136                      VSEG_WRITE   |
137                      VSEG_CACHE; 
138    }
139    else if( type == VSEG_TYPE_FILE )
140    {
141        vseg->flags = VSEG_USER    |
142                      VSEG_WRITE   |
143                      VSEG_CACHE   ;
144    }
145    else if( type == VSEG_TYPE_KCODE )
146    {
147        vseg->flags = VSEG_EXEC    |
148                      VSEG_CACHE   |
149                      VSEG_PRIVATE ;
150    }
151    else if( type == VSEG_TYPE_KDATA )
152    {
153        vseg->flags = VSEG_CACHE   |
154                      VSEG_WRITE   ;
155    }
156    else if( type == VSEG_TYPE_KDEV )
157    {
158        vseg->flags = VSEG_WRITE   ;
159    }
160    else
161    {
162            assert( false , "illegal vseg type\n" );
163    }
164
165}  // end vseg_init()
166
167//////////////////////////////////////////
168void vseg_init_from_ref( vseg_t    * vseg,
169                         xptr_t      ref_xp )
170{
171    // get remote vseg cluster and pointer
172    cxy_t    cxy = (cxy_t   )GET_CXY( ref_xp );
173    vseg_t * ptr = (vseg_t *)GET_PTR( ref_xp );
174
175    // initialize vseg with remote_read access
176    vseg->type        =           hal_remote_l32( XPTR( cxy , &ptr->type        ) );
177    vseg->min         = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->min         ) );
178    vseg->max         = (intptr_t)hal_remote_lpt( XPTR( cxy , &ptr->max         ) );
179    vseg->vpn_base    =           hal_remote_l32( XPTR( cxy , &ptr->vpn_base    ) );
180    vseg->vpn_size    =           hal_remote_l32( XPTR( cxy , &ptr->vpn_size    ) );
181    vseg->flags       =           hal_remote_l32( XPTR( cxy , &ptr->flags       ) );
182    vseg->file_offset =           hal_remote_l32( XPTR( cxy , &ptr->file_offset ) );
183    vseg->file_size   =           hal_remote_l32( XPTR( cxy , &ptr->file_size   ) );
184        vseg->mapper_xp   = (xptr_t)  hal_remote_l64( XPTR( cxy , &ptr->mapper_xp   ) );
185
186    switch (vseg->type)
187    {
188        case VSEG_TYPE_DATA:      // unused
189        {
190            vseg->cxy = 0xffff;
191            break;
192        }
193        case VSEG_TYPE_CODE:      // always local
194        case VSEG_TYPE_STACK: 
195        case VSEG_TYPE_KCODE:
196        {
197            vseg->cxy = local_cxy;
198            break;
199        }
200        case VSEG_TYPE_ANON:      // intrinsic
201        case VSEG_TYPE_FILE:
202        case VSEG_TYPE_REMOTE: 
203        case VSEG_TYPE_KDEV:
204        case VSEG_TYPE_KDATA:
205        {
206            vseg->cxy = (cxy_t) hal_remote_l32( XPTR(cxy, &ptr->cxy) );
207            break;
208        }
209        default: 
210        {
211            assert( false, "Illegal vseg type" );
212            break;
213        }
214    }
215}
216
217
Note: See TracBrowser for help on using the repository browser.