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

Last change on this file since 611 was 611, checked in by alain, 5 years ago

Introduce sigificant modifs in VFS to support the <ls> command,
and the . and .. directories entries.

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