[1] | 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 | |
---|
[14] | 26 | #include <kernel_config.h> |
---|
[1] | 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> |
---|
[7] | 39 | #include <chdev.h> |
---|
[1] | 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> |
---|
[23] | 46 | #include <remote_mutex.h> |
---|
| 47 | #include <remote_condvar.h> |
---|
[1] | 48 | #include <mapper.h> |
---|
| 49 | #include <grdxt.h> |
---|
| 50 | #include <vseg.h> |
---|
| 51 | #include <kmem.h> |
---|
| 52 | |
---|
[7] | 53 | /////////////////////////// |
---|
| 54 | void kmem_print_kcm_table() |
---|
| 55 | { |
---|
[159] | 56 | uint32_t index; |
---|
| 57 | kcm_t * kcm; |
---|
| 58 | cluster_t * cluster = LOCAL_CLUSTER; |
---|
[1] | 59 | |
---|
[159] | 60 | printk("\n *** KCM Pointers Table ***\n"); |
---|
[7] | 61 | |
---|
[159] | 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 | } |
---|
[7] | 80 | |
---|
| 81 | ///////////////////////////////////////// |
---|
| 82 | uint32_t kmem_type_size( uint32_t type ) |
---|
[1] | 83 | { |
---|
[188] | 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 ); |
---|
[1] | 94 | |
---|
[188] | 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 ); |
---|
[159] | 104 | else if( type == KMEM_512_BYTES ) return 512; |
---|
[50] | 105 | |
---|
[159] | 106 | else return 0; |
---|
[18] | 107 | } |
---|
[1] | 108 | |
---|
[7] | 109 | ///////////////////////////////////// |
---|
| 110 | char * kmem_type_str( uint32_t type ) |
---|
| 111 | { |
---|
[159] | 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"; |
---|
[1] | 122 | |
---|
[188] | 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"; |
---|
[159] | 132 | else if( type == KMEM_512_BYTES ) return "KMEM_512_BYTES"; |
---|
[50] | 133 | |
---|
[159] | 134 | else return "undefined"; |
---|
[7] | 135 | } |
---|
| 136 | |
---|
[1] | 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 | ///////////////////////////////////////////////////////////////////////////////////////////// |
---|
[7] | 141 | static error_t kmem_create_kcm( uint32_t type ) |
---|
[1] | 142 | { |
---|
| 143 | kcm_t * kcm; |
---|
| 144 | |
---|
[159] | 145 | assert( ((type > 1) && (type < KMEM_TYPES_NR) ) , __FUNCTION__ , "illegal KCM type" ); |
---|
[1] | 146 | |
---|
[7] | 147 | kmem_dmsg("\n[INFO] %s : enters / KCM type %s missing in cluster %x\n", |
---|
[159] | 148 | __FUNCTION__ , kmem_type_str( type ) , local_cxy ); |
---|
[7] | 149 | |
---|
[159] | 150 | cluster_t * cluster = LOCAL_CLUSTER; |
---|
[1] | 151 | |
---|
[180] | 152 | // allocate memory for the requested KCM allocator |
---|
[159] | 153 | // from the KCM allocator embedded in cluster descriptor |
---|
[1] | 154 | kcm = kcm_alloc( &cluster->kcm ); |
---|
[7] | 155 | |
---|
[1] | 156 | if( kcm == NULL ) |
---|
[159] | 157 | { |
---|
[1] | 158 | printk("\n[ERROR] in %s : failed to create KCM type %d in cluster %x\n", |
---|
[159] | 159 | __FUNCTION__ , type , local_cxy ); |
---|
| 160 | return ENOMEM; |
---|
| 161 | } |
---|
[1] | 162 | |
---|
[180] | 163 | // initialize the new KCM allocator |
---|
[7] | 164 | kcm_init( kcm , type ); |
---|
[1] | 165 | |
---|
[159] | 166 | // register it if the KCM pointers Table |
---|
[7] | 167 | cluster->kcm_tbl[type] = kcm; |
---|
[1] | 168 | |
---|
[124] | 169 | hal_fence(); |
---|
[1] | 170 | |
---|
[7] | 171 | kmem_dmsg("\n[INFO] %s : exit / KCM type %s created in cluster %x\n", |
---|
[159] | 172 | __FUNCTION__ , kmem_type_str( type ) , local_cxy ); |
---|
[7] | 173 | |
---|
[1] | 174 | return 0; |
---|
[159] | 175 | } |
---|
[7] | 176 | |
---|
[1] | 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; |
---|
[7] | 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 |
---|
[1] | 186 | |
---|
[7] | 187 | |
---|
[1] | 188 | type = req->type; |
---|
| 189 | size = req->size; |
---|
| 190 | flags = req->flags; |
---|
[18] | 191 | |
---|
[7] | 192 | assert( (type < KMEM_TYPES_NR) , __FUNCTION__ , "illegal KMEM request type" ); |
---|
[18] | 193 | |
---|
[50] | 194 | kmem_dmsg("\n[INFO] %s : enters in cluster %x for type %s\n", |
---|
| 195 | __FUNCTION__ , local_cxy , kmem_type_str( type ) ); |
---|
[1] | 196 | |
---|
[159] | 197 | // analyse request type |
---|
[180] | 198 | if( type == KMEM_PAGE ) // PPM allocator |
---|
[159] | 199 | { |
---|
| 200 | // allocate the number of requested pages |
---|
[7] | 201 | ptr = (void *)ppm_alloc_pages( size ); |
---|
[180] | 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 | } |
---|
[1] | 208 | |
---|
[159] | 209 | // reset page if requested |
---|
[7] | 210 | if( flags & AF_ZERO ) page_zero( (page_t *)ptr ); |
---|
[18] | 211 | |
---|
[159] | 212 | kmem_dmsg("\n[INFO] %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 ) ); |
---|
[1] | 215 | } |
---|
[159] | 216 | else if( type == KMEM_GENERIC ) // KHM allocator |
---|
| 217 | { |
---|
| 218 | // allocate memory from KHM |
---|
[1] | 219 | ptr = khm_alloc( &cluster->khm , size ); |
---|
[180] | 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 | } |
---|
[1] | 226 | |
---|
[159] | 227 | // reset memory if requested |
---|
[1] | 228 | if( flags & AF_ZERO ) memset( ptr , 0 , size ); |
---|
[7] | 229 | |
---|
[159] | 230 | kmem_dmsg("\n[INFO] %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 ); |
---|
[1] | 233 | } |
---|
[159] | 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 ); |
---|
[7] | 240 | error_t error = kmem_create_kcm( type ); |
---|
[159] | 241 | spinlock_unlock( &cluster->kcm_lock ); |
---|
| 242 | if ( error ) return NULL; |
---|
| 243 | } |
---|
[1] | 244 | |
---|
[159] | 245 | // allocate memory from KCM |
---|
| 246 | ptr = kcm_alloc( cluster->kcm_tbl[type] ); |
---|
[180] | 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 | } |
---|
[7] | 253 | |
---|
[159] | 254 | // reset memory if requested |
---|
[7] | 255 | if( flags & AF_ZERO ) memset( ptr , 0 , kmem_type_size( type ) ); |
---|
| 256 | |
---|
[159] | 257 | kmem_dmsg("\n[INFO] %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 ) ); |
---|
[1] | 260 | } |
---|
| 261 | |
---|
| 262 | return ptr; |
---|
[159] | 263 | } |
---|
[1] | 264 | |
---|
| 265 | ////////////////////////////////// |
---|
| 266 | void kmem_free( kmem_req_t * req ) |
---|
| 267 | { |
---|
| 268 | if( req->type >= KMEM_TYPES_NR ) |
---|
[159] | 269 | { |
---|
| 270 | printk("\n[PANIC] in %s : illegal request type\n", __FUNCTION__ ); |
---|
| 271 | hal_core_sleep(); |
---|
| 272 | } |
---|
[18] | 273 | |
---|
[1] | 274 | switch(req->type) |
---|
| 275 | { |
---|
[159] | 276 | case KMEM_PAGE: |
---|
[181] | 277 | ppm_free_pages( (page_t*)req->ptr ); |
---|
| 278 | return; |
---|
[1] | 279 | |
---|
[159] | 280 | case KMEM_GENERIC: |
---|
[181] | 281 | khm_free( req->ptr ); |
---|
| 282 | return; |
---|
[1] | 283 | |
---|
[159] | 284 | default: |
---|
[181] | 285 | kcm_free( req->ptr ); |
---|
| 286 | return; |
---|
[1] | 287 | } |
---|
| 288 | } |
---|
| 289 | |
---|