[1] | 1 | /* |
---|
| 2 | * elf.c - elf parser: find and map process CODE and DATA segments |
---|
| 3 | * |
---|
[671] | 4 | * Authors Alain Greiner (2016,2017,2018,2019,2020) |
---|
[1] | 5 | * |
---|
| 6 | * Copyright (c) UPMC Sorbonne Universites |
---|
| 7 | * |
---|
| 8 | * This file is part of ALMOS-MKH. |
---|
| 9 | * |
---|
| 10 | * ALMOS-MKH is free software; you can redistribute it and/or modify it |
---|
| 11 | * under the terms of the GNU General Public License as published by |
---|
| 12 | * the Free Software Foundation; version 2.0 of the License. |
---|
| 13 | * |
---|
| 14 | * ALMOS-MKH is distributed in the hope that it will be useful, but |
---|
| 15 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
---|
| 17 | * General Public License for more details. |
---|
| 18 | * |
---|
| 19 | * You should have received a copy of the GNU General Public License |
---|
| 20 | * along with ALMOS-MKH; if not, write to the Free Software Foundation, |
---|
| 21 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
---|
| 22 | */ |
---|
| 23 | |
---|
[14] | 24 | #include <kernel_config.h> |
---|
[457] | 25 | #include <hal_kernel_types.h> |
---|
[406] | 26 | #include <hal_special.h> |
---|
[1] | 27 | #include <hal_uspace.h> |
---|
| 28 | #include <printk.h> |
---|
| 29 | #include <process.h> |
---|
[406] | 30 | #include <thread.h> |
---|
| 31 | #include <mapper.h> |
---|
[1] | 32 | #include <vseg.h> |
---|
| 33 | #include <kmem.h> |
---|
| 34 | #include <vfs.h> |
---|
| 35 | #include <elf.h> |
---|
[23] | 36 | #include <syscalls.h> |
---|
[1] | 37 | |
---|
| 38 | /////////////////////////////////////////////////////////////////// |
---|
| 39 | // This static function checks the .elf header. |
---|
| 40 | // - return true if legal header. |
---|
| 41 | // - return false with an error message if illegal header. |
---|
| 42 | /////////////////////////////////////////////////////////////////// |
---|
[227] | 43 | static bool_t elf_isValidHeader(Elf_Ehdr *header) |
---|
[1] | 44 | { |
---|
[671] | 45 | if( (header->e_ident[EI_CLASS] == ELFCLASS) && |
---|
| 46 | (header->e_ident[EI_DATA] == ELFDATA2LSB) && |
---|
| 47 | (header->e_ident[EI_VERSION] == EV_CURRENT) && |
---|
| 48 | ( (header->e_machine == EM_MIPS) || |
---|
| 49 | (header->e_machine == EM_MIPS_RS3_LE) || |
---|
| 50 | (header->e_machine == EM_X86_64) ) && |
---|
| 51 | (header->e_type == ET_EXEC) ) |
---|
[156] | 52 | return true; |
---|
| 53 | |
---|
[270] | 54 | if( header->e_ident[EI_CLASS] != ELFCLASS ) |
---|
| 55 | printk("\n[ERROR] in %s : Elf is not 32/64-Binary\n", __FUNCTION__ ); |
---|
[1] | 56 | |
---|
| 57 | if( header->e_ident[EI_DATA] != ELFDATA2LSB ) |
---|
[156] | 58 | printk("\n[ERROR] in %s : Elf is not 2's complement, little endian\n", __FUNCTION__ ); |
---|
[1] | 59 | |
---|
[156] | 60 | if( header->e_ident[EI_VERSION] != EV_CURRENT ) |
---|
| 61 | printk("\n[ERROR] in %s : Elf is not in Current Version\n", __FUNCTION__); |
---|
[441] | 62 | |
---|
[270] | 63 | if( (header->e_machine != EM_MIPS) && |
---|
| 64 | (header->e_machine != EM_MIPS_RS3_LE) && |
---|
| 65 | (header->e_machine != EM_X86_64) ) |
---|
[157] | 66 | printk("\n[ERROR] in %s : unexpected core / accept only MIPS or x86_64\n", __FUNCTION__ ); |
---|
[1] | 67 | |
---|
[270] | 68 | if( header->e_type != ET_EXEC ) |
---|
[156] | 69 | printk("\n[ERROR] in %s : Elf is not executable binary\n", __FUNCTION__ ); |
---|
[1] | 70 | |
---|
| 71 | return false; |
---|
| 72 | } |
---|
| 73 | |
---|
| 74 | /////////////////////////////////////////////////////////////////////////////////////// |
---|
[671] | 75 | // This static function loads the .elf header in the buffer allocated by the caller. |
---|
[204] | 76 | /////////////////////////////////////////////////////////////////////////////////////// |
---|
[1] | 77 | // @ file : extended pointer on the remote file descriptor. |
---|
| 78 | // @ buffer : pointer on buffer allocated by the caller. |
---|
| 79 | // @ size : number of bytes to read. |
---|
| 80 | /////////////////////////////////////////////////////////////////////////////////////// |
---|
[204] | 81 | static error_t elf_header_load( xptr_t file_xp, |
---|
[1] | 82 | void * buffer, |
---|
| 83 | uint32_t size ) |
---|
[156] | 84 | { |
---|
[332] | 85 | error_t error; |
---|
[328] | 86 | xptr_t buf_xp; |
---|
[1] | 87 | |
---|
[337] | 88 | buf_xp = XPTR( local_cxy , buffer ); |
---|
[328] | 89 | |
---|
[156] | 90 | // load .elf header |
---|
[332] | 91 | error = vfs_kernel_move( true, // to_buffer |
---|
[328] | 92 | file_xp, |
---|
| 93 | buf_xp, |
---|
| 94 | size ); |
---|
[1] | 95 | |
---|
[332] | 96 | if( error ) |
---|
[1] | 97 | { |
---|
[332] | 98 | printk("\n[ERROR] in %s : cannot read ELF header size : %d\n", |
---|
| 99 | __FUNCTION__ , size ); |
---|
[1] | 100 | return -1; |
---|
| 101 | } |
---|
| 102 | |
---|
[227] | 103 | Elf_Ehdr * header = (Elf_Ehdr *)buffer; |
---|
[156] | 104 | |
---|
[1] | 105 | if( (header->e_ident[EI_MAG0] != ELFMAG0) || |
---|
| 106 | (header->e_ident[EI_MAG1] != ELFMAG1) || |
---|
| 107 | (header->e_ident[EI_MAG2] != ELFMAG2) || |
---|
| 108 | (header->e_ident[EI_MAG3] != ELFMAG3) ) |
---|
| 109 | { |
---|
[332] | 110 | printk("\n[ERROR] in %s : file not in ELF format\n", __FUNCTION__ ); |
---|
[1] | 111 | return -1; |
---|
| 112 | } |
---|
| 113 | |
---|
| 114 | if( !(elf_isValidHeader( header ) ) ) |
---|
| 115 | { |
---|
| 116 | printk("\n[ERROR] in %s : not supported Elf\n", __FUNCTION__ ); |
---|
| 117 | return -1; |
---|
| 118 | } |
---|
| 119 | return 0; |
---|
| 120 | |
---|
[204] | 121 | } // end elf_header_load() |
---|
| 122 | |
---|
[1] | 123 | /////////////////////////////////////////////////////////////////////////////////////// |
---|
| 124 | // This function registers in the process VMM the CODE and DATA segments. |
---|
[204] | 125 | /////////////////////////////////////////////////////////////////////////////////////// |
---|
[1] | 126 | // @ file : extended pointer on the remote file descriptor. |
---|
| 127 | // @ segs_base : local pointer on buffer containing the segments descriptors array |
---|
| 128 | // @ segs_nr : number of segments in segment descriptors array. |
---|
| 129 | // @ process : local pointer on process descriptor. |
---|
| 130 | /////////////////////////////////////////////////////////////////////////////////////// |
---|
[313] | 131 | static error_t elf_segments_register( xptr_t file_xp, |
---|
| 132 | void * segs_base, |
---|
| 133 | uint32_t nb_segs, |
---|
| 134 | process_t * process ) |
---|
[1] | 135 | { |
---|
| 136 | uint32_t index; |
---|
[313] | 137 | intptr_t file_size; |
---|
| 138 | intptr_t mem_size; |
---|
| 139 | intptr_t file_offset; |
---|
| 140 | intptr_t vbase; |
---|
[1] | 141 | uint32_t type; |
---|
| 142 | uint32_t flags; |
---|
[156] | 143 | vseg_t * vseg; |
---|
[1] | 144 | |
---|
[227] | 145 | Elf_Phdr * seg_ptr = (Elf_Phdr *)segs_base; |
---|
[1] | 146 | |
---|
[156] | 147 | // loop on segments |
---|
| 148 | for( index = 0 ; index < nb_segs ; index++ , seg_ptr++ ) |
---|
| 149 | { |
---|
| 150 | if( seg_ptr->p_type != PT_LOAD) |
---|
| 151 | continue; |
---|
| 152 | |
---|
| 153 | // get segment attributes |
---|
[313] | 154 | vbase = seg_ptr->p_vaddr; // vseg base vaddr |
---|
| 155 | mem_size = seg_ptr->p_memsz; // actual vseg size |
---|
| 156 | file_offset = seg_ptr->p_offset; // vseg offset in .elf file |
---|
| 157 | file_size = seg_ptr->p_filesz; // vseg size in .elf file |
---|
| 158 | flags = seg_ptr->p_flags; |
---|
[1] | 159 | |
---|
| 160 | if( flags & PF_X ) // found CODE segment |
---|
| 161 | { |
---|
[156] | 162 | type = VSEG_TYPE_CODE; |
---|
[683] | 163 | process->vmm.code_vpn_base = vbase >> CONFIG_PPM_PAGE_ORDER; |
---|
[1] | 164 | } |
---|
[156] | 165 | else // found DATA segment |
---|
[1] | 166 | { |
---|
[156] | 167 | type = VSEG_TYPE_DATA; |
---|
[683] | 168 | process->vmm.data_vpn_base = vbase >> CONFIG_PPM_PAGE_ORDER; |
---|
[1] | 169 | } |
---|
| 170 | |
---|
[407] | 171 | // get .elf file descriptor cluster and local pointer |
---|
| 172 | cxy_t file_cxy = GET_CXY( file_xp ); |
---|
[671] | 173 | vfs_file_t * file_ptr = GET_PTR( file_xp ); |
---|
[407] | 174 | |
---|
| 175 | // get local pointer on .elf file mapper |
---|
| 176 | mapper_t * mapper_ptr = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , |
---|
| 177 | &file_ptr->mapper ) ); |
---|
[156] | 178 | // register vseg in VMM |
---|
| 179 | vseg = (vseg_t *)vmm_create_vseg( process, |
---|
[407] | 180 | type, |
---|
[313] | 181 | vbase, |
---|
[156] | 182 | mem_size, |
---|
[407] | 183 | file_offset, |
---|
| 184 | file_size, |
---|
| 185 | XPTR( file_cxy , mapper_ptr ), |
---|
| 186 | local_cxy ); |
---|
[1] | 187 | if( vseg == NULL ) |
---|
| 188 | { |
---|
| 189 | printk("\n[ERROR] in %s : cannot map segment / base = %x / size = %x\n", |
---|
[313] | 190 | __FUNCTION__ , vbase , mem_size ); |
---|
[1] | 191 | return -1; |
---|
| 192 | } |
---|
| 193 | |
---|
[438] | 194 | #if DEBUG_ELF_LOAD |
---|
[625] | 195 | uint32_t cycle = (uint32_t)hal_get_cycles(); |
---|
| 196 | thread_t * this = CURRENT_THREAD; |
---|
[438] | 197 | if( DEBUG_ELF_LOAD < cycle ) |
---|
[625] | 198 | printk("\n[%s] thread[%x,%x] found %s vseg / base %x / size %x\n" |
---|
[671] | 199 | " file_size %x / file_offset %x / mapper[%x,%x] / cycle %d\n", |
---|
[635] | 200 | __FUNCTION__ , this->process->pid, this->trdid, |
---|
[625] | 201 | vseg_type_str(vseg->type) , vseg->min , vseg->max - vseg->min , |
---|
[671] | 202 | vseg->file_size , vseg->file_offset , |
---|
| 203 | GET_CXY(vseg->mapper_xp), GET_PTR(vseg->mapper_xp), cycle ); |
---|
[433] | 204 | #endif |
---|
| 205 | |
---|
[1] | 206 | } |
---|
| 207 | |
---|
| 208 | return 0; |
---|
| 209 | |
---|
[313] | 210 | } // end elf_segments_register() |
---|
[204] | 211 | |
---|
[457] | 212 | ////////////////////////////////////////////// |
---|
| 213 | error_t elf_load_process( xptr_t file_xp, |
---|
| 214 | process_t * process ) |
---|
[1] | 215 | { |
---|
[651] | 216 | uint32_t new_offset; // unused, required by vfs_lseek() |
---|
[227] | 217 | Elf_Ehdr header; // local buffer for .elf header |
---|
[1] | 218 | void * segs_base; // pointer on buffer for segment descriptors array |
---|
[156] | 219 | uint32_t segs_size; // size of buffer for segment descriptors array |
---|
[457] | 220 | char name[CONFIG_VFS_MAX_NAME_LENGTH]; |
---|
[1] | 221 | error_t error; |
---|
| 222 | |
---|
[657] | 223 | // get file cluster and local pointer |
---|
[671] | 224 | cxy_t file_cxy = GET_CXY( file_xp ); |
---|
| 225 | vfs_file_t * file_ptr = GET_PTR( file_xp ); |
---|
[657] | 226 | |
---|
[671] | 227 | // get inode pointer |
---|
| 228 | vfs_inode_t * inode_ptr = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) ); |
---|
| 229 | |
---|
[657] | 230 | // get file name for error reporting and debug |
---|
[671] | 231 | vfs_inode_get_name( XPTR( file_cxy , inode_ptr ) , name ); |
---|
[457] | 232 | |
---|
[438] | 233 | #if DEBUG_ELF_LOAD |
---|
[603] | 234 | uint32_t cycle = (uint32_t)hal_get_cycles(); |
---|
| 235 | thread_t * this = CURRENT_THREAD; |
---|
[438] | 236 | if( DEBUG_ELF_LOAD < cycle ) |
---|
[603] | 237 | printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n", |
---|
| 238 | __FUNCTION__, this->process->pid, this->trdid, name, cycle ); |
---|
[433] | 239 | #endif |
---|
[1] | 240 | |
---|
[156] | 241 | // load header in local buffer |
---|
[204] | 242 | error = elf_header_load( file_xp , |
---|
[156] | 243 | &header, |
---|
[227] | 244 | sizeof(Elf_Ehdr) ); |
---|
[156] | 245 | if( error ) |
---|
| 246 | { |
---|
[457] | 247 | printk("\n[ERROR] in %s : cannot get header for <%s>\n", __FUNCTION__ , name ); |
---|
[156] | 248 | return -1; |
---|
| 249 | } |
---|
[1] | 250 | |
---|
[438] | 251 | #if (DEBUG_ELF_LOAD & 1) |
---|
| 252 | if( DEBUG_ELF_LOAD < cycle ) |
---|
[671] | 253 | printk("\n[%s] loaded elf header for <%s>\n" |
---|
| 254 | " - size = %x\n" |
---|
| 255 | " - version = %x\n" |
---|
| 256 | " - entry = %x\n" |
---|
| 257 | " - machine = %x\n" |
---|
| 258 | " - offset = %x\n" |
---|
| 259 | " - segnum = %x\n", |
---|
| 260 | __FUNCTION__, name, |
---|
| 261 | header.e_ehsize, |
---|
| 262 | header.e_version, |
---|
| 263 | header.e_entry, |
---|
| 264 | header.e_machine, |
---|
| 265 | header.e_phoff, |
---|
| 266 | header.e_phnum ); |
---|
[433] | 267 | #endif |
---|
[1] | 268 | |
---|
| 269 | if( header.e_phnum == 0 ) |
---|
| 270 | { |
---|
| 271 | printk("\n[ERROR] in %s : no segments found\n", __FUNCTION__ ); |
---|
| 272 | return -1; |
---|
| 273 | } |
---|
| 274 | |
---|
[156] | 275 | // compute buffer size for segment descriptors array |
---|
[227] | 276 | segs_size = sizeof(Elf_Phdr) * header.e_phnum; |
---|
[156] | 277 | |
---|
| 278 | // allocate memory for segment descriptors array |
---|
[683] | 279 | segs_base = kmem_alloc( bits_log2(segs_size) , AF_NONE ); |
---|
[1] | 280 | |
---|
| 281 | if( segs_base == NULL ) |
---|
[156] | 282 | { |
---|
[1] | 283 | printk("\n[ERROR] in %s : no memory for segment descriptors\n", __FUNCTION__ ); |
---|
[156] | 284 | return -1; |
---|
| 285 | } |
---|
[1] | 286 | |
---|
[156] | 287 | // set seek pointer in file descriptor to access segment descriptors array |
---|
[651] | 288 | error = vfs_lseek( file_xp , header.e_phoff, SEEK_SET , &new_offset ); |
---|
[1] | 289 | |
---|
| 290 | if( error ) |
---|
| 291 | { |
---|
| 292 | printk("\n[ERROR] in %s : cannot seek for descriptors array\n", __FUNCTION__ ); |
---|
[683] | 293 | kmem_free( segs_base , bits_log2(segs_size) ); |
---|
[1] | 294 | return -1; |
---|
| 295 | } |
---|
| 296 | |
---|
[438] | 297 | #if (DEBUG_ELF_LOAD & 1) |
---|
| 298 | if( DEBUG_ELF_LOAD < cycle ) |
---|
[603] | 299 | printk("\n[%s] segments array allocated for <%s>\n", __FUNCTION__ , name ); |
---|
[433] | 300 | #endif |
---|
[367] | 301 | |
---|
[156] | 302 | // load seg descriptors array to local buffer |
---|
[367] | 303 | error = vfs_kernel_move( true, // to_buffer |
---|
| 304 | file_xp, |
---|
| 305 | XPTR( local_cxy , segs_base ), |
---|
| 306 | segs_size ); |
---|
[1] | 307 | |
---|
[333] | 308 | if( error ) |
---|
[1] | 309 | { |
---|
| 310 | printk("\n[ERROR] in %s : cannot read segments descriptors\n", __FUNCTION__ ); |
---|
[683] | 311 | kmem_free( segs_base , bits_log2(segs_size) ); |
---|
[1] | 312 | return -1; |
---|
| 313 | } |
---|
| 314 | |
---|
[438] | 315 | #if (DEBUG_ELF_LOAD & 1) |
---|
| 316 | if( DEBUG_ELF_LOAD < cycle ) |
---|
[603] | 317 | printk("\n[%s] loaded segments descriptors for <%s>\n", __FUNCTION__ , name ); |
---|
[433] | 318 | #endif |
---|
[1] | 319 | |
---|
[156] | 320 | // register loadable segments in process VMM |
---|
[313] | 321 | error = elf_segments_register( file_xp, |
---|
| 322 | segs_base, |
---|
| 323 | header.e_phnum, |
---|
| 324 | process ); |
---|
[1] | 325 | if( error ) |
---|
[156] | 326 | { |
---|
[683] | 327 | printk("\n[ERROR] in %s : cannot register segments descriptors\n", __FUNCTION__ ); |
---|
| 328 | kmem_free( segs_base , bits_log2(segs_size) ); |
---|
[1] | 329 | return -1; |
---|
[156] | 330 | } |
---|
[1] | 331 | |
---|
[156] | 332 | // register process entry point in VMM |
---|
[1] | 333 | process->vmm.entry_point = (intptr_t)header.e_entry; |
---|
| 334 | |
---|
[156] | 335 | // register extended pointer on .elf file descriptor |
---|
| 336 | process->vfs_bin_xp = file_xp; |
---|
[1] | 337 | |
---|
[156] | 338 | // release allocated memory for program header |
---|
[683] | 339 | kmem_free( segs_base , bits_log2(segs_size) ); |
---|
[1] | 340 | |
---|
[438] | 341 | #if DEBUG_ELF_LOAD |
---|
[433] | 342 | cycle = (uint32_t)hal_get_cycles(); |
---|
[438] | 343 | if( DEBUG_ELF_LOAD < cycle ) |
---|
[603] | 344 | printk("\n[%s] thread[%x,%x] exit for <%s> / entry_point %x / cycle %d\n", |
---|
| 345 | __FUNCTION__, this->process->pid, this->trdid, name, header.e_entry, cycle ); |
---|
[433] | 346 | #endif |
---|
[1] | 347 | |
---|
| 348 | return 0; |
---|
| 349 | |
---|
[204] | 350 | } // end elf_load_process() |
---|
| 351 | |
---|