1 /* $NetBSD: load_elf.cpp,v 1.10 2004/03/16 22:30:36 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 _sym_blk.enable = FALSE; 55 56 DPRINTF((TEXT("Loader: ELF\n"))); 57 } 58 59 ElfLoader::~ElfLoader(void) 60 { 61 if (_sym_blk.header != NULL) 62 free (_sym_blk.header); 63 } 64 65 BOOL 66 ElfLoader::setFile(File *&file) 67 { 68 size_t sz; 69 Loader::setFile(file); 70 71 // read ELF header and check it 72 if (!read_header()) 73 return FALSE; 74 // read section header 75 sz = _eh.e_shnum * _eh.e_shentsize; 76 _file->read(_sh, _eh.e_shentsize * _eh.e_shnum, _eh.e_shoff); 77 78 // read program header 79 sz = _eh.e_phnum * _eh.e_phentsize; 80 81 return _file->read(_ph, sz, _eh.e_phoff) == sz; 82 } 83 84 size_t 85 ElfLoader::memorySize() 86 { 87 int i; 88 Elf_Phdr *ph = _ph; 89 size_t sz = 0; 90 91 DPRINTF((TEXT("file size: "))); 92 for (i = 0; i < _eh.e_phnum; i++, ph++) { 93 if (ph->p_type == PT_LOAD) { 94 size_t filesz = ph->p_filesz; 95 DPRINTF((TEXT("+0x%x"), filesz)); 96 sz += _mem->roundPage(filesz); 97 } 98 } 99 100 // reserve for symbols 101 size_t symblk_sz = symbol_block_size(); 102 if (symblk_sz) { 103 sz += symblk_sz; 104 DPRINTF((TEXT(" = 0x%x]"), symblk_sz)); 105 } 106 107 DPRINTF((TEXT(" = 0x%x byte\n"), sz)); 108 return sz; 109 } 110 111 kaddr_t 112 ElfLoader::jumpAddr() 113 { 114 DPRINTF((TEXT("kernel entry address: 0x%08x\n"), _eh.e_entry)); 115 return _eh.e_entry; 116 } 117 118 BOOL 119 ElfLoader::load() 120 { 121 Elf_Phdr *ph; 122 vaddr_t kv; 123 int i; 124 125 _load_segment_start(); 126 127 for (i = 0, ph = _ph; i < _eh.e_phnum; i++, ph++) { 128 if (ph->p_type == PT_LOAD) { 129 size_t filesz = ph->p_filesz; 130 size_t memsz = ph->p_memsz; 131 kv = ph->p_vaddr; 132 off_t fileofs = ph->p_offset; 133 DPRINTF((TEXT("[%d] vaddr 0x%08x file size 0x%x mem size 0x%x\n"), 134 i, kv, filesz, memsz)); 135 _load_segment(kv, memsz, fileofs, filesz); 136 kv += memsz; 137 } 138 } 139 140 load_symbol_block(kv); 141 142 // tag chain still opening 143 144 return _load_success(); 145 } 146 147 // 148 // Prepare ELF headers for symbol table. 149 // 150 // ELF header 151 // section header 152 // shstrtab 153 // symtab 154 // strtab 155 // 156 size_t 157 ElfLoader::symbol_block_size() 158 { 159 size_t shstrsize = ROUND4(_sh[_eh.e_shstrndx].sh_size); 160 size_t shtab_sz = _eh.e_shentsize * _eh.e_shnum; 161 off_t shstrtab_offset = sizeof(Elf_Ehdr) + shtab_sz; 162 int i; 163 164 memset(&_sym_blk, 0, sizeof(_sym_blk)); 165 _sym_blk.enable = FALSE; 166 _sym_blk.header_size = sizeof(Elf_Ehdr) + shtab_sz + shstrsize; 167 168 // inquire string and symbol table size 169 _sym_blk.header = static_cast<char *>(malloc(_sym_blk.header_size)); 170 if (_sym_blk.header == NULL) { 171 MessageBox(HPC_MENU._root->_window, 172 TEXT("Can't determine symbol block size."), 173 TEXT("WARNING"), 174 MB_ICONWARNING | MB_OK); 175 UpdateWindow(HPC_MENU._root->_window); 176 return (0); 177 } 178 179 // set pointer for symbol block 180 Elf_Ehdr *eh = reinterpret_cast<Elf_Ehdr *>(_sym_blk.header); 181 Elf_Shdr *sh = reinterpret_cast<Elf_Shdr *> 182 (_sym_blk.header + sizeof(Elf_Ehdr)); 183 char *shstrtab = _sym_blk.header + shstrtab_offset; 184 185 // initialize headers 186 memset(_sym_blk.header, 0, _sym_blk.header_size); 187 memcpy(eh, &_eh, sizeof(Elf_Ehdr)); 188 eh->e_phoff = 0; 189 eh->e_phnum = 0; 190 eh->e_entry = 0; // XXX NetBSD kernel check this member. see machdep.c 191 eh->e_shoff = sizeof(Elf_Ehdr); 192 memcpy(sh, _sh, shtab_sz); 193 194 // inquire symbol/string table information 195 _file->read(shstrtab, shstrsize, _sh[_eh.e_shstrndx].sh_offset); 196 for (i = 0; i < _eh.e_shnum; i++, sh++) { 197 if (strcmp(".strtab", shstrtab + sh->sh_name) == 0) { 198 _sym_blk.shstr = sh; 199 _sym_blk.stroff = sh->sh_offset; 200 } else if (strcmp(".symtab", shstrtab + sh->sh_name) == 0) { 201 _sym_blk.shsym = sh; 202 _sym_blk.symoff = sh->sh_offset; 203 } 204 205 sh->sh_offset = (i == _eh.e_shstrndx) ? shstrtab_offset : 0; 206 } 207 208 if (_sym_blk.shstr == NULL || _sym_blk.shsym == NULL) { 209 if (HPC_PREFERENCE.safety_message) { 210 MessageBox(HPC_MENU._root->_window, 211 TEXT("No symbol and/or string table in binary.\n(not fatal)"), 212 TEXT("Information"), 213 MB_ICONINFORMATION | MB_OK); 214 UpdateWindow(HPC_MENU._root->_window); 215 } 216 free(_sym_blk.header); 217 _sym_blk.header = NULL; 218 219 return (0); 220 } 221 222 // set Section Headers for symbol/string table 223 _sym_blk.shsym->sh_offset = shstrtab_offset + shstrsize; 224 _sym_blk.shstr->sh_offset = shstrtab_offset + shstrsize + 225 ROUND4(_sym_blk.shsym->sh_size); 226 _sym_blk.enable = TRUE; 227 228 DPRINTF((TEXT("+[(symbol block: header %d symbol %d string %d byte)"), 229 _sym_blk.header_size,_sym_blk.shsym->sh_size, 230 _sym_blk.shstr->sh_size)); 231 232 // return total amount of symbol block 233 return (_sym_blk.header_size + ROUND4(_sym_blk.shsym->sh_size) + 234 _sym_blk.shstr->sh_size); 235 } 236 237 void 238 ElfLoader::load_symbol_block(vaddr_t kv) 239 { 240 size_t sz; 241 242 if (!_sym_blk.enable) 243 return; 244 245 // load header 246 _load_memory(kv, _sym_blk.header_size, _sym_blk.header); 247 kv += _sym_blk.header_size; 248 249 // load symbol table 250 sz = _sym_blk.shsym->sh_size; 251 _load_segment(kv, sz, _sym_blk.symoff, sz); 252 kv += ROUND4(sz); 253 254 // load string table 255 sz = _sym_blk.shstr->sh_size; 256 _load_segment(kv, sz, _sym_blk.stroff, sz); 257 } 258 259 BOOL 260 ElfLoader::read_header() 261 { 262 // read ELF header 263 _file->read(&_eh, sizeof(Elf_Ehdr), 0); 264 265 // check ELF Magic. 266 if (!is_elf_file()) { 267 DPRINTF((TEXT("not a ELF file.\n"))); 268 return FALSE; 269 } 270 271 // Windows CE is 32bit little-endian only. 272 if (_eh.e_ident[EI_DATA] != ELFDATA2LSB || 273 _eh.e_ident[EI_CLASS] != ELFCLASS32) { 274 DPRINTF((TEXT("invalid class/data(%d/%d)\n"), 275 _eh.e_ident[EI_CLASS], _eh.e_ident[EI_DATA])); 276 return FALSE; 277 } 278 279 // Is native architecture? 280 switch(_eh.e_machine) { 281 ELF32_MACHDEP_ID_CASES; 282 default: 283 DPRINTF((TEXT("not a native architecture. machine = %d\n"), 284 _eh.e_machine)); 285 return FALSE; 286 } 287 288 // Check object type 289 if (_eh.e_type != ET_EXEC) { 290 DPRINTF((TEXT("not a executable file. type = %d\n"), 291 _eh.e_type)); 292 return FALSE; 293 } 294 295 if (_eh.e_phoff == 0 || _eh.e_phnum == 0 || _eh.e_phnum > 16 || 296 _eh.e_phentsize != sizeof(Elf_Phdr)) { 297 DPRINTF((TEXT("invalid program header information.\n"))); 298 return FALSE; 299 } 300 301 return TRUE; 302 } 303