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_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 | kmem_dmsg("\n[DMSG] %s : enters / KCM type %s missing in cluster %x\n", |
---|
148 | __FUNCTION__ , kmem_type_str( type ) , local_cxy ); |
---|
149 | |
---|
150 | cluster_t * cluster = LOCAL_CLUSTER; |
---|
151 | |
---|
152 | // allocate memory for the requested KCM allocator |
---|
153 | // from the KCM allocator embedded in cluster descriptor |
---|
154 | kcm = kcm_alloc( &cluster->kcm ); |
---|
155 | |
---|
156 | if( kcm == NULL ) |
---|
157 | { |
---|
158 | printk("\n[ERROR] in %s : failed to create KCM type %d in cluster %x\n", |
---|
159 | __FUNCTION__ , type , local_cxy ); |
---|
160 | return ENOMEM; |
---|
161 | } |
---|
162 | |
---|
163 | // initialize the new KCM allocator |
---|
164 | kcm_init( kcm , type ); |
---|
165 | |
---|
166 | // register it if the KCM pointers Table |
---|
167 | cluster->kcm_tbl[type] = kcm; |
---|
168 | |
---|
169 | hal_fence(); |
---|
170 | |
---|
171 | kmem_dmsg("\n[DMSG] %s : exit / KCM type %s created in cluster %x\n", |
---|
172 | __FUNCTION__ , kmem_type_str( type ) , local_cxy ); |
---|
173 | |
---|
174 | return 0; |
---|
175 | } |
---|
176 | |
---|
177 | ///////////////////////////////////// |
---|
178 | void * kmem_alloc( kmem_req_t * req ) |
---|
179 | { |
---|
180 | cluster_t * cluster = LOCAL_CLUSTER; |
---|
181 | |
---|
182 | uint32_t type; |
---|
183 | uint32_t flags; |
---|
184 | uint32_t size; // ln( pages ) if PPM / bytes if KHM / unused if KCM |
---|
185 | void * ptr; // memory buffer if KHM or KCM / page descriptor if PPM |
---|
186 | |
---|
187 | |
---|
188 | type = req->type; |
---|
189 | size = req->size; |
---|
190 | flags = req->flags; |
---|
191 | |
---|
192 | assert( (type < KMEM_TYPES_NR) , __FUNCTION__ , "illegal KMEM request type" ); |
---|
193 | |
---|
194 | kmem_dmsg("\n[DMSG] %s : enters in cluster %x for type %s\n", |
---|
195 | __FUNCTION__ , local_cxy , kmem_type_str( type ) ); |
---|
196 | |
---|
197 | // analyse request type |
---|
198 | if( type == KMEM_PAGE ) // PPM allocator |
---|
199 | { |
---|
200 | // allocate the number of requested pages |
---|
201 | ptr = (void *)ppm_alloc_pages( size ); |
---|
202 | if( ptr == NULL ) |
---|
203 | { |
---|
204 | printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n", |
---|
205 | __FUNCTION__ , type , size , local_cxy ); |
---|
206 | return NULL; |
---|
207 | } |
---|
208 | |
---|
209 | // reset page if requested |
---|
210 | if( flags & AF_ZERO ) page_zero( (page_t *)ptr ); |
---|
211 | |
---|
212 | kmem_dmsg("\n[DMSG] %s : exit in cluster %x for type %s / page = %x / base = %x\n", |
---|
213 | __FUNCTION__, local_cxy , kmem_type_str( type ) , |
---|
214 | (intptr_t)ptr , (intptr_t)ppm_page2base( ptr ) ); |
---|
215 | } |
---|
216 | else if( type == KMEM_GENERIC ) // KHM allocator |
---|
217 | { |
---|
218 | // allocate memory from KHM |
---|
219 | ptr = khm_alloc( &cluster->khm , size ); |
---|
220 | if( ptr == NULL ) |
---|
221 | { |
---|
222 | printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n", |
---|
223 | __FUNCTION__ , type , size , local_cxy ); |
---|
224 | return NULL; |
---|
225 | } |
---|
226 | |
---|
227 | // reset memory if requested |
---|
228 | if( flags & AF_ZERO ) memset( ptr , 0 , size ); |
---|
229 | |
---|
230 | kmem_dmsg("\n[DMSG] %s : exit in cluster %x for type %s / base = %x / size = %d\n", |
---|
231 | __FUNCTION__, local_cxy , kmem_type_str( type ) , |
---|
232 | (intptr_t)ptr , req->size ); |
---|
233 | } |
---|
234 | else // KCM allocator |
---|
235 | { |
---|
236 | // initialize the KCM allocator if not already done |
---|
237 | if( cluster->kcm_tbl[type] == NULL ) |
---|
238 | { |
---|
239 | spinlock_lock( &cluster->kcm_lock ); |
---|
240 | error_t error = kmem_create_kcm( type ); |
---|
241 | spinlock_unlock( &cluster->kcm_lock ); |
---|
242 | if ( error ) return NULL; |
---|
243 | } |
---|
244 | |
---|
245 | // allocate memory from KCM |
---|
246 | ptr = kcm_alloc( cluster->kcm_tbl[type] ); |
---|
247 | if( ptr == NULL ) |
---|
248 | { |
---|
249 | printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n", |
---|
250 | __FUNCTION__ , type , size , local_cxy ); |
---|
251 | return NULL; |
---|
252 | } |
---|
253 | |
---|
254 | // reset memory if requested |
---|
255 | if( flags & AF_ZERO ) memset( ptr , 0 , kmem_type_size( type ) ); |
---|
256 | |
---|
257 | kmem_dmsg("\n[DMSG] %s : exit in cluster %x for type %s / base = %x / size = %d\n", |
---|
258 | __FUNCTION__, local_cxy , kmem_type_str( type ) , |
---|
259 | (intptr_t)ptr , kmem_type_size( type ) ); |
---|
260 | } |
---|
261 | |
---|
262 | return ptr; |
---|
263 | } |
---|
264 | |
---|
265 | ////////////////////////////////// |
---|
266 | void kmem_free( kmem_req_t * req ) |
---|
267 | { |
---|
268 | if( req->type >= KMEM_TYPES_NR ) |
---|
269 | { |
---|
270 | panic("illegal request type"); |
---|
271 | } |
---|
272 | |
---|
273 | switch(req->type) |
---|
274 | { |
---|
275 | case KMEM_PAGE: |
---|
276 | ppm_free_pages( (page_t*)req->ptr ); |
---|
277 | return; |
---|
278 | |
---|
279 | case KMEM_GENERIC: |
---|
280 | khm_free( req->ptr ); |
---|
281 | return; |
---|
282 | |
---|
283 | default: |
---|
284 | kcm_free( req->ptr ); |
---|
285 | return; |
---|
286 | } |
---|
287 | } |
---|
288 | |
---|