source: trunk/kernel/mm/kmem.c @ 567

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

Complete restructuration of kernel locks.
File size: 9.9 KB
Line 
1/*
2 * kmem.c - kernel memory allocator implementation.
3 *
4 * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
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 <printk.h>
29#include <busylock.h>
30#include <memcpy.h>
31#include <khm.h>
32#include <ppm.h>
33#include <page.h>
34#include <cluster.h>
35#include <thread.h>
36#include <process.h>
37#include <chdev.h>
38#include <mapper.h>
39#include <vfs.h>
40#include <fatfs.h>
41#include <ramfs.h>
42#include <remote_sem.h>
43#include <remote_barrier.h>
44#include <remote_mutex.h>
45#include <remote_condvar.h>
46#include <mapper.h>
47#include <grdxt.h>
48#include <vseg.h>
49#include <kmem.h>
50
51/////////////////////////////////
52void kmem_print_kcm_table( void )
53{
54        uint32_t    index;
55        kcm_t     * kcm;
56        cluster_t * cluster = LOCAL_CLUSTER;
57
58        printk("\n    *** KCM Pointers Table ***\n");
59
60        for( index = 0 ; index < KMEM_TYPES_NR ; index++ )
61        {
62                kcm = cluster->kcm_tbl[index];
63                if( kcm != NULL )
64                {
65                        if( index == kcm->type )
66                        {
67                                printk("     - KCM[%s] (at address %x) is OK\n",
68                                       kmem_type_str( index ) , (intptr_t)kcm );
69                        }
70                        else
71                        {
72                                printk("     - KCM[%s] (at address %x) is KO : has type %s\n",
73                                       kmem_type_str( index ) , (intptr_t)kcm , kmem_type_str( kcm->type ) );
74                        }
75                }
76        }
77}
78
79/////////////////////////////////////////
80uint32_t  kmem_type_size( uint32_t type )
81{
82    if     ( type == KMEM_PAGE )          return CONFIG_PPM_PAGE_SIZE;
83    else if( type == KMEM_GENERIC )       return 0;
84    else if( type == KMEM_KCM )           return sizeof( kcm_t );
85    else if( type == KMEM_VSEG )          return sizeof( vseg_t );
86    else if( type == KMEM_DEVICE )        return sizeof( chdev_t );
87    else if( type == KMEM_MAPPER )        return sizeof( mapper_t );
88    else if( type == KMEM_PROCESS )       return sizeof( process_t );
89    else if( type == KMEM_CPU_CTX )       return CONFIG_CPU_CTX_SIZE;
90    else if( type == KMEM_FPU_CTX )       return CONFIG_FPU_CTX_SIZE;
91    else if( type == KMEM_BARRIER )       return sizeof( remote_barrier_t );
92
93    else if( type == KMEM_DEVFS_CTX )     return sizeof( fatfs_ctx_t );
94    else if( type == KMEM_FATFS_CTX )     return sizeof( fatfs_ctx_t );
95    else if( type == KMEM_VFS_CTX )       return sizeof( vfs_ctx_t );
96    else if( type == KMEM_VFS_INODE )     return sizeof( vfs_inode_t );
97    else if( type == KMEM_VFS_DENTRY )    return sizeof( vfs_dentry_t );
98    else if( type == KMEM_VFS_FILE )      return sizeof( vfs_file_t );
99    else if( type == KMEM_SEM )           return sizeof( remote_sem_t );
100    else if( type == KMEM_CONDVAR )       return sizeof( remote_condvar_t );
101    else if( type == KMEM_MUTEX )         return sizeof( remote_mutex_t );
102        else if( type == KMEM_512_BYTES )     return 512;
103
104        else                                  return 0;
105}
106
107/////////////////////////////////////
108char * kmem_type_str( uint32_t type )
109{
110        if     ( type == KMEM_PAGE )          return "KMEM_PAGE";
111        else if( type == KMEM_GENERIC )       return "KMEM_GENERIC";
112        else if( type == KMEM_KCM )           return "KMEM_KCM";
113        else if( type == KMEM_VSEG )          return "KMEM_VSEG";
114        else if( type == KMEM_DEVICE )        return "KMEM_DEVICE";
115        else if( type == KMEM_MAPPER )        return "KMEM_MAPPER";
116        else if( type == KMEM_PROCESS )       return "KMEM_PROCESS";
117        else if( type == KMEM_CPU_CTX )       return "KMEM_CPU_CTX";
118        else if( type == KMEM_FPU_CTX )       return "KMEM_FPU_CTX";
119        else if( type == KMEM_BARRIER )       return "KMEM_BARRIER";
120
121    else if( type == KMEM_DEVFS_CTX )     return "KMEM_DEVFS_CTX";
122    else if( type == KMEM_FATFS_CTX )     return "KMEM_FATFS_CTX";
123    else if( type == KMEM_VFS_CTX )       return "KMEM_VFS_CTX";
124    else if( type == KMEM_VFS_INODE )     return "KMEM_VFS_INODE";
125    else if( type == KMEM_VFS_DENTRY )    return "KMEM_VFS_DENTRY";
126    else if( type == KMEM_VFS_FILE )      return "KMEM_VFS_FILE";
127    else if( type == KMEM_SEM )           return "KMEM_SEM";
128    else if( type == KMEM_CONDVAR )       return "KMEM_CONDVAR";
129    else if( type == KMEM_MUTEX )         return "KMEM_MUTEX";
130        else if( type == KMEM_512_BYTES )     return "KMEM_512_BYTES";
131
132        else                                  return "undefined";
133}
134
135/////////////////////////////////////////////////////////////////////////////////////////////
136// This static function dynamically allocates and initializes a specific KCM allocator.
137// It uses the KCM allocator embedded in cluster manager, initialized by cluster_init().
138/////////////////////////////////////////////////////////////////////////////////////////////
139static error_t kmem_create_kcm( uint32_t type )
140{
141        kcm_t    * kcm;
142
143        assert( ((type > 1) && (type < KMEM_TYPES_NR) ) , "illegal KCM type" );
144
145#if DEBUG_KMEM
146uint32_t cycle = (uint32_t)hal_get_cycles();
147if( DEBUG_KMEM < cycle )
148printk("\n[DBG] %s : thread %x enter / KCM type %s missing in cluster %x / cycle %d\n",
149__FUNCTION__, CURRENT_THREAD, kmem_type_str( type ), local_cxy, cycle );
150#endif
151
152        cluster_t * cluster = LOCAL_CLUSTER;
153
154        // allocate memory for the requested KCM allocator
155        // from the KCM allocator embedded in cluster descriptor
156        kcm = kcm_alloc( &cluster->kcm );
157
158        if( kcm == NULL )
159        {
160                printk("\n[ERROR] in %s : failed to create KCM type %d in cluster %x\n",
161                       __FUNCTION__ , type , local_cxy );
162                return ENOMEM;
163        }
164
165        // initialize the new KCM allocator
166        kcm_init( kcm , type );
167
168        // register it in the KCM pointers Table
169        cluster->kcm_tbl[type] = kcm;
170
171        hal_fence();
172
173#if DEBUG_KMEM
174cycle = (uint32_t)hal_get_cycles();
175if( DEBUG_KMEM < cycle )
176printk("\n[DBG] %s : thread %x exit / cycle %d\n",
177__FUNCTION__, CURRENT_THREAD, cycle );
178#endif
179
180        return 0;
181}
182
183/////////////////////////////////////
184void * kmem_alloc( kmem_req_t * req )
185{
186        cluster_t * cluster = LOCAL_CLUSTER;
187
188        uint32_t    type;
189        uint32_t    flags;
190        uint32_t    size;    // ln( pages ) if PPM / bytes if KHM / unused if KCM
191        void      * ptr;     // memory buffer if KHM or KCM / page descriptor if PPM
192        uint32_t    irq_state;
193
194
195        type  = req->type;
196        size  = req->size;
197        flags = req->flags;
198
199        assert( (type < KMEM_TYPES_NR) , "illegal KMEM request type" );
200
201#if DEBUG_KMEM
202uint32_t cycle = (uint32_t)hal_get_cycles();
203if( DEBUG_KMEM < cycle )
204printk("\n[DBG] %s : thread %x enter / type %s / cluster %x / cycle %d\n",
205__FUNCTION__, CURRENT_THREAD, kmem_type_str( type ), local_cxy, cycle );
206#endif
207
208        // analyse request type
209        if( type == KMEM_PAGE )                        // PPM allocator
210        {
211                // allocate the number of requested pages
212                ptr = (void *)ppm_alloc_pages( size );
213                if( ptr == NULL )
214                {
215                        printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n",
216                            __FUNCTION__ , type , size , local_cxy );
217                        return NULL;
218                }
219
220                // reset page if requested
221                if( flags & AF_ZERO ) page_zero( (page_t *)ptr );
222
223#if DEBUG_KMEM
224cycle = (uint32_t)hal_get_cycles();
225if( DEBUG_KMEM < cycle )
226printk("\n[DBG] %s : thread %x exit / %d page(s) allocated / ppn %x / cycle %d\n",
227__FUNCTION__, CURRENT_THREAD, 1<<size, ppm_page2ppn(XPTR(local_cxy,ptr)), cycle );
228#endif
229
230        }
231        else if( type == KMEM_GENERIC )                // KHM allocator
232        {
233                // allocate memory from KHM
234                ptr = khm_alloc( &cluster->khm , size );
235                if( ptr == NULL )
236                {
237                        printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n",
238                            __FUNCTION__ , type , size , local_cxy );
239                        return NULL;
240                }
241
242                // reset memory if requested
243                if( flags & AF_ZERO ) memset( ptr , 0 , size );
244
245#if DEBUG_KMEM
246cycle = (uint32_t)hal_get_cycles();
247if( DEBUG_KMEM < cycle )
248printk("\n[DBG] %s : thread %x exit / type %s allocated / base %x / size %d / cycle %d\n",
249__FUNCTION__, CURRENT_THREAD, kmem_type_str( type ), (intptr_t)ptr, size, cycle );
250#endif
251
252        }
253        else                                           // KCM allocator
254        {
255                // initialize the KCM allocator if not already done
256                if( cluster->kcm_tbl[type] == NULL )
257                {
258            // get lock protecting local kcm_tbl[] array
259                        busylock_acquire( &cluster->kcm_lock );
260
261            // create missing KCM
262                        error_t error = kmem_create_kcm( type );
263
264            // release lock protecting local kcm_tbl[] array
265                        busylock_release( &cluster->kcm_lock );
266
267                        if ( error ) 
268            {
269                 printk("\n[ERROR] in %s : cannot create KCM type %d in cluster %x\n",
270                 __FUNCTION__, type, local_cxy );
271                 return NULL;
272            }
273                }
274
275                // allocate memory from KCM
276                ptr = kcm_alloc( cluster->kcm_tbl[type] );
277                if( ptr == NULL )
278                {
279                        printk("\n[ERROR] in %s : failed for type %d / size %d in cluster %x\n",
280                    __FUNCTION__ , type , size , local_cxy );
281                        return NULL;
282                }
283
284                // reset memory if requested
285                if( flags & AF_ZERO ) memset( ptr , 0 , kmem_type_size( type ) );
286
287#if DEBUG_KMEM
288cycle = (uint32_t)hal_get_cycles();
289if( DEBUG_KMEM < cycle )
290printk("\n[DBG] %s : thread %x exit / type %s allocated / base %x / size %d / cycle %d\n",
291__FUNCTION__, CURRENT_THREAD, kmem_type_str(type), (intptr_t)ptr, 
292kmem_type_size(type), cycle );
293#endif
294
295        }
296
297        return ptr;
298}
299
300//////////////////////////////////
301void kmem_free( kmem_req_t * req )
302{
303        if( req->type >= KMEM_TYPES_NR )
304        {
305                assert( false , "illegal request type\n" );
306        }
307
308        switch(req->type)
309        {
310                case KMEM_PAGE:
311                        ppm_free_pages( (page_t*)req->ptr );
312                        return;
313
314                case KMEM_GENERIC:
315                        khm_free( req->ptr );
316                        return;
317
318                default:
319                        kcm_free( req->ptr );
320                        return;
321        }
322}
323
Note: See TracBrowser for help on using the repository browser.