1 /* $NetBSD: load_elf.cpp,v 1.17 2006/03/05 04:04:13 uwe Exp $ */ 2 3 /*- 4 * Copyright (c) 2001 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by UCHIYAMA Yasushi. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <hpcmenu.h> 40 #include <menu/window.h> 41 #include <menu/rootwindow.h> 42 43 #include <load.h> 44 #include <load_elf.h> 45 #include <console.h> 46 #include <memory.h> 47 #include <file.h> 48 49 #define ROUND4(x) (((x) + 3) & ~3) 50 51 ElfLoader::ElfLoader(Console *&cons, MemoryManager *&mem) 52 : Loader(cons, mem) 53 { 54 55 _sym_blk.enable = FALSE; 56 _ph = NULL; 57 _sh = NULL; 58 59 DPRINTF((TEXT("Loader: ELF\n"))); 60 } 61 62 ElfLoader::~ElfLoader(void) 63 { 64 65 if (_sym_blk.header != NULL) 66 free(_sym_blk.header); 67 if (_ph != NULL) 68 free(_ph); 69 if (_sh != NULL) 70 free(_sh); 71 } 72 73 BOOL 74 ElfLoader::setFile(File *&file) 75 { 76 size_t sz; 77 Loader::setFile(file); 78 79 // read ELF header and check it 80 if (!read_header()) 81 return FALSE; 82 83 // read section header 84 sz = _eh.e_shnum * _eh.e_shentsize; 85 if ((_sh = static_cast<Elf_Shdr *>(malloc(sz))) == NULL) { 86 DPRINTF((TEXT("can't allocate section header table.\n"))); 87 return FALSE; 88 } 89 if (_file->read(_sh, sz, _eh.e_shoff) != sz) { 90 DPRINTF((TEXT("section header read error.\n"))); 91 return FALSE; 92 } 93 94 // read program header 95 sz = _eh.e_phnum * _eh.e_phentsize; 96 if ((_ph = static_cast<Elf_Phdr *>(malloc(sz))) == NULL) { 97 DPRINTF((TEXT("can't allocate program header table.\n"))); 98 return FALSE; 99 } 100 if (_file->read(_ph, sz, _eh.e_phoff) != sz) { 101 DPRINTF((TEXT("program header read error.\n"))); 102 return FALSE; 103 } 104 105 return TRUE; 106 } 107 108 size_t 109 ElfLoader::memorySize() 110 { 111 int i; 112 Elf_Phdr *ph = _ph; 113 size_t sz = 0; 114 size_t extra = 0; 115 116 DPRINTF((TEXT("file size: "))); 117 for (i = 0; i < _eh.e_phnum; i++, ph++) { 118 if (ph->p_type == PT_LOAD) { 119 size_t filesz = ph->p_filesz; 120 DPRINTF((TEXT("%s0x%x"), 121 sz == 0 ? "" : "+", 122 filesz)); 123 sz += _mem->roundPage(filesz); 124 // compensate for partial last tag 125 extra += _mem->getTaggedPageSize(); 126 if (filesz < ph->p_memsz) 127 // compensate for zero clear 128 extra += _mem->getTaggedPageSize(); 129 130 } 131 } 132 133 // reserve for symbols 134 size_t symblk_sz = symbol_block_size(); 135 if (symblk_sz) { 136 sz += symblk_sz; 137 DPRINTF((TEXT(" = 0x%x]"), symblk_sz)); 138 // XXX: compensate for partial tags after ELF header and symtab 139 extra += 2 * _mem->getTaggedPageSize(); 140 } 141 142 sz += extra; 143 DPRINTF((TEXT("+[extra: 0x%x]"), extra)); 144 145 DPRINTF((TEXT(" = 0x%x bytes\n"), sz)); 146 return sz; 147 } 148 149 kaddr_t 150 ElfLoader::jumpAddr() 151 { 152 DPRINTF((TEXT("kernel entry address: 0x%08x\n"), _eh.e_entry)); 153 return _eh.e_entry; 154 } 155 156 BOOL 157 ElfLoader::load() 158 { 159 Elf_Phdr *ph; 160 vaddr_t kv; 161 int i; 162 163 _load_segment_start(); 164 165 for (i = 0, ph = _ph; i < _eh.e_phnum; i++, ph++) { 166 if (ph->p_type == PT_LOAD) { 167 size_t filesz = ph->p_filesz; 168 size_t memsz = ph->p_memsz; 169 kv = ph->p_vaddr; 170 off_t fileofs = ph->p_offset; 171 DPRINTF((TEXT("seg[%d] vaddr 0x%08x file size 0x%x mem size 0x%x\n"), 172 i, kv, filesz, memsz)); 173 _load_segment(kv, memsz, fileofs, filesz); 174 kv += ROUND4(memsz); 175 } 176 } 177 178 load_symbol_block(kv); 179 180 // tag chain still opening 181 182 return _load_success(); 183 } 184 185 // 186 // Prepare ELF headers for symbol table. 187 // 188 // ELF header 189 // section header 190 // shstrtab 191 // symtab 192 // strtab 193 // 194 size_t 195 ElfLoader::symbol_block_size() 196 { 197 size_t shstrsize = ROUND4(_sh[_eh.e_shstrndx].sh_size); 198 size_t shtab_sz = _eh.e_shentsize * _eh.e_shnum; 199 off_t shstrtab_offset = sizeof(Elf_Ehdr) + shtab_sz; 200 int i; 201 202 memset(&_sym_blk, 0, sizeof(_sym_blk)); 203 _sym_blk.enable = FALSE; 204 _sym_blk.header_size = sizeof(Elf_Ehdr) + shtab_sz + shstrsize; 205 206 // inquire string and symbol table size 207 _sym_blk.header = static_cast<char *>(malloc(_sym_blk.header_size)); 208 if (_sym_blk.header == NULL) { 209 MessageBox(HPC_MENU._root->_window, 210 TEXT("Can't determine symbol block size."), 211 TEXT("WARNING"), 212 MB_ICONWARNING | MB_OK); 213 UpdateWindow(HPC_MENU._root->_window); 214 return (0); 215 } 216 217 // set pointer for symbol block 218 Elf_Ehdr *eh = reinterpret_cast<Elf_Ehdr *>(_sym_blk.header); 219 Elf_Shdr *sh = reinterpret_cast<Elf_Shdr *> 220 (_sym_blk.header + sizeof(Elf_Ehdr)); 221 char *shstrtab = _sym_blk.header + shstrtab_offset; 222 223 // initialize headers 224 memset(_sym_blk.header, 0, _sym_blk.header_size); 225 memcpy(eh, &_eh, sizeof(Elf_Ehdr)); 226 eh->e_phoff = 0; 227 eh->e_phnum = 0; 228 eh->e_entry = 0; // XXX NetBSD kernel check this member. see machdep.c 229 eh->e_shoff = sizeof(Elf_Ehdr); 230 memcpy(sh, _sh, shtab_sz); 231 232 // inquire symbol/string table information 233 _file->read(shstrtab, shstrsize, _sh[_eh.e_shstrndx].sh_offset); 234 for (i = 0; i < _eh.e_shnum; i++, sh++) { 235 if (strcmp(".strtab", shstrtab + sh->sh_name) == 0) { 236 _sym_blk.shstr = sh; 237 _sym_blk.stroff = sh->sh_offset; 238 } else if (strcmp(".symtab", shstrtab + sh->sh_name) == 0) { 239 _sym_blk.shsym = sh; 240 _sym_blk.symoff = sh->sh_offset; 241 } 242 243 sh->sh_offset = (i == _eh.e_shstrndx) ? shstrtab_offset : 0; 244 } 245 246 if (_sym_blk.shstr == NULL || _sym_blk.shsym == NULL) { 247 if (HPC_PREFERENCE.safety_message) { 248 MessageBox(HPC_MENU._root->_window, 249 TEXT("No symbol and/or string table in binary.\n(not fatal)"), 250 TEXT("Information"), 251 MB_ICONINFORMATION | MB_OK); 252 UpdateWindow(HPC_MENU._root->_window); 253 } 254 free(_sym_blk.header); 255 _sym_blk.header = NULL; 256 257 return (0); 258 } 259 260 // set Section Headers for symbol/string table 261 _sym_blk.shsym->sh_offset = shstrtab_offset + shstrsize; 262 _sym_blk.shstr->sh_offset = shstrtab_offset + shstrsize + 263 ROUND4(_sym_blk.shsym->sh_size); 264 _sym_blk.enable = TRUE; 265 266 DPRINTF((TEXT("+[ksyms: header 0x%x, symtab 0x%x, strtab 0x%x"), 267 _sym_blk.header_size, _sym_blk.shsym->sh_size, 268 _sym_blk.shstr->sh_size)); 269 270 // return total amount of symbol block 271 return (_sym_blk.header_size + ROUND4(_sym_blk.shsym->sh_size) + 272 _sym_blk.shstr->sh_size); 273 } 274 275 void 276 ElfLoader::load_symbol_block(vaddr_t kv) 277 { 278 size_t sz; 279 280 if (!_sym_blk.enable) 281 return; 282 283 DPRINTF((TEXT("ksyms\n"))); 284 285 // load header 286 _load_memory(kv, _sym_blk.header_size, _sym_blk.header); 287 kv += _sym_blk.header_size; 288 289 // load symbol table 290 sz = _sym_blk.shsym->sh_size; 291 _load_segment(kv, sz, _sym_blk.symoff, sz); 292 kv += ROUND4(sz); 293 294 // load string table 295 sz = _sym_blk.shstr->sh_size; 296 _load_segment(kv, sz, _sym_blk.stroff, sz); 297 } 298 299 BOOL 300 ElfLoader::read_header() 301 { 302 // read ELF header 303 _file->read(&_eh, sizeof(Elf_Ehdr), 0); 304 305 // check ELF Magic. 306 if (!is_elf_file()) { 307 DPRINTF((TEXT("not a ELF file.\n"))); 308 return FALSE; 309 } 310 311 // Windows CE is 32bit little-endian only. 312 if (_eh.e_ident[EI_DATA] != ELFDATA2LSB || 313 _eh.e_ident[EI_CLASS] != ELFCLASS32) { 314 DPRINTF((TEXT("invalid class/data(%d/%d)\n"), 315 _eh.e_ident[EI_CLASS], _eh.e_ident[EI_DATA])); 316 return FALSE; 317 } 318 319 // Is native architecture? 320 switch(_eh.e_machine) { 321 ELF32_MACHDEP_ID_CASES; 322 default: 323 DPRINTF((TEXT("not a native architecture. machine = %d\n"), 324 _eh.e_machine)); 325 return FALSE; 326 } 327 328 // Check object type 329 if (_eh.e_type != ET_EXEC) { 330 DPRINTF((TEXT("not a executable file. type = %d\n"), 331 _eh.e_type)); 332 return FALSE; 333 } 334 335 if (_eh.e_phoff == 0 || _eh.e_phnum == 0 || _eh.e_phnum > 16 || 336 _eh.e_phentsize != sizeof(Elf_Phdr)) { 337 DPRINTF((TEXT("invalid program header information.\n"))); 338 return FALSE; 339 } 340 341 return TRUE; 342 } 343