1 | /* |
---|
2 | * kmem.c - kernel memory allocator implementation. |
---|
3 | * |
---|
4 | * Authors Ghassan Almaless (2008,2009,2010,2011,2012) |
---|
5 | * Mohamed Lamine Karaoui (2015) |
---|
6 | * Alain Greiner (2016) |
---|
7 | * |
---|
8 | * Copyright (c) UPMC Sorbonne Universites |
---|
9 | * |
---|
10 | * This file is part of ALMOS-MKH. |
---|
11 | * |
---|
12 | * ALMOS-MKH is free software; you can redistribute it and/or modify it |
---|
13 | * under the terms of the GNU General Public License as published by |
---|
14 | * the Free Software Foundation; version 2.0 of the License. |
---|
15 | * |
---|
16 | * ALMOS-MKH is distributed in the hope that it will be useful, but |
---|
17 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
---|
19 | * General Public License for more details. |
---|
20 | * |
---|
21 | * You should have received a copy of the GNU General Public License |
---|
22 | * along with ALMOS-MKH; if not, write to the Free Software Foundation, |
---|
23 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
---|
24 | */ |
---|
25 | |
---|
26 | #include <kernel_config.h> |
---|
27 | #include <hal_kernel_types.h> |
---|
28 | #include <hal_special.h> |
---|
29 | #include <printk.h> |
---|
30 | #include <spinlock.h> |
---|
31 | #include <readlock.h> |
---|
32 | #include <memcpy.h> |
---|
33 | #include <khm.h> |
---|
34 | #include <ppm.h> |
---|
35 | #include <page.h> |
---|
36 | #include <cluster.h> |
---|
37 | #include <thread.h> |
---|
38 | #include <process.h> |
---|
39 | #include <chdev.h> |
---|
40 | #include <mapper.h> |
---|
41 | #include <vfs.h> |
---|
42 | #include <fatfs.h> |
---|
43 | #include <ramfs.h> |
---|
44 | #include <remote_sem.h> |
---|
45 | #include <remote_barrier.h> |
---|
46 | #include <remote_mutex.h> |
---|
47 | #include <remote_condvar.h> |
---|
48 | #include <mapper.h> |
---|
49 | #include <grdxt.h> |
---|
50 | #include <vseg.h> |
---|
51 | #include <kmem.h> |
---|
52 | |
---|
53 | /////////////////////////// |
---|
54 | void kmem_print_kcm_table() |
---|
55 | { |
---|
56 | uint32_t index; |
---|
57 | kcm_t * kcm; |
---|
58 | cluster_t * cluster = LOCAL_CLUSTER; |
---|
59 | |
---|
60 | printk("\n *** KCM Pointers Table ***\n"); |
---|
61 | |
---|
62 | for( index = 0 ; index < KMEM_TYPES_NR ; index++ ) |
---|
63 | { |
---|
64 | kcm = cluster->kcm_tbl[index]; |
---|
65 | if( kcm != NULL ) |
---|
66 | { |
---|
67 | if( index == kcm->type ) |
---|
68 | { |
---|
69 | printk(" - KCM[%s] (at address %x) is OK\n", |
---|
70 | kmem_type_str( index ) , (intptr_t)kcm ); |
---|
71 | } |
---|
72 | else |
---|
73 | { |
---|
74 | printk(" - KCM[%s] (at address %x) is KO : has type %s\n", |
---|
75 | kmem_type_str( index ) , (intptr_t)kcm , kmem_type_str( kcm->type ) ); |
---|
76 | } |
---|
77 | } |
---|
78 | } |
---|
79 | } |
---|
80 | |
---|
81 | ///////////////////////////////////////// |
---|
82 | uint32_t kmem_type_size( uint32_t type ) |
---|
83 | { |
---|
84 | if ( type == KMEM_PAGE ) return CONFIG_PPM_PAGE_SIZE; |
---|
85 | else if( type == KMEM_GENERIC ) return 0; |
---|
86 | else if( type == KMEM_KCM ) return sizeof( kcm_t ); |
---|
87 | else if( type == KMEM_VSEG ) return sizeof( vseg_t ); |
---|
88 | else if( type == KMEM_DEVICE ) return sizeof( chdev_t ); |
---|
89 | else if( type == KMEM_MAPPER ) return sizeof( mapper_t ); |
---|
90 | else if( type == KMEM_PROCESS ) return sizeof( process_t ); |
---|
91 | else if( type == KMEM_CPU_CTX ) return CONFIG_CPU_CTX_SIZE; |
---|
92 | else if( type == KMEM_FPU_CTX ) return CONFIG_FPU_CTX_SIZE; |
---|
93 | else if( type == KMEM_BARRIER ) return sizeof( remote_barrier_t ); |
---|
94 | |
---|
95 | else if( type == KMEM_DEVFS_CTX ) return sizeof( fatfs_ctx_t ); |
---|
96 | else if( type == KMEM_FATFS_CTX ) return sizeof( fatfs_ctx_t ); |
---|
97 | else if( type == KMEM_VFS_CTX ) return sizeof( vfs_ctx_t ); |
---|
98 | else if( type == KMEM_VFS_INODE ) return sizeof( vfs_inode_t ); |
---|
99 | else if( type == KMEM_VFS_DENTRY ) return sizeof( vfs_dentry_t ); |
---|
100 | else if( type == KMEM_VFS_FILE ) return sizeof( vfs_file_t ); |
---|
101 | else if( type == KMEM_SEM ) return sizeof( remote_sem_t ); |
---|
102 | else if( type == KMEM_CONDVAR ) return sizeof( remote_condvar_t ); |
---|
103 | else if( type == KMEM_MUTEX ) return sizeof( remote_mutex_t ); |
---|
104 | else if( type == KMEM_512_BYTES ) return 512; |
---|
105 | |
---|
106 | else return 0; |
---|
107 | } |
---|
108 | |
---|
109 | ///////////////////////////////////// |
---|
110 | char * kmem_type_str( uint32_t type ) |
---|
111 | { |
---|
112 | if ( type == KMEM_PAGE ) return "KMEM_PAGE"; |
---|
113 | else if( type == KMEM_GENERIC ) return "KMEM_GENERIC"; |
---|
114 | else if( type == KMEM_KCM ) return "KMEM_KCM"; |
---|
115 | else if( type == KMEM_VSEG ) return "KMEM_VSEG"; |
---|
116 | else if( type == KMEM_DEVICE ) return "KMEM_DEVICE"; |
---|
117 | else if( type == KMEM_MAPPER ) return "KMEM_MAPPER"; |
---|
118 | else if( type == KMEM_PROCESS ) return "KMEM_PROCESS"; |
---|
119 | else if( type == KMEM_CPU_CTX ) return "KMEM_CPU_CTX"; |
---|
120 | else if( type == KMEM_FPU_CTX ) return "KMEM_FPU_CTX"; |
---|
121 | else if( type == KMEM_BARRIER ) return "KMEM_BARRIER"; |
---|
122 | |
---|
123 | else if( type == KMEM_DEVFS_CTX ) return "KMEM_DEVFS_CTX"; |
---|
124 | else if( type == KMEM_FATFS_CTX ) return "KMEM_FATFS_CTX"; |
---|
125 | else if( type == KMEM_VFS_CTX ) return "KMEM_VFS_CTX"; |
---|
126 | else if( type == KMEM_VFS_INODE ) return "KMEM_VFS_INODE"; |
---|
127 | else if( type == KMEM_VFS_DENTRY ) return "KMEM_VFS_DENTRY"; |
---|
128 | else if( type == KMEM_VFS_FILE ) return "KMEM_VFS_FILE"; |
---|
129 | else if( type == KMEM_SEM ) return "KMEM_SEM"; |
---|
130 | else if( type == KMEM_CONDVAR ) return "KMEM_CONDVAR"; |
---|
131 | else if( type == KMEM_MUTEX ) return "KMEM_MUTEX"; |
---|
132 | else if( type == KMEM_512_BYTES ) return "KMEM_512_BYTES"; |
---|
133 | |
---|
134 | else return "undefined"; |
---|
135 | } |
---|
136 | |
---|
137 | ///////////////////////////////////////////////////////////////////////////////////////////// |
---|
138 | // This static function dynamically allocates and initializes a specific KCM allocator. |
---|
139 | // It uses the KCM allocator embedded in cluster manager, initialized by cluster_init(). |
---|
140 | ///////////////////////////////////////////////////////////////////////////////////////////// |
---|
141 | static error_t kmem_create_kcm( uint32_t type ) |
---|
142 | { |
---|
143 | kcm_t * kcm; |
---|
144 | |
---|
145 | assert( ((type > 1) && (type < KMEM_TYPES_NR) ) , __FUNCTION__ , "illegal KCM type" ); |
---|
146 | |
---|
147 | #if DEBUG_KMEM |
---|
148 | uint32_t cycle = (uint32_t)hal_get_cycles(); |
---|
149 | if( DEBUG_KMEM < cycle ) |
---|
150 | printk("\n[DBG] %s : thread %x enter / KCM type %s missing in cluster %x / cycle %d\n", |
---|
151 | __FUNCTION__, CURRENT_THREAD, kmem_type_str( type ), local_cxy, cycle ); |
---|
152 | #endif |
---|
153 | |
---|
154 | cluster_t * cluster = LOCAL_CLUSTER; |
---|
155 | |
---|
156 | // allocate memory for the requested KCM allocator |
---|
157 | // from the KCM allocator embedded in cluster descriptor |
---|
158 | kcm = kcm_alloc( &cluster->kcm ); |
---|
159 | |
---|
160 | if( kcm == NULL ) |
---|
161 | { |
---|
162 | printk("\n[ERROR] in %s : failed to create KCM type %d in cluster %x\n", |
---|
163 | __FUNCTION__ , type , local_cxy ); |
---|
164 | return ENOMEM; |
---|
165 | } |
---|
166 | |
---|
167 | // initialize the new KCM allocator |
---|
168 | kcm_init( kcm , type ); |
---|
169 | |
---|
170 | // register it if the KCM pointers Table |
---|
171 | cluster->kcm_tbl[type] = kcm; |
---|
172 | |
---|
173 | hal_fence(); |
---|
174 | |
---|
175 | #if DEBUG_KMEM |
---|
176 | cycle = (uint32_t)hal_get_cycles(); |
---|
177 | if( DEBUG_KMEM < cycle ) |
---|
178 | printk("\n[DBG] %s : thread %x exit / cycle %d\n", |
---|
179 | __FUNCTION__, CURRENT_THREAD, cycle ); |
---|
180 | #endif |
---|
181 | |
---|
182 | return 0; |
---|
183 | } |
---|
184 | |
---|
185 | ///////////////////////////////////// |
---|
186 | void * kmem_alloc( kmem_req_t * req ) |
---|
187 | { |
---|
188 | cluster_t * cluster = LOCAL_CLUSTER; |
---|
189 | |
---|
190 | uint32_t type; |
---|
191 | uint32_t flags; |
---|
192 | uint32_t size; // ln( pages ) if PPM / bytes if KHM / unused if KCM |
---|
193 | void * ptr; // memory buffer if KHM or KCM / page descriptor if PPM |
---|
194 | |
---|
195 | |
---|
196 | type = req->type; |
---|
197 | size = req->size; |
---|
198 | flags = req->flags; |
---|
199 | |
---|
200 | assert( (type < KMEM_TYPES_NR) , __FUNCTION__ , "illegal KMEM request type" ); |
---|
201 | |
---|
202 | #if DEBUG_KMEM |
---|
203 | uint32_t cycle = (uint32_t)hal_get_cycles(); |
---|
204 | if( DEBUG_KMEM < cycle ) |
---|
205 | printk("\n[DBG] %s : thread %x enter / type %s / cluster %x / cycle %d\n", |
---|
206 | __FUNCTION__, CURRENT_THREAD, kmem_type_str( type ), local_cxy, cycle ); |
---|
207 | #endif |
---|
208 | |
---|
209 | // analyse request type |
---|
210 | if( type == KMEM_PAGE ) // PPM allocator |
---|
211 | { |
---|
212 | // allocate the number of requested pages |
---|
213 | ptr = (void *)ppm_alloc_pages( size ); |
---|
214 | if( ptr == NULL ) |
---|
215 | { |
---|
216 | printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n", |
---|
217 | __FUNCTION__ , type , size , local_cxy ); |
---|
218 | return NULL; |
---|
219 | } |
---|
220 | |
---|
221 | // reset page if requested |
---|
222 | if( flags & AF_ZERO ) page_zero( (page_t *)ptr ); |
---|
223 | |
---|
224 | #if DEBUG_KMEM |
---|
225 | cycle = (uint32_t)hal_get_cycles(); |
---|
226 | if( DEBUG_KMEM < cycle ) |
---|
227 | printk("\n[DBG] %s : thread %x exit / %d page(s) allocated / ppn %x / cycle %d\n", |
---|
228 | __FUNCTION__, CURRENT_THREAD, 1<<size, ppm_page2ppn(XPTR(local_cxy,ptr)), cycle ); |
---|
229 | #endif |
---|
230 | |
---|
231 | } |
---|
232 | else if( type == KMEM_GENERIC ) // KHM allocator |
---|
233 | { |
---|
234 | // allocate memory from KHM |
---|
235 | ptr = khm_alloc( &cluster->khm , size ); |
---|
236 | if( ptr == NULL ) |
---|
237 | { |
---|
238 | printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n", |
---|
239 | __FUNCTION__ , type , size , local_cxy ); |
---|
240 | return NULL; |
---|
241 | } |
---|
242 | |
---|
243 | // reset memory if requested |
---|
244 | if( flags & AF_ZERO ) memset( ptr , 0 , size ); |
---|
245 | |
---|
246 | #if DEBUG_KMEM |
---|
247 | cycle = (uint32_t)hal_get_cycles(); |
---|
248 | if( DEBUG_KMEM < cycle ) |
---|
249 | printk("\n[DBG] %s : thread %x exit / type %s allocated / base %x / size %d / cycle %d\n", |
---|
250 | __FUNCTION__, CURRENT_THREAD, kmem_type_str( type ), (intptr_t)ptr, size, cycle ); |
---|
251 | #endif |
---|
252 | |
---|
253 | } |
---|
254 | else // KCM allocator |
---|
255 | { |
---|
256 | // initialize the KCM allocator if not already done |
---|
257 | if( cluster->kcm_tbl[type] == NULL ) |
---|
258 | { |
---|
259 | spinlock_lock( &cluster->kcm_lock ); |
---|
260 | error_t error = kmem_create_kcm( type ); |
---|
261 | spinlock_unlock( &cluster->kcm_lock ); |
---|
262 | if ( error ) return NULL; |
---|
263 | } |
---|
264 | |
---|
265 | // allocate memory from KCM |
---|
266 | ptr = kcm_alloc( cluster->kcm_tbl[type] ); |
---|
267 | if( ptr == NULL ) |
---|
268 | { |
---|
269 | printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n", |
---|
270 | __FUNCTION__ , type , size , local_cxy ); |
---|
271 | return NULL; |
---|
272 | } |
---|
273 | |
---|
274 | // reset memory if requested |
---|
275 | if( flags & AF_ZERO ) memset( ptr , 0 , kmem_type_size( type ) ); |
---|
276 | |
---|
277 | #if DEBUG_KMEM |
---|
278 | cycle = (uint32_t)hal_get_cycles(); |
---|
279 | if( DEBUG_KMEM < cycle ) |
---|
280 | printk("\n[DBG] %s : thread %x exit / type %s allocated / base %x / size %d / cycle %d\n", |
---|
281 | __FUNCTION__, CURRENT_THREAD, kmem_type_str(type), (intptr_t)ptr, |
---|
282 | kmem_type_size(type), cycle ); |
---|
283 | #endif |
---|
284 | |
---|
285 | } |
---|
286 | |
---|
287 | return ptr; |
---|
288 | } |
---|
289 | |
---|
290 | ////////////////////////////////// |
---|
291 | void kmem_free( kmem_req_t * req ) |
---|
292 | { |
---|
293 | if( req->type >= KMEM_TYPES_NR ) |
---|
294 | { |
---|
295 | assert( false , __FUNCTION__ , "illegal request type\n" ); |
---|
296 | } |
---|
297 | |
---|
298 | switch(req->type) |
---|
299 | { |
---|
300 | case KMEM_PAGE: |
---|
301 | ppm_free_pages( (page_t*)req->ptr ); |
---|
302 | return; |
---|
303 | |
---|
304 | case KMEM_GENERIC: |
---|
305 | khm_free( req->ptr ); |
---|
306 | return; |
---|
307 | |
---|
308 | default: |
---|
309 | kcm_free( req->ptr ); |
---|
310 | return; |
---|
311 | } |
---|
312 | } |
---|
313 | |
---|