1ca987d46SWarner Losh /*- 2ca987d46SWarner Losh * Copyright (c) 1998 Michael Smith <msmith@freebsd.org> 3ca987d46SWarner Losh * Copyright (c) 1998 Peter Wemm <peter@freebsd.org> 4ca987d46SWarner Losh * All rights reserved. 5ca987d46SWarner Losh * 6ca987d46SWarner Losh * Redistribution and use in source and binary forms, with or without 7ca987d46SWarner Losh * modification, are permitted provided that the following conditions 8ca987d46SWarner Losh * are met: 9ca987d46SWarner Losh * 1. Redistributions of source code must retain the above copyright 10ca987d46SWarner Losh * notice, this list of conditions and the following disclaimer. 11ca987d46SWarner Losh * 2. Redistributions in binary form must reproduce the above copyright 12ca987d46SWarner Losh * notice, this list of conditions and the following disclaimer in the 13ca987d46SWarner Losh * documentation and/or other materials provided with the distribution. 14ca987d46SWarner Losh * 15ca987d46SWarner Losh * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16ca987d46SWarner Losh * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17ca987d46SWarner Losh * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18ca987d46SWarner Losh * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19ca987d46SWarner Losh * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20ca987d46SWarner Losh * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21ca987d46SWarner Losh * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22ca987d46SWarner Losh * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23ca987d46SWarner Losh * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24ca987d46SWarner Losh * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25ca987d46SWarner Losh * SUCH DAMAGE. 26ca987d46SWarner Losh */ 27ca987d46SWarner Losh 28ca987d46SWarner Losh #include <sys/cdefs.h> 29ca987d46SWarner Losh __FBSDID("$FreeBSD$"); 30ca987d46SWarner Losh 31ca987d46SWarner Losh #include <sys/param.h> 328de1ad0bSWojciech Macek #include <sys/endian.h> 33ca987d46SWarner Losh #include <sys/exec.h> 34ca987d46SWarner Losh #include <sys/linker.h> 35ca987d46SWarner Losh #include <sys/module.h> 36ca987d46SWarner Losh #include <sys/stdint.h> 37ca987d46SWarner Losh #include <string.h> 38ca987d46SWarner Losh #include <machine/elf.h> 39ca987d46SWarner Losh #include <stand.h> 40ca987d46SWarner Losh #define FREEBSD_ELF 41f38658e1SWarner Losh #include <sys/link_elf.h> 42ca987d46SWarner Losh 43ca987d46SWarner Losh #include "bootstrap.h" 44ca987d46SWarner Losh 45ca987d46SWarner Losh #define COPYOUT(s,d,l) archsw.arch_copyout((vm_offset_t)(s), d, l) 46ca987d46SWarner Losh 47ca987d46SWarner Losh #if defined(__i386__) && __ELF_WORD_SIZE == 64 48ca987d46SWarner Losh #undef ELF_TARG_CLASS 49ca987d46SWarner Losh #undef ELF_TARG_MACH 50ca987d46SWarner Losh #define ELF_TARG_CLASS ELFCLASS64 51ca987d46SWarner Losh #define ELF_TARG_MACH EM_X86_64 52ca987d46SWarner Losh #endif 53ca987d46SWarner Losh 54ca987d46SWarner Losh typedef struct elf_file { 55ca987d46SWarner Losh Elf_Phdr *ph; 56ca987d46SWarner Losh Elf_Ehdr *ehdr; 57ca987d46SWarner Losh Elf_Sym *symtab; 58ca987d46SWarner Losh Elf_Hashelt *hashtab; 59ca987d46SWarner Losh Elf_Hashelt nbuckets; 60ca987d46SWarner Losh Elf_Hashelt nchains; 61ca987d46SWarner Losh Elf_Hashelt *buckets; 62ca987d46SWarner Losh Elf_Hashelt *chains; 63ca987d46SWarner Losh Elf_Rel *rel; 64ca987d46SWarner Losh size_t relsz; 65ca987d46SWarner Losh Elf_Rela *rela; 66ca987d46SWarner Losh size_t relasz; 67ca987d46SWarner Losh char *strtab; 68ca987d46SWarner Losh size_t strsz; 69ca987d46SWarner Losh int fd; 70ca987d46SWarner Losh caddr_t firstpage; 71ca987d46SWarner Losh size_t firstlen; 72ca987d46SWarner Losh int kernel; 7356e53cb8SWarner Losh uint64_t off; 74afc571b1SSimon J. Gerraty #ifdef LOADER_VERIEXEC_VECTX 75afc571b1SSimon J. Gerraty struct vectx *vctx; 76afc571b1SSimon J. Gerraty #endif 77ca987d46SWarner Losh } *elf_file_t; 78ca987d46SWarner Losh 79afc571b1SSimon J. Gerraty #ifdef LOADER_VERIEXEC_VECTX 80afc571b1SSimon J. Gerraty #define VECTX_HANDLE(ef) (ef)->vctx 81afc571b1SSimon J. Gerraty #else 82afc571b1SSimon J. Gerraty #define VECTX_HANDLE(ef) (ef)->fd 83afc571b1SSimon J. Gerraty #endif 84afc571b1SSimon J. Gerraty 856b632498SEd Maste static int __elfN(loadimage)(struct preloaded_file *mp, elf_file_t ef, 8656e53cb8SWarner Losh uint64_t loadaddr); 876c7a932dSToomas Soome static int __elfN(lookup_symbol)(elf_file_t ef, const char* name, 886c7a932dSToomas Soome Elf_Sym *sym, unsigned char type); 89ca987d46SWarner Losh static int __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 90ca987d46SWarner Losh Elf_Addr p, void *val, size_t len); 91ca987d46SWarner Losh static int __elfN(parse_modmetadata)(struct preloaded_file *mp, elf_file_t ef, 92ca987d46SWarner Losh Elf_Addr p_start, Elf_Addr p_end); 93ca987d46SWarner Losh static symaddr_fn __elfN(symaddr); 94ca987d46SWarner Losh static char *fake_modname(const char *name); 95ca987d46SWarner Losh 96ca987d46SWarner Losh const char *__elfN(kerneltype) = "elf kernel"; 97ca987d46SWarner Losh const char *__elfN(moduletype) = "elf module"; 98ca987d46SWarner Losh 9956e53cb8SWarner Losh uint64_t __elfN(relocation_offset) = 0; 100ca987d46SWarner Losh 101c0ecae78SWarner Losh #ifdef __powerpc__ 10212363d8eSRoger Pau Monné extern void elf_wrong_field_size(void); 10312363d8eSRoger Pau Monné #define CONVERT_FIELD(b, f, e) \ 10412363d8eSRoger Pau Monné switch (sizeof((b)->f)) { \ 10512363d8eSRoger Pau Monné case 2: \ 10612363d8eSRoger Pau Monné (b)->f = e ## 16toh((b)->f); \ 10712363d8eSRoger Pau Monné break; \ 10812363d8eSRoger Pau Monné case 4: \ 10912363d8eSRoger Pau Monné (b)->f = e ## 32toh((b)->f); \ 11012363d8eSRoger Pau Monné break; \ 11112363d8eSRoger Pau Monné case 8: \ 11212363d8eSRoger Pau Monné (b)->f = e ## 64toh((b)->f); \ 11312363d8eSRoger Pau Monné break; \ 11412363d8eSRoger Pau Monné default: \ 11512363d8eSRoger Pau Monné /* Force a link time error. */ \ 11612363d8eSRoger Pau Monné elf_wrong_field_size(); \ 11712363d8eSRoger Pau Monné break; \ 11812363d8eSRoger Pau Monné } 11912363d8eSRoger Pau Monné 12012363d8eSRoger Pau Monné #define CONVERT_SWITCH(h, d, f) \ 12112363d8eSRoger Pau Monné switch ((h)->e_ident[EI_DATA]) { \ 12212363d8eSRoger Pau Monné case ELFDATA2MSB: \ 12312363d8eSRoger Pau Monné f(d, be); \ 12412363d8eSRoger Pau Monné break; \ 12512363d8eSRoger Pau Monné case ELFDATA2LSB: \ 12612363d8eSRoger Pau Monné f(d, le); \ 12712363d8eSRoger Pau Monné break; \ 12812363d8eSRoger Pau Monné default: \ 12912363d8eSRoger Pau Monné return (EINVAL); \ 13012363d8eSRoger Pau Monné } 13112363d8eSRoger Pau Monné 13212363d8eSRoger Pau Monné 13312363d8eSRoger Pau Monné static int elf_header_convert(Elf_Ehdr *ehdr) 13412363d8eSRoger Pau Monné { 13512363d8eSRoger Pau Monné /* 13612363d8eSRoger Pau Monné * Fixup ELF header endianness. 13712363d8eSRoger Pau Monné * 13812363d8eSRoger Pau Monné * The Xhdr structure was loaded using block read call to optimize file 13912363d8eSRoger Pau Monné * accesses. It might happen, that the endianness of the system memory 14012363d8eSRoger Pau Monné * is different that endianness of the ELF header. Swap fields here to 14112363d8eSRoger Pau Monné * guarantee that Xhdr always contain valid data regardless of 14212363d8eSRoger Pau Monné * architecture. 14312363d8eSRoger Pau Monné */ 14412363d8eSRoger Pau Monné #define HEADER_FIELDS(b, e) \ 14512363d8eSRoger Pau Monné CONVERT_FIELD(b, e_type, e); \ 14612363d8eSRoger Pau Monné CONVERT_FIELD(b, e_machine, e); \ 14712363d8eSRoger Pau Monné CONVERT_FIELD(b, e_version, e); \ 14812363d8eSRoger Pau Monné CONVERT_FIELD(b, e_entry, e); \ 14912363d8eSRoger Pau Monné CONVERT_FIELD(b, e_phoff, e); \ 15012363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shoff, e); \ 15112363d8eSRoger Pau Monné CONVERT_FIELD(b, e_flags, e); \ 15212363d8eSRoger Pau Monné CONVERT_FIELD(b, e_ehsize, e); \ 15312363d8eSRoger Pau Monné CONVERT_FIELD(b, e_phentsize, e); \ 15412363d8eSRoger Pau Monné CONVERT_FIELD(b, e_phnum, e); \ 15512363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shentsize, e); \ 15612363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shnum, e); \ 15712363d8eSRoger Pau Monné CONVERT_FIELD(b, e_shstrndx, e) 15812363d8eSRoger Pau Monné 15912363d8eSRoger Pau Monné CONVERT_SWITCH(ehdr, ehdr, HEADER_FIELDS); 16012363d8eSRoger Pau Monné 16112363d8eSRoger Pau Monné #undef HEADER_FIELDS 16212363d8eSRoger Pau Monné 16312363d8eSRoger Pau Monné return (0); 16412363d8eSRoger Pau Monné } 16512363d8eSRoger Pau Monné 16612363d8eSRoger Pau Monné static int elf_program_header_convert(const Elf_Ehdr *ehdr, Elf_Phdr *phdr) 16712363d8eSRoger Pau Monné { 16812363d8eSRoger Pau Monné #define PROGRAM_HEADER_FIELDS(b, e) \ 16912363d8eSRoger Pau Monné CONVERT_FIELD(b, p_type, e); \ 17012363d8eSRoger Pau Monné CONVERT_FIELD(b, p_flags, e); \ 17112363d8eSRoger Pau Monné CONVERT_FIELD(b, p_offset, e); \ 17212363d8eSRoger Pau Monné CONVERT_FIELD(b, p_vaddr, e); \ 17312363d8eSRoger Pau Monné CONVERT_FIELD(b, p_paddr, e); \ 17412363d8eSRoger Pau Monné CONVERT_FIELD(b, p_filesz, e); \ 17512363d8eSRoger Pau Monné CONVERT_FIELD(b, p_memsz, e); \ 17612363d8eSRoger Pau Monné CONVERT_FIELD(b, p_align, e) 17712363d8eSRoger Pau Monné 17812363d8eSRoger Pau Monné CONVERT_SWITCH(ehdr, phdr, PROGRAM_HEADER_FIELDS); 17912363d8eSRoger Pau Monné 18012363d8eSRoger Pau Monné #undef PROGRAM_HEADER_FIELDS 18112363d8eSRoger Pau Monné 18212363d8eSRoger Pau Monné return (0); 18312363d8eSRoger Pau Monné } 18412363d8eSRoger Pau Monné 18512363d8eSRoger Pau Monné static int elf_section_header_convert(const Elf_Ehdr *ehdr, Elf_Shdr *shdr) 18612363d8eSRoger Pau Monné { 18712363d8eSRoger Pau Monné #define SECTION_HEADER_FIELDS(b, e) \ 18812363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_name, e); \ 18912363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_type, e); \ 19012363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_link, e); \ 19112363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_info, e); \ 19212363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_flags, e); \ 19312363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_addr, e); \ 19412363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_offset, e); \ 19512363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_size, e); \ 19612363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_addralign, e); \ 19712363d8eSRoger Pau Monné CONVERT_FIELD(b, sh_entsize, e) 19812363d8eSRoger Pau Monné 19912363d8eSRoger Pau Monné CONVERT_SWITCH(ehdr, shdr, SECTION_HEADER_FIELDS); 20012363d8eSRoger Pau Monné 20112363d8eSRoger Pau Monné #undef SECTION_HEADER_FIELDS 20212363d8eSRoger Pau Monné 20312363d8eSRoger Pau Monné return (0); 20412363d8eSRoger Pau Monné } 20512363d8eSRoger Pau Monné #undef CONVERT_SWITCH 20612363d8eSRoger Pau Monné #undef CONVERT_FIELD 207c0ecae78SWarner Losh #else 208c0ecae78SWarner Losh static int elf_header_convert(Elf_Ehdr *ehdr) 209c0ecae78SWarner Losh { 210c0ecae78SWarner Losh return (0); 211c0ecae78SWarner Losh } 21212363d8eSRoger Pau Monné 213c0ecae78SWarner Losh static int elf_program_header_convert(const Elf_Ehdr *ehdr, Elf_Phdr *phdr) 214c0ecae78SWarner Losh { 215c0ecae78SWarner Losh return (0); 216c0ecae78SWarner Losh } 217c0ecae78SWarner Losh 218c0ecae78SWarner Losh static int elf_section_header_convert(const Elf_Ehdr *ehdr, Elf_Shdr *shdr) 219c0ecae78SWarner Losh { 220c0ecae78SWarner Losh return (0); 221c0ecae78SWarner Losh } 222c0ecae78SWarner Losh #endif 223f75caed6SKonstantin Belousov 224f75caed6SKonstantin Belousov #ifdef __amd64__ 225f75caed6SKonstantin Belousov static bool 226f75caed6SKonstantin Belousov is_kernphys_relocatable(elf_file_t ef) 227f75caed6SKonstantin Belousov { 228f75caed6SKonstantin Belousov Elf_Sym sym; 229f75caed6SKonstantin Belousov 2309a964ad5SMark Johnston return (__elfN(lookup_symbol)(ef, "kernphys", &sym, STT_OBJECT) == 0); 231f75caed6SKonstantin Belousov } 232f75caed6SKonstantin Belousov #endif 233f75caed6SKonstantin Belousov 234aaaa5a2eSWarner Losh #ifdef __i386__ 235aaaa5a2eSWarner Losh static bool 236aaaa5a2eSWarner Losh is_tg_kernel_support(struct preloaded_file *fp, elf_file_t ef) 237aaaa5a2eSWarner Losh { 238aaaa5a2eSWarner Losh Elf_Sym sym; 239aaaa5a2eSWarner Losh Elf_Addr p_start, p_end, v, p; 240aaaa5a2eSWarner Losh char vd_name[16]; 241aaaa5a2eSWarner Losh int error; 242aaaa5a2eSWarner Losh 243aaaa5a2eSWarner Losh if (__elfN(lookup_symbol)(ef, "__start_set_vt_drv_set", &sym, STT_NOTYPE) != 0) 244aaaa5a2eSWarner Losh return (false); 245aaaa5a2eSWarner Losh p_start = sym.st_value + ef->off; 246aaaa5a2eSWarner Losh if (__elfN(lookup_symbol)(ef, "__stop_set_vt_drv_set", &sym, STT_NOTYPE) != 0) 247aaaa5a2eSWarner Losh return (false); 248aaaa5a2eSWarner Losh p_end = sym.st_value + ef->off; 249aaaa5a2eSWarner Losh 250aaaa5a2eSWarner Losh /* 251aaaa5a2eSWarner Losh * Walk through vt_drv_set, each vt driver structure starts with 252aaaa5a2eSWarner Losh * static 16 chars for driver name. If we have "vbefb", return true. 253aaaa5a2eSWarner Losh */ 254aaaa5a2eSWarner Losh for (p = p_start; p < p_end; p += sizeof(Elf_Addr)) { 255aaaa5a2eSWarner Losh COPYOUT(p, &v, sizeof(v)); 256aaaa5a2eSWarner Losh 257aaaa5a2eSWarner Losh error = __elfN(reloc_ptr)(fp, ef, p, &v, sizeof(v)); 258aaaa5a2eSWarner Losh if (error == EOPNOTSUPP) 259aaaa5a2eSWarner Losh v += ef->off; 260aaaa5a2eSWarner Losh else if (error != 0) 261aaaa5a2eSWarner Losh return (false); 262aaaa5a2eSWarner Losh COPYOUT(v, &vd_name, sizeof(vd_name)); 263aaaa5a2eSWarner Losh if (strncmp(vd_name, "vbefb", sizeof(vd_name)) == 0) 264aaaa5a2eSWarner Losh return (true); 265aaaa5a2eSWarner Losh } 266aaaa5a2eSWarner Losh 267aaaa5a2eSWarner Losh return (false); 268aaaa5a2eSWarner Losh } 269aaaa5a2eSWarner Losh #endif 270aaaa5a2eSWarner Losh 271ca987d46SWarner Losh static int 272ca987d46SWarner Losh __elfN(load_elf_header)(char *filename, elf_file_t ef) 273ca987d46SWarner Losh { 274ca987d46SWarner Losh ssize_t bytes_read; 275ca987d46SWarner Losh Elf_Ehdr *ehdr; 276ca987d46SWarner Losh int err; 277ca987d46SWarner Losh 278ca987d46SWarner Losh /* 279ca987d46SWarner Losh * Open the image, read and validate the ELF header 280ca987d46SWarner Losh */ 281ca987d46SWarner Losh if (filename == NULL) /* can't handle nameless */ 282ca987d46SWarner Losh return (EFTYPE); 283ca987d46SWarner Losh if ((ef->fd = open(filename, O_RDONLY)) == -1) 284ca987d46SWarner Losh return (errno); 285ca987d46SWarner Losh ef->firstpage = malloc(PAGE_SIZE); 286ca987d46SWarner Losh if (ef->firstpage == NULL) { 287ca987d46SWarner Losh close(ef->fd); 288ca987d46SWarner Losh return (ENOMEM); 289ca987d46SWarner Losh } 290c25d9affSEmmanuel Vadot preload(ef->fd); 291afc571b1SSimon J. Gerraty #ifdef LOADER_VERIEXEC_VECTX 292afc571b1SSimon J. Gerraty { 293afc571b1SSimon J. Gerraty int verror; 294afc571b1SSimon J. Gerraty 295afc571b1SSimon J. Gerraty ef->vctx = vectx_open(ef->fd, filename, 0L, NULL, &verror, __func__); 296afc571b1SSimon J. Gerraty if (verror) { 297afc571b1SSimon J. Gerraty printf("Unverified %s: %s\n", filename, ve_error_get()); 298afc571b1SSimon J. Gerraty close(ef->fd); 299afc571b1SSimon J. Gerraty free(ef->vctx); 300afc571b1SSimon J. Gerraty return (EAUTH); 301afc571b1SSimon J. Gerraty } 302afc571b1SSimon J. Gerraty } 303afc571b1SSimon J. Gerraty #endif 304afc571b1SSimon J. Gerraty bytes_read = VECTX_READ(VECTX_HANDLE(ef), ef->firstpage, PAGE_SIZE); 305ca987d46SWarner Losh ef->firstlen = (size_t)bytes_read; 306ca987d46SWarner Losh if (bytes_read < 0 || ef->firstlen <= sizeof(Elf_Ehdr)) { 307ca987d46SWarner Losh err = EFTYPE; /* could be EIO, but may be small file */ 308ca987d46SWarner Losh goto error; 309ca987d46SWarner Losh } 310ca987d46SWarner Losh ehdr = ef->ehdr = (Elf_Ehdr *)ef->firstpage; 311ca987d46SWarner Losh 312ca987d46SWarner Losh /* Is it ELF? */ 313ca987d46SWarner Losh if (!IS_ELF(*ehdr)) { 314ca987d46SWarner Losh err = EFTYPE; 315ca987d46SWarner Losh goto error; 316ca987d46SWarner Losh } 3178de1ad0bSWojciech Macek 318ca987d46SWarner Losh if (ehdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || /* Layout ? */ 319ca987d46SWarner Losh ehdr->e_ident[EI_DATA] != ELF_TARG_DATA || 3208de1ad0bSWojciech Macek ehdr->e_ident[EI_VERSION] != EV_CURRENT) /* Version ? */ { 3218de1ad0bSWojciech Macek err = EFTYPE; 3228de1ad0bSWojciech Macek goto error; 3238de1ad0bSWojciech Macek } 3248de1ad0bSWojciech Macek 32512363d8eSRoger Pau Monné err = elf_header_convert(ehdr); 32612363d8eSRoger Pau Monné if (err) 32712363d8eSRoger Pau Monné goto error; 3288de1ad0bSWojciech Macek 3296b632498SEd Maste if (ehdr->e_version != EV_CURRENT || ehdr->e_machine != ELF_TARG_MACH) { 3306b632498SEd Maste /* Machine ? */ 331ca987d46SWarner Losh err = EFTYPE; 332ca987d46SWarner Losh goto error; 333ca987d46SWarner Losh } 334ca987d46SWarner Losh 335afc571b1SSimon J. Gerraty #if defined(LOADER_VERIEXEC) && !defined(LOADER_VERIEXEC_VECTX) 336afc571b1SSimon J. Gerraty if (verify_file(ef->fd, filename, bytes_read, VE_MUST, __func__) < 0) { 3378df8b2d3SSimon J. Gerraty err = EAUTH; 3388df8b2d3SSimon J. Gerraty goto error; 3398df8b2d3SSimon J. Gerraty } 3408df8b2d3SSimon J. Gerraty #endif 341ca987d46SWarner Losh return (0); 342ca987d46SWarner Losh 343ca987d46SWarner Losh error: 344ca987d46SWarner Losh if (ef->firstpage != NULL) { 345ca987d46SWarner Losh free(ef->firstpage); 346ca987d46SWarner Losh ef->firstpage = NULL; 347ca987d46SWarner Losh } 348ca987d46SWarner Losh if (ef->fd != -1) { 349afc571b1SSimon J. Gerraty #ifdef LOADER_VERIEXEC_VECTX 350afc571b1SSimon J. Gerraty free(ef->vctx); 351afc571b1SSimon J. Gerraty #endif 352ca987d46SWarner Losh close(ef->fd); 353ca987d46SWarner Losh ef->fd = -1; 354ca987d46SWarner Losh } 355ca987d46SWarner Losh return (err); 356ca987d46SWarner Losh } 357ca987d46SWarner Losh 358ca987d46SWarner Losh /* 359ca987d46SWarner Losh * Attempt to load the file (file) as an ELF module. It will be stored at 360ca987d46SWarner Losh * (dest), and a pointer to a module structure describing the loaded object 361ca987d46SWarner Losh * will be saved in (result). 362ca987d46SWarner Losh */ 363ca987d46SWarner Losh int 36456e53cb8SWarner Losh __elfN(loadfile)(char *filename, uint64_t dest, struct preloaded_file **result) 365ca987d46SWarner Losh { 366ca987d46SWarner Losh return (__elfN(loadfile_raw)(filename, dest, result, 0)); 367ca987d46SWarner Losh } 368ca987d46SWarner Losh 369ca987d46SWarner Losh int 37056e53cb8SWarner Losh __elfN(loadfile_raw)(char *filename, uint64_t dest, 371ca987d46SWarner Losh struct preloaded_file **result, int multiboot) 372ca987d46SWarner Losh { 373ca987d46SWarner Losh struct preloaded_file *fp, *kfp; 374ca987d46SWarner Losh struct elf_file ef; 375ca987d46SWarner Losh Elf_Ehdr *ehdr; 376ca987d46SWarner Losh int err; 377ca987d46SWarner Losh 378ca987d46SWarner Losh fp = NULL; 379ca987d46SWarner Losh bzero(&ef, sizeof(struct elf_file)); 380ca987d46SWarner Losh ef.fd = -1; 381ca987d46SWarner Losh 382ca987d46SWarner Losh err = __elfN(load_elf_header)(filename, &ef); 383ca987d46SWarner Losh if (err != 0) 384ca987d46SWarner Losh return (err); 385ca987d46SWarner Losh 386ca987d46SWarner Losh ehdr = ef.ehdr; 387ca987d46SWarner Losh 388ca987d46SWarner Losh /* 389ca987d46SWarner Losh * Check to see what sort of module we are. 390ca987d46SWarner Losh */ 391ca987d46SWarner Losh kfp = file_findfile(NULL, __elfN(kerneltype)); 392ca987d46SWarner Losh #ifdef __powerpc__ 393ca987d46SWarner Losh /* 394ca987d46SWarner Losh * Kernels can be ET_DYN, so just assume the first loaded object is the 395ca987d46SWarner Losh * kernel. This assumption will be checked later. 396ca987d46SWarner Losh */ 397ca987d46SWarner Losh if (kfp == NULL) 398ca987d46SWarner Losh ef.kernel = 1; 399ca987d46SWarner Losh #endif 400ca987d46SWarner Losh if (ef.kernel || ehdr->e_type == ET_EXEC) { 401ca987d46SWarner Losh /* Looks like a kernel */ 402ca987d46SWarner Losh if (kfp != NULL) { 4036b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 4046b632498SEd Maste "_loadfile: kernel already loaded\n"); 405ca987d46SWarner Losh err = EPERM; 406ca987d46SWarner Losh goto oerr; 407ca987d46SWarner Losh } 408ca987d46SWarner Losh /* 409ca987d46SWarner Losh * Calculate destination address based on kernel entrypoint. 410ca987d46SWarner Losh * 4116b632498SEd Maste * For ARM, the destination address is independent of any values 4126b632498SEd Maste * in the elf header (an ARM kernel can be loaded at any 2MB 4136b632498SEd Maste * boundary), so we leave dest set to the value calculated by 4146b632498SEd Maste * archsw.arch_loadaddr() and passed in to this function. 415ca987d46SWarner Losh */ 416ca987d46SWarner Losh #ifndef __arm__ 417ca987d46SWarner Losh if (ehdr->e_type == ET_EXEC) 418ca987d46SWarner Losh dest = (ehdr->e_entry & ~PAGE_MASK); 419ca987d46SWarner Losh #endif 420ca987d46SWarner Losh if ((ehdr->e_entry & ~PAGE_MASK) == 0) { 4216b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 4226b632498SEd Maste "_loadfile: not a kernel (maybe static binary?)\n"); 423ca987d46SWarner Losh err = EPERM; 424ca987d46SWarner Losh goto oerr; 425ca987d46SWarner Losh } 426ca987d46SWarner Losh ef.kernel = 1; 427ca987d46SWarner Losh 428ca987d46SWarner Losh } else if (ehdr->e_type == ET_DYN) { 429ca987d46SWarner Losh /* Looks like a kld module */ 430ca987d46SWarner Losh if (multiboot != 0) { 4316b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 4326b632498SEd Maste "_loadfile: can't load module as multiboot\n"); 433ca987d46SWarner Losh err = EPERM; 434ca987d46SWarner Losh goto oerr; 435ca987d46SWarner Losh } 436ca987d46SWarner Losh if (kfp == NULL) { 4376b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 4386b632498SEd Maste "_loadfile: can't load module before kernel\n"); 439ca987d46SWarner Losh err = EPERM; 440ca987d46SWarner Losh goto oerr; 441ca987d46SWarner Losh } 442ca987d46SWarner Losh if (strcmp(__elfN(kerneltype), kfp->f_type)) { 4436b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 4446b632498SEd Maste "_loadfile: can't load module with kernel type '%s'\n", 4456b632498SEd Maste kfp->f_type); 446ca987d46SWarner Losh err = EPERM; 447ca987d46SWarner Losh goto oerr; 448ca987d46SWarner Losh } 449ca987d46SWarner Losh /* Looks OK, got ahead */ 450ca987d46SWarner Losh ef.kernel = 0; 451ca987d46SWarner Losh 452ca987d46SWarner Losh } else { 453ca987d46SWarner Losh err = EFTYPE; 454ca987d46SWarner Losh goto oerr; 455ca987d46SWarner Losh } 456ca987d46SWarner Losh 457ca987d46SWarner Losh if (archsw.arch_loadaddr != NULL) 458ca987d46SWarner Losh dest = archsw.arch_loadaddr(LOAD_ELF, ehdr, dest); 459ca987d46SWarner Losh else 460ca987d46SWarner Losh dest = roundup(dest, PAGE_SIZE); 461ca987d46SWarner Losh 462ca987d46SWarner Losh /* 463ca987d46SWarner Losh * Ok, we think we should handle this. 464ca987d46SWarner Losh */ 465ca987d46SWarner Losh fp = file_alloc(); 466ca987d46SWarner Losh if (fp == NULL) { 4676b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 4686b632498SEd Maste "_loadfile: cannot allocate module info\n"); 469ca987d46SWarner Losh err = EPERM; 470ca987d46SWarner Losh goto out; 471ca987d46SWarner Losh } 472ca987d46SWarner Losh if (ef.kernel == 1 && multiboot == 0) 473ca987d46SWarner Losh setenv("kernelname", filename, 1); 474ca987d46SWarner Losh fp->f_name = strdup(filename); 475ca987d46SWarner Losh if (multiboot == 0) 476ca987d46SWarner Losh fp->f_type = strdup(ef.kernel ? 477ca987d46SWarner Losh __elfN(kerneltype) : __elfN(moduletype)); 478ca987d46SWarner Losh else 479ca987d46SWarner Losh fp->f_type = strdup("elf multiboot kernel"); 480ca987d46SWarner Losh 481ec042f46SSimon J. Gerraty if (module_verbose >= MODULE_VERBOSE_FULL) { 482ca987d46SWarner Losh if (ef.kernel) 4836b632498SEd Maste printf("%s entry at 0x%jx\n", filename, 4846b632498SEd Maste (uintmax_t)ehdr->e_entry); 485ec042f46SSimon J. Gerraty } else if (module_verbose > MODULE_VERBOSE_SILENT) 486ca987d46SWarner Losh printf("%s ", filename); 487ec042f46SSimon J. Gerraty 488ca987d46SWarner Losh fp->f_size = __elfN(loadimage)(fp, &ef, dest); 489ca987d46SWarner Losh if (fp->f_size == 0 || fp->f_addr == 0) 490ca987d46SWarner Losh goto ioerr; 491ca987d46SWarner Losh 492ca987d46SWarner Losh /* save exec header as metadata */ 493ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_ELFHDR, sizeof(*ehdr), ehdr); 494ca987d46SWarner Losh 495ca987d46SWarner Losh /* Load OK, return module pointer */ 496ca987d46SWarner Losh *result = (struct preloaded_file *)fp; 497ca987d46SWarner Losh err = 0; 498f75caed6SKonstantin Belousov #ifdef __amd64__ 4995e4279a8SRoger Pau Monné fp->f_kernphys_relocatable = multiboot || is_kernphys_relocatable(&ef); 500f75caed6SKonstantin Belousov #endif 501aaaa5a2eSWarner Losh #ifdef __i386__ 502aaaa5a2eSWarner Losh fp->f_tg_kernel_support = is_tg_kernel_support(fp, &ef); 503aaaa5a2eSWarner Losh #endif 504ca987d46SWarner Losh goto out; 505ca987d46SWarner Losh 506ca987d46SWarner Losh ioerr: 507ca987d46SWarner Losh err = EIO; 508ca987d46SWarner Losh oerr: 509ca987d46SWarner Losh file_discard(fp); 510ca987d46SWarner Losh out: 511ca987d46SWarner Losh if (ef.firstpage) 512ca987d46SWarner Losh free(ef.firstpage); 513afc571b1SSimon J. Gerraty if (ef.fd != -1) { 514afc571b1SSimon J. Gerraty #ifdef LOADER_VERIEXEC_VECTX 515afc571b1SSimon J. Gerraty if (!err && ef.vctx) { 516afc571b1SSimon J. Gerraty int verror; 517afc571b1SSimon J. Gerraty 518afc571b1SSimon J. Gerraty verror = vectx_close(ef.vctx, VE_MUST, __func__); 519afc571b1SSimon J. Gerraty if (verror) { 520afc571b1SSimon J. Gerraty err = EAUTH; 521afc571b1SSimon J. Gerraty file_discard(fp); 522afc571b1SSimon J. Gerraty } 523afc571b1SSimon J. Gerraty } 524afc571b1SSimon J. Gerraty #endif 525ca987d46SWarner Losh close(ef.fd); 526afc571b1SSimon J. Gerraty } 527ca987d46SWarner Losh return (err); 528ca987d46SWarner Losh } 529ca987d46SWarner Losh 530ca987d46SWarner Losh /* 531ca987d46SWarner Losh * With the file (fd) open on the image, and (ehdr) containing 532ca987d46SWarner Losh * the Elf header, load the image at (off) 533ca987d46SWarner Losh */ 534ca987d46SWarner Losh static int 53556e53cb8SWarner Losh __elfN(loadimage)(struct preloaded_file *fp, elf_file_t ef, uint64_t off) 536ca987d46SWarner Losh { 537ca987d46SWarner Losh int i; 538ca987d46SWarner Losh u_int j; 539ca987d46SWarner Losh Elf_Ehdr *ehdr; 540ca987d46SWarner Losh Elf_Phdr *phdr, *php; 541ca987d46SWarner Losh Elf_Shdr *shdr; 542ca987d46SWarner Losh char *shstr; 543ca987d46SWarner Losh int ret; 544ca987d46SWarner Losh vm_offset_t firstaddr; 545ca987d46SWarner Losh vm_offset_t lastaddr; 546ca987d46SWarner Losh size_t chunk; 547ca987d46SWarner Losh ssize_t result; 548ca987d46SWarner Losh Elf_Addr ssym, esym; 549ca987d46SWarner Losh Elf_Dyn *dp; 550ca987d46SWarner Losh Elf_Addr adp; 551ca987d46SWarner Losh Elf_Addr ctors; 552ca987d46SWarner Losh int ndp; 553ca987d46SWarner Losh int symstrindex; 554ca987d46SWarner Losh int symtabindex; 555ca987d46SWarner Losh Elf_Size size; 556ca987d46SWarner Losh u_int fpcopy; 557ca987d46SWarner Losh Elf_Sym sym; 558ca987d46SWarner Losh Elf_Addr p_start, p_end; 559ca987d46SWarner Losh 560ca987d46SWarner Losh dp = NULL; 561ca987d46SWarner Losh shdr = NULL; 562ca987d46SWarner Losh ret = 0; 563ca987d46SWarner Losh firstaddr = lastaddr = 0; 564ca987d46SWarner Losh ehdr = ef->ehdr; 5652f6823d4SJustin Hibbits #ifdef __powerpc__ 5662f6823d4SJustin Hibbits if (ef->kernel) { 5672f6823d4SJustin Hibbits #else 568ca987d46SWarner Losh if (ehdr->e_type == ET_EXEC) { 5692f6823d4SJustin Hibbits #endif 570ca987d46SWarner Losh #if defined(__i386__) || defined(__amd64__) 571ca987d46SWarner Losh #if __ELF_WORD_SIZE == 64 5726b632498SEd Maste /* x86_64 relocates after locore */ 5736b632498SEd Maste off = - (off & 0xffffffffff000000ull); 574ca987d46SWarner Losh #else 5756b632498SEd Maste /* i386 relocates after locore */ 5766b632498SEd Maste off = - (off & 0xff000000u); 577ca987d46SWarner Losh #endif 578ca987d46SWarner Losh #elif defined(__powerpc__) 579ca987d46SWarner Losh /* 5806b632498SEd Maste * On the purely virtual memory machines like e500, the kernel 5816b632498SEd Maste * is linked against its final VA range, which is most often 5826b632498SEd Maste * not available at the loader stage, but only after kernel 5836b632498SEd Maste * initializes and completes its VM settings. In such cases we 5846b632498SEd Maste * cannot use p_vaddr field directly to load ELF segments, but 5856b632498SEd Maste * put them at some 'load-time' locations. 586ca987d46SWarner Losh */ 587ca987d46SWarner Losh if (off & 0xf0000000u) { 588ca987d46SWarner Losh off = -(off & 0xf0000000u); 589ca987d46SWarner Losh /* 5906b632498SEd Maste * XXX the physical load address should not be 5916b632498SEd Maste * hardcoded. Note that the Book-E kernel assumes that 5926b632498SEd Maste * it's loaded at a 16MB boundary for now... 593ca987d46SWarner Losh */ 594ca987d46SWarner Losh off += 0x01000000; 5952f6823d4SJustin Hibbits } 596ca987d46SWarner Losh ehdr->e_entry += off; 597ec042f46SSimon J. Gerraty if (module_verbose >= MODULE_VERBOSE_FULL) 598ec042f46SSimon J. Gerraty printf("Converted entry 0x%jx\n", 599ec042f46SSimon J. Gerraty (uintmax_t)ehdr->e_entry); 600ec042f46SSimon J. Gerraty 601ca987d46SWarner Losh #elif defined(__arm__) && !defined(EFI) 602ca987d46SWarner Losh /* 6036b632498SEd Maste * The elf headers in arm kernels specify virtual addresses in 6046b632498SEd Maste * all header fields, even the ones that should be physical 6056b632498SEd Maste * addresses. We assume the entry point is in the first page, 6066b632498SEd Maste * and masking the page offset will leave us with the virtual 6076b632498SEd Maste * address the kernel was linked at. We subtract that from the 6086b632498SEd Maste * load offset, making 'off' into the value which, when added 6096b632498SEd Maste * to a virtual address in an elf header, translates it to a 6106b632498SEd Maste * physical address. We do the va->pa conversion on the entry 6116b632498SEd Maste * point address in the header now, so that later we can launch 6126b632498SEd Maste * the kernel by just jumping to that address. 613ca987d46SWarner Losh * 6146b632498SEd Maste * When booting from UEFI the copyin and copyout functions 6156b632498SEd Maste * handle adjusting the location relative to the first virtual 6166b632498SEd Maste * address. Because of this there is no need to adjust the 6176b632498SEd Maste * offset or entry point address as these will both be handled 6186b632498SEd Maste * by the efi code. 619ca987d46SWarner Losh */ 620ca987d46SWarner Losh off -= ehdr->e_entry & ~PAGE_MASK; 621ca987d46SWarner Losh ehdr->e_entry += off; 622ec042f46SSimon J. Gerraty if (module_verbose >= MODULE_VERBOSE_FULL) 623637b6532SEnji Cooper printf("ehdr->e_entry 0x%jx, va<->pa off %llx\n", 624ff7449d6SLeandro Lupori (uintmax_t)ehdr->e_entry, off); 625ca987d46SWarner Losh #else 626ca987d46SWarner Losh off = 0; /* other archs use direct mapped kernels */ 627ca987d46SWarner Losh #endif 628ca987d46SWarner Losh } 629ca987d46SWarner Losh ef->off = off; 630ca987d46SWarner Losh 631ca987d46SWarner Losh if (ef->kernel) 632ca987d46SWarner Losh __elfN(relocation_offset) = off; 633ca987d46SWarner Losh 634ca987d46SWarner Losh if ((ehdr->e_phoff + ehdr->e_phnum * sizeof(*phdr)) > ef->firstlen) { 6356b632498SEd Maste printf("elf" __XSTRING(__ELF_WORD_SIZE) 6366b632498SEd Maste "_loadimage: program header not within first page\n"); 637ca987d46SWarner Losh goto out; 638ca987d46SWarner Losh } 639ca987d46SWarner Losh phdr = (Elf_Phdr *)(ef->firstpage + ehdr->e_phoff); 640ca987d46SWarner Losh 641ca987d46SWarner Losh for (i = 0; i < ehdr->e_phnum; i++) { 64212363d8eSRoger Pau Monné if (elf_program_header_convert(ehdr, phdr)) 64312363d8eSRoger Pau Monné continue; 6448de1ad0bSWojciech Macek 645ca987d46SWarner Losh /* We want to load PT_LOAD segments only.. */ 646ca987d46SWarner Losh if (phdr[i].p_type != PT_LOAD) 647ca987d46SWarner Losh continue; 648ca987d46SWarner Losh 649ec042f46SSimon J. Gerraty if (module_verbose >= MODULE_VERBOSE_FULL) { 650ca987d46SWarner Losh printf("Segment: 0x%lx@0x%lx -> 0x%lx-0x%lx", 651ca987d46SWarner Losh (long)phdr[i].p_filesz, (long)phdr[i].p_offset, 652ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off), 653ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1)); 654ec042f46SSimon J. Gerraty } else if (module_verbose > MODULE_VERBOSE_SILENT) { 655ca987d46SWarner Losh if ((phdr[i].p_flags & PF_W) == 0) { 656ca987d46SWarner Losh printf("text=0x%lx ", (long)phdr[i].p_filesz); 657ca987d46SWarner Losh } else { 658ca987d46SWarner Losh printf("data=0x%lx", (long)phdr[i].p_filesz); 659ca987d46SWarner Losh if (phdr[i].p_filesz < phdr[i].p_memsz) 6606b632498SEd Maste printf("+0x%lx", (long)(phdr[i].p_memsz - 6616b632498SEd Maste phdr[i].p_filesz)); 662ca987d46SWarner Losh printf(" "); 663ca987d46SWarner Losh } 664ec042f46SSimon J. Gerraty } 665ca987d46SWarner Losh fpcopy = 0; 666ca987d46SWarner Losh if (ef->firstlen > phdr[i].p_offset) { 667ca987d46SWarner Losh fpcopy = ef->firstlen - phdr[i].p_offset; 668ca987d46SWarner Losh archsw.arch_copyin(ef->firstpage + phdr[i].p_offset, 669ca987d46SWarner Losh phdr[i].p_vaddr + off, fpcopy); 670ca987d46SWarner Losh } 671ca987d46SWarner Losh if (phdr[i].p_filesz > fpcopy) { 672afc571b1SSimon J. Gerraty if (kern_pread(VECTX_HANDLE(ef), 673afc571b1SSimon J. Gerraty phdr[i].p_vaddr + off + fpcopy, 6746b632498SEd Maste phdr[i].p_filesz - fpcopy, 6756b632498SEd Maste phdr[i].p_offset + fpcopy) != 0) { 676ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 677ca987d46SWarner Losh "_loadimage: read failed\n"); 678ca987d46SWarner Losh goto out; 679ca987d46SWarner Losh } 680ca987d46SWarner Losh } 681ca987d46SWarner Losh /* clear space from oversized segments; eg: bss */ 682ca987d46SWarner Losh if (phdr[i].p_filesz < phdr[i].p_memsz) { 683ec042f46SSimon J. Gerraty if (module_verbose >= MODULE_VERBOSE_FULL) { 684ca987d46SWarner Losh printf(" (bss: 0x%lx-0x%lx)", 685ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_filesz), 686ca987d46SWarner Losh (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz -1)); 687ec042f46SSimon J. Gerraty } 688ca987d46SWarner Losh kern_bzero(phdr[i].p_vaddr + off + phdr[i].p_filesz, 689ca987d46SWarner Losh phdr[i].p_memsz - phdr[i].p_filesz); 690ca987d46SWarner Losh } 691ec042f46SSimon J. Gerraty if (module_verbose >= MODULE_VERBOSE_FULL) 692ca987d46SWarner Losh printf("\n"); 693ca987d46SWarner Losh 694ca987d46SWarner Losh if (archsw.arch_loadseg != NULL) 695ca987d46SWarner Losh archsw.arch_loadseg(ehdr, phdr + i, off); 696ca987d46SWarner Losh 697ca987d46SWarner Losh if (firstaddr == 0 || firstaddr > (phdr[i].p_vaddr + off)) 698ca987d46SWarner Losh firstaddr = phdr[i].p_vaddr + off; 6996b632498SEd Maste if (lastaddr == 0 || lastaddr < 7006b632498SEd Maste (phdr[i].p_vaddr + off + phdr[i].p_memsz)) 701ca987d46SWarner Losh lastaddr = phdr[i].p_vaddr + off + phdr[i].p_memsz; 702ca987d46SWarner Losh } 703ca987d46SWarner Losh lastaddr = roundup(lastaddr, sizeof(long)); 704ca987d46SWarner Losh 705ca987d46SWarner Losh /* 706ca987d46SWarner Losh * Get the section headers. We need this for finding the .ctors 707ca987d46SWarner Losh * section as well as for loading any symbols. Both may be hard 708ca987d46SWarner Losh * to do if reading from a .gz file as it involves seeking. I 709ca987d46SWarner Losh * think the rule is going to have to be that you must strip a 710ca987d46SWarner Losh * file to remove symbols before gzipping it. 711ca987d46SWarner Losh */ 712db711744SWarner Losh chunk = (size_t)ehdr->e_shnum * (size_t)ehdr->e_shentsize; 713ca987d46SWarner Losh if (chunk == 0 || ehdr->e_shoff == 0) 714ca987d46SWarner Losh goto nosyms; 715afc571b1SSimon J. Gerraty shdr = alloc_pread(VECTX_HANDLE(ef), ehdr->e_shoff, chunk); 716ca987d46SWarner Losh if (shdr == NULL) { 717ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 718ca987d46SWarner Losh "_loadimage: failed to read section headers"); 719ca987d46SWarner Losh goto nosyms; 720ca987d46SWarner Losh } 7218de1ad0bSWojciech Macek 72212363d8eSRoger Pau Monné for (i = 0; i < ehdr->e_shnum; i++) 72312363d8eSRoger Pau Monné elf_section_header_convert(ehdr, &shdr[i]); 7245cca46a9SEd Maste 725ca987d46SWarner Losh file_addmetadata(fp, MODINFOMD_SHDR, chunk, shdr); 726ca987d46SWarner Losh 727ca987d46SWarner Losh /* 728ca987d46SWarner Losh * Read the section string table and look for the .ctors section. 729ca987d46SWarner Losh * We need to tell the kernel where it is so that it can call the 730ca987d46SWarner Losh * ctors. 731ca987d46SWarner Losh */ 732ca987d46SWarner Losh chunk = shdr[ehdr->e_shstrndx].sh_size; 733ca987d46SWarner Losh if (chunk) { 734afc571b1SSimon J. Gerraty shstr = alloc_pread(VECTX_HANDLE(ef), 735afc571b1SSimon J. Gerraty shdr[ehdr->e_shstrndx].sh_offset, chunk); 736ca987d46SWarner Losh if (shstr) { 737ca987d46SWarner Losh for (i = 0; i < ehdr->e_shnum; i++) { 7386b632498SEd Maste if (strcmp(shstr + shdr[i].sh_name, 7396b632498SEd Maste ".ctors") != 0) 740ca987d46SWarner Losh continue; 741ca987d46SWarner Losh ctors = shdr[i].sh_addr; 7426b632498SEd Maste file_addmetadata(fp, MODINFOMD_CTORS_ADDR, 7436b632498SEd Maste sizeof(ctors), &ctors); 744ca987d46SWarner Losh size = shdr[i].sh_size; 7456b632498SEd Maste file_addmetadata(fp, MODINFOMD_CTORS_SIZE, 7466b632498SEd Maste sizeof(size), &size); 747ca987d46SWarner Losh break; 748ca987d46SWarner Losh } 749ca987d46SWarner Losh free(shstr); 750ca987d46SWarner Losh } 751ca987d46SWarner Losh } 752ca987d46SWarner Losh 753ca987d46SWarner Losh /* 754ca987d46SWarner Losh * Now load any symbols. 755ca987d46SWarner Losh */ 756ca987d46SWarner Losh symtabindex = -1; 757ca987d46SWarner Losh symstrindex = -1; 758ca987d46SWarner Losh for (i = 0; i < ehdr->e_shnum; i++) { 759ca987d46SWarner Losh if (shdr[i].sh_type != SHT_SYMTAB) 760ca987d46SWarner Losh continue; 761ca987d46SWarner Losh for (j = 0; j < ehdr->e_phnum; j++) { 762ca987d46SWarner Losh if (phdr[j].p_type != PT_LOAD) 763ca987d46SWarner Losh continue; 764ca987d46SWarner Losh if (shdr[i].sh_offset >= phdr[j].p_offset && 765ca987d46SWarner Losh (shdr[i].sh_offset + shdr[i].sh_size <= 766ca987d46SWarner Losh phdr[j].p_offset + phdr[j].p_filesz)) { 767ca987d46SWarner Losh shdr[i].sh_offset = 0; 768ca987d46SWarner Losh shdr[i].sh_size = 0; 769ca987d46SWarner Losh break; 770ca987d46SWarner Losh } 771ca987d46SWarner Losh } 772ca987d46SWarner Losh if (shdr[i].sh_offset == 0 || shdr[i].sh_size == 0) 773ca987d46SWarner Losh continue; /* alread loaded in a PT_LOAD above */ 774ca987d46SWarner Losh /* Save it for loading below */ 775ca987d46SWarner Losh symtabindex = i; 776ca987d46SWarner Losh symstrindex = shdr[i].sh_link; 777ca987d46SWarner Losh } 778ca987d46SWarner Losh if (symtabindex < 0 || symstrindex < 0) 779ca987d46SWarner Losh goto nosyms; 780ca987d46SWarner Losh 781ca987d46SWarner Losh /* Ok, committed to a load. */ 782ec042f46SSimon J. Gerraty if (module_verbose >= MODULE_VERBOSE_FULL) 783ca987d46SWarner Losh printf("syms=["); 784ca987d46SWarner Losh ssym = lastaddr; 785ca987d46SWarner Losh for (i = symtabindex; i >= 0; i = symstrindex) { 786ca987d46SWarner Losh char *secname; 787ca987d46SWarner Losh 788ca987d46SWarner Losh switch(shdr[i].sh_type) { 789ca987d46SWarner Losh case SHT_SYMTAB: /* Symbol table */ 790ca987d46SWarner Losh secname = "symtab"; 791ca987d46SWarner Losh break; 792ca987d46SWarner Losh case SHT_STRTAB: /* String table */ 793ca987d46SWarner Losh secname = "strtab"; 794ca987d46SWarner Losh break; 795ca987d46SWarner Losh default: 796ca987d46SWarner Losh secname = "WHOA!!"; 797ca987d46SWarner Losh break; 798ca987d46SWarner Losh } 799ca987d46SWarner Losh size = shdr[i].sh_size; 8005cca46a9SEd Maste 8015cca46a9SEd Maste archsw.arch_copyin(&size, lastaddr, sizeof(size)); 8025cca46a9SEd Maste lastaddr += sizeof(size); 803ca987d46SWarner Losh 804ec042f46SSimon J. Gerraty if (module_verbose >= MODULE_VERBOSE_FULL) { 805ca987d46SWarner Losh printf("\n%s: 0x%jx@0x%jx -> 0x%jx-0x%jx", secname, 806ca987d46SWarner Losh (uintmax_t)shdr[i].sh_size, (uintmax_t)shdr[i].sh_offset, 8076b632498SEd Maste (uintmax_t)lastaddr, 8086b632498SEd Maste (uintmax_t)(lastaddr + shdr[i].sh_size)); 809ec042f46SSimon J. Gerraty } else if (module_verbose > MODULE_VERBOSE_SILENT) { 810ca987d46SWarner Losh if (i == symstrindex) 811ca987d46SWarner Losh printf("+"); 812ca987d46SWarner Losh printf("0x%lx+0x%lx", (long)sizeof(size), (long)size); 813ec042f46SSimon J. Gerraty } 814afc571b1SSimon J. Gerraty if (VECTX_LSEEK(VECTX_HANDLE(ef), (off_t)shdr[i].sh_offset, SEEK_SET) == -1) { 8156b632498SEd Maste printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 8166b632498SEd Maste "_loadimage: could not seek for symbols - skipped!"); 817ca987d46SWarner Losh lastaddr = ssym; 818ca987d46SWarner Losh ssym = 0; 819ca987d46SWarner Losh goto nosyms; 820ca987d46SWarner Losh } 821afc571b1SSimon J. Gerraty result = archsw.arch_readin(VECTX_HANDLE(ef), lastaddr, shdr[i].sh_size); 822ca987d46SWarner Losh if (result < 0 || (size_t)result != shdr[i].sh_size) { 8236b632498SEd Maste printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 8246b632498SEd Maste "_loadimage: could not read symbols - skipped! " 8256b632498SEd Maste "(%ju != %ju)", (uintmax_t)result, 826ca987d46SWarner Losh (uintmax_t)shdr[i].sh_size); 827ca987d46SWarner Losh lastaddr = ssym; 828ca987d46SWarner Losh ssym = 0; 829ca987d46SWarner Losh goto nosyms; 830ca987d46SWarner Losh } 831ca987d46SWarner Losh /* Reset offsets relative to ssym */ 832ca987d46SWarner Losh lastaddr += shdr[i].sh_size; 833ca987d46SWarner Losh lastaddr = roundup(lastaddr, sizeof(size)); 834ca987d46SWarner Losh if (i == symtabindex) 835ca987d46SWarner Losh symtabindex = -1; 836ca987d46SWarner Losh else if (i == symstrindex) 837ca987d46SWarner Losh symstrindex = -1; 838ca987d46SWarner Losh } 839ca987d46SWarner Losh esym = lastaddr; 840ec042f46SSimon J. Gerraty if (module_verbose >= MODULE_VERBOSE_FULL) 841ca987d46SWarner Losh printf("]"); 842ca987d46SWarner Losh 8435cca46a9SEd Maste file_addmetadata(fp, MODINFOMD_SSYM, sizeof(ssym), &ssym); 8445cca46a9SEd Maste file_addmetadata(fp, MODINFOMD_ESYM, sizeof(esym), &esym); 845ca987d46SWarner Losh 846ca987d46SWarner Losh nosyms: 847ec042f46SSimon J. Gerraty if (module_verbose > MODULE_VERBOSE_SILENT) 848ca987d46SWarner Losh printf("\n"); 849ca987d46SWarner Losh 850ca987d46SWarner Losh ret = lastaddr - firstaddr; 851ca987d46SWarner Losh fp->f_addr = firstaddr; 852ca987d46SWarner Losh 853ca987d46SWarner Losh php = NULL; 854ca987d46SWarner Losh for (i = 0; i < ehdr->e_phnum; i++) { 855ca987d46SWarner Losh if (phdr[i].p_type == PT_DYNAMIC) { 856ca987d46SWarner Losh php = phdr + i; 857ca987d46SWarner Losh adp = php->p_vaddr; 8586b632498SEd Maste file_addmetadata(fp, MODINFOMD_DYNAMIC, sizeof(adp), 8596b632498SEd Maste &adp); 860ca987d46SWarner Losh break; 861ca987d46SWarner Losh } 862ca987d46SWarner Losh } 863ca987d46SWarner Losh 864ca987d46SWarner Losh if (php == NULL) /* this is bad, we cannot get to symbols or _DYNAMIC */ 865ca987d46SWarner Losh goto out; 866ca987d46SWarner Losh 867ca987d46SWarner Losh ndp = php->p_filesz / sizeof(Elf_Dyn); 868ca987d46SWarner Losh if (ndp == 0) 869ca987d46SWarner Losh goto out; 870ca987d46SWarner Losh dp = malloc(php->p_filesz); 871ca987d46SWarner Losh if (dp == NULL) 872ca987d46SWarner Losh goto out; 873ca987d46SWarner Losh archsw.arch_copyout(php->p_vaddr + off, dp, php->p_filesz); 874ca987d46SWarner Losh 875ca987d46SWarner Losh ef->strsz = 0; 876ca987d46SWarner Losh for (i = 0; i < ndp; i++) { 877ca987d46SWarner Losh if (dp[i].d_tag == 0) 878ca987d46SWarner Losh break; 879ca987d46SWarner Losh switch (dp[i].d_tag) { 880ca987d46SWarner Losh case DT_HASH: 8816b632498SEd Maste ef->hashtab = 8826b632498SEd Maste (Elf_Hashelt*)(uintptr_t)(dp[i].d_un.d_ptr + off); 883ca987d46SWarner Losh break; 884ca987d46SWarner Losh case DT_STRTAB: 8856b632498SEd Maste ef->strtab = 8866b632498SEd Maste (char *)(uintptr_t)(dp[i].d_un.d_ptr + off); 887ca987d46SWarner Losh break; 888ca987d46SWarner Losh case DT_STRSZ: 889ca987d46SWarner Losh ef->strsz = dp[i].d_un.d_val; 890ca987d46SWarner Losh break; 891ca987d46SWarner Losh case DT_SYMTAB: 8926b632498SEd Maste ef->symtab = 8936b632498SEd Maste (Elf_Sym *)(uintptr_t)(dp[i].d_un.d_ptr + off); 894ca987d46SWarner Losh break; 895ca987d46SWarner Losh case DT_REL: 8966b632498SEd Maste ef->rel = 8976b632498SEd Maste (Elf_Rel *)(uintptr_t)(dp[i].d_un.d_ptr + off); 898ca987d46SWarner Losh break; 899ca987d46SWarner Losh case DT_RELSZ: 900ca987d46SWarner Losh ef->relsz = dp[i].d_un.d_val; 901ca987d46SWarner Losh break; 902ca987d46SWarner Losh case DT_RELA: 9036b632498SEd Maste ef->rela = 9046b632498SEd Maste (Elf_Rela *)(uintptr_t)(dp[i].d_un.d_ptr + off); 905ca987d46SWarner Losh break; 906ca987d46SWarner Losh case DT_RELASZ: 907ca987d46SWarner Losh ef->relasz = dp[i].d_un.d_val; 908ca987d46SWarner Losh break; 909ca987d46SWarner Losh default: 910ca987d46SWarner Losh break; 911ca987d46SWarner Losh } 912ca987d46SWarner Losh } 913ca987d46SWarner Losh if (ef->hashtab == NULL || ef->symtab == NULL || 914ca987d46SWarner Losh ef->strtab == NULL || ef->strsz == 0) 915ca987d46SWarner Losh goto out; 916ca987d46SWarner Losh COPYOUT(ef->hashtab, &ef->nbuckets, sizeof(ef->nbuckets)); 917ca987d46SWarner Losh COPYOUT(ef->hashtab + 1, &ef->nchains, sizeof(ef->nchains)); 918ca987d46SWarner Losh ef->buckets = ef->hashtab + 2; 919ca987d46SWarner Losh ef->chains = ef->buckets + ef->nbuckets; 920ca987d46SWarner Losh 9216c7a932dSToomas Soome if (__elfN(lookup_symbol)(ef, "__start_set_modmetadata_set", &sym, 9226c7a932dSToomas Soome STT_NOTYPE) != 0) 923ca987d46SWarner Losh return 0; 924ca987d46SWarner Losh p_start = sym.st_value + ef->off; 9256c7a932dSToomas Soome if (__elfN(lookup_symbol)(ef, "__stop_set_modmetadata_set", &sym, 9266c7a932dSToomas Soome STT_NOTYPE) != 0) 9271ea87e2aSMark Johnston return 0; 928ca987d46SWarner Losh p_end = sym.st_value + ef->off; 929ca987d46SWarner Losh 930ca987d46SWarner Losh if (__elfN(parse_modmetadata)(fp, ef, p_start, p_end) == 0) 931ca987d46SWarner Losh goto out; 932ca987d46SWarner Losh 933ca987d46SWarner Losh if (ef->kernel) /* kernel must not depend on anything */ 934ca987d46SWarner Losh goto out; 935ca987d46SWarner Losh 936ca987d46SWarner Losh out: 937ca987d46SWarner Losh if (dp) 938ca987d46SWarner Losh free(dp); 939ca987d46SWarner Losh if (shdr) 940ca987d46SWarner Losh free(shdr); 941ca987d46SWarner Losh return ret; 942ca987d46SWarner Losh } 943ca987d46SWarner Losh 944ca987d46SWarner Losh static char invalid_name[] = "bad"; 945ca987d46SWarner Losh 946ca987d46SWarner Losh char * 947ca987d46SWarner Losh fake_modname(const char *name) 948ca987d46SWarner Losh { 949ca987d46SWarner Losh const char *sp, *ep; 950ca987d46SWarner Losh char *fp; 951ca987d46SWarner Losh size_t len; 952ca987d46SWarner Losh 953ca987d46SWarner Losh sp = strrchr(name, '/'); 954ca987d46SWarner Losh if (sp) 955ca987d46SWarner Losh sp++; 956ca987d46SWarner Losh else 957ca987d46SWarner Losh sp = name; 958fe6ee081SEd Maste 959fe6ee081SEd Maste ep = strrchr(sp, '.'); 960fe6ee081SEd Maste if (ep == NULL) { 961fe6ee081SEd Maste ep = sp + strlen(sp); 962fe6ee081SEd Maste } 963fe6ee081SEd Maste if (ep == sp) { 964ca987d46SWarner Losh sp = invalid_name; 965ca987d46SWarner Losh ep = invalid_name + sizeof(invalid_name) - 1; 966ca987d46SWarner Losh } 967fe6ee081SEd Maste 968ca987d46SWarner Losh len = ep - sp; 969ca987d46SWarner Losh fp = malloc(len + 1); 970ca987d46SWarner Losh if (fp == NULL) 971ca987d46SWarner Losh return NULL; 972ca987d46SWarner Losh memcpy(fp, sp, len); 973ca987d46SWarner Losh fp[len] = '\0'; 974ca987d46SWarner Losh return fp; 975ca987d46SWarner Losh } 976ca987d46SWarner Losh 977ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 978ca987d46SWarner Losh struct mod_metadata64 { 979ca987d46SWarner Losh int md_version; /* structure version MDTV_* */ 980ca987d46SWarner Losh int md_type; /* type of entry MDT_* */ 98156e53cb8SWarner Losh uint64_t md_data; /* specific data */ 98256e53cb8SWarner Losh uint64_t md_cval; /* common string label */ 983ca987d46SWarner Losh }; 984ca987d46SWarner Losh #endif 985ca987d46SWarner Losh #if defined(__amd64__) && __ELF_WORD_SIZE == 32 986ca987d46SWarner Losh struct mod_metadata32 { 987ca987d46SWarner Losh int md_version; /* structure version MDTV_* */ 988ca987d46SWarner Losh int md_type; /* type of entry MDT_* */ 98956e53cb8SWarner Losh uint32_t md_data; /* specific data */ 99056e53cb8SWarner Losh uint32_t md_cval; /* common string label */ 991ca987d46SWarner Losh }; 992ca987d46SWarner Losh #endif 993ca987d46SWarner Losh 994ca987d46SWarner Losh int 99556e53cb8SWarner Losh __elfN(load_modmetadata)(struct preloaded_file *fp, uint64_t dest) 996ca987d46SWarner Losh { 997ca987d46SWarner Losh struct elf_file ef; 998ca987d46SWarner Losh int err, i, j; 999ca987d46SWarner Losh Elf_Shdr *sh_meta, *shdr = NULL; 1000ca987d46SWarner Losh Elf_Shdr *sh_data[2]; 1001ca987d46SWarner Losh char *shstrtab = NULL; 1002ca987d46SWarner Losh size_t size; 1003ca987d46SWarner Losh Elf_Addr p_start, p_end; 1004ca987d46SWarner Losh 1005ca987d46SWarner Losh bzero(&ef, sizeof(struct elf_file)); 1006ca987d46SWarner Losh ef.fd = -1; 1007ca987d46SWarner Losh 1008ca987d46SWarner Losh err = __elfN(load_elf_header)(fp->f_name, &ef); 1009ca987d46SWarner Losh if (err != 0) 1010ca987d46SWarner Losh goto out; 1011ca987d46SWarner Losh 1012ca987d46SWarner Losh if (ef.kernel == 1 || ef.ehdr->e_type == ET_EXEC) { 1013ca987d46SWarner Losh ef.kernel = 1; 1014ca987d46SWarner Losh } else if (ef.ehdr->e_type != ET_DYN) { 1015ca987d46SWarner Losh err = EFTYPE; 1016ca987d46SWarner Losh goto out; 1017ca987d46SWarner Losh } 1018ca987d46SWarner Losh 1019db711744SWarner Losh size = (size_t)ef.ehdr->e_shnum * (size_t)ef.ehdr->e_shentsize; 1020afc571b1SSimon J. Gerraty shdr = alloc_pread(VECTX_HANDLE(&ef), ef.ehdr->e_shoff, size); 1021ca987d46SWarner Losh if (shdr == NULL) { 1022ca987d46SWarner Losh err = ENOMEM; 1023ca987d46SWarner Losh goto out; 1024ca987d46SWarner Losh } 1025ca987d46SWarner Losh 1026ca987d46SWarner Losh /* Load shstrtab. */ 1027afc571b1SSimon J. Gerraty shstrtab = alloc_pread(VECTX_HANDLE(&ef), shdr[ef.ehdr->e_shstrndx].sh_offset, 1028ca987d46SWarner Losh shdr[ef.ehdr->e_shstrndx].sh_size); 1029ca987d46SWarner Losh if (shstrtab == NULL) { 1030ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 1031ca987d46SWarner Losh "load_modmetadata: unable to load shstrtab\n"); 1032ca987d46SWarner Losh err = EFTYPE; 1033ca987d46SWarner Losh goto out; 1034ca987d46SWarner Losh } 1035ca987d46SWarner Losh 1036ca987d46SWarner Losh /* Find set_modmetadata_set and data sections. */ 1037ca987d46SWarner Losh sh_data[0] = sh_data[1] = sh_meta = NULL; 1038ca987d46SWarner Losh for (i = 0, j = 0; i < ef.ehdr->e_shnum; i++) { 1039ca987d46SWarner Losh if (strcmp(&shstrtab[shdr[i].sh_name], 1040ca987d46SWarner Losh "set_modmetadata_set") == 0) { 1041ca987d46SWarner Losh sh_meta = &shdr[i]; 1042ca987d46SWarner Losh } 1043ca987d46SWarner Losh if ((strcmp(&shstrtab[shdr[i].sh_name], ".data") == 0) || 1044ca987d46SWarner Losh (strcmp(&shstrtab[shdr[i].sh_name], ".rodata") == 0)) { 1045ca987d46SWarner Losh sh_data[j++] = &shdr[i]; 1046ca987d46SWarner Losh } 1047ca987d46SWarner Losh } 1048ca987d46SWarner Losh if (sh_meta == NULL || sh_data[0] == NULL || sh_data[1] == NULL) { 1049ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 1050ca987d46SWarner Losh "load_modmetadata: unable to find set_modmetadata_set or data sections\n"); 1051ca987d46SWarner Losh err = EFTYPE; 1052ca987d46SWarner Losh goto out; 1053ca987d46SWarner Losh } 1054ca987d46SWarner Losh 1055ca987d46SWarner Losh /* Load set_modmetadata_set into memory */ 1056afc571b1SSimon J. Gerraty err = kern_pread(VECTX_HANDLE(&ef), dest, sh_meta->sh_size, sh_meta->sh_offset); 1057ca987d46SWarner Losh if (err != 0) { 1058ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 1059ca987d46SWarner Losh "load_modmetadata: unable to load set_modmetadata_set: %d\n", err); 1060ca987d46SWarner Losh goto out; 1061ca987d46SWarner Losh } 1062ca987d46SWarner Losh p_start = dest; 1063ca987d46SWarner Losh p_end = dest + sh_meta->sh_size; 1064ca987d46SWarner Losh dest += sh_meta->sh_size; 1065ca987d46SWarner Losh 1066ca987d46SWarner Losh /* Load data sections into memory. */ 1067afc571b1SSimon J. Gerraty err = kern_pread(VECTX_HANDLE(&ef), dest, sh_data[0]->sh_size, 1068ca987d46SWarner Losh sh_data[0]->sh_offset); 1069ca987d46SWarner Losh if (err != 0) { 1070ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 1071ca987d46SWarner Losh "load_modmetadata: unable to load data: %d\n", err); 1072ca987d46SWarner Losh goto out; 1073ca987d46SWarner Losh } 1074ca987d46SWarner Losh 1075ca987d46SWarner Losh /* 1076ca987d46SWarner Losh * We have to increment the dest, so that the offset is the same into 1077ca987d46SWarner Losh * both the .rodata and .data sections. 1078ca987d46SWarner Losh */ 1079ca987d46SWarner Losh ef.off = -(sh_data[0]->sh_addr - dest); 1080ca987d46SWarner Losh dest += (sh_data[1]->sh_addr - sh_data[0]->sh_addr); 1081ca987d46SWarner Losh 1082afc571b1SSimon J. Gerraty err = kern_pread(VECTX_HANDLE(&ef), dest, sh_data[1]->sh_size, 1083ca987d46SWarner Losh sh_data[1]->sh_offset); 1084ca987d46SWarner Losh if (err != 0) { 1085ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 1086ca987d46SWarner Losh "load_modmetadata: unable to load data: %d\n", err); 1087ca987d46SWarner Losh goto out; 1088ca987d46SWarner Losh } 1089ca987d46SWarner Losh 1090ca987d46SWarner Losh err = __elfN(parse_modmetadata)(fp, &ef, p_start, p_end); 1091ca987d46SWarner Losh if (err != 0) { 1092ca987d46SWarner Losh printf("\nelf" __XSTRING(__ELF_WORD_SIZE) 1093ca987d46SWarner Losh "load_modmetadata: unable to parse metadata: %d\n", err); 1094ca987d46SWarner Losh goto out; 1095ca987d46SWarner Losh } 1096ca987d46SWarner Losh 1097ca987d46SWarner Losh out: 1098ca987d46SWarner Losh if (shstrtab != NULL) 1099ca987d46SWarner Losh free(shstrtab); 1100ca987d46SWarner Losh if (shdr != NULL) 1101ca987d46SWarner Losh free(shdr); 1102ca987d46SWarner Losh if (ef.firstpage != NULL) 1103ca987d46SWarner Losh free(ef.firstpage); 1104afc571b1SSimon J. Gerraty if (ef.fd != -1) { 1105afc571b1SSimon J. Gerraty #ifdef LOADER_VERIEXEC_VECTX 1106afc571b1SSimon J. Gerraty if (!err && ef.vctx) { 1107afc571b1SSimon J. Gerraty int verror; 1108afc571b1SSimon J. Gerraty 1109afc571b1SSimon J. Gerraty verror = vectx_close(ef.vctx, VE_MUST, __func__); 1110afc571b1SSimon J. Gerraty if (verror) { 1111afc571b1SSimon J. Gerraty err = EAUTH; 1112afc571b1SSimon J. Gerraty file_discard(fp); 1113afc571b1SSimon J. Gerraty } 1114afc571b1SSimon J. Gerraty } 1115afc571b1SSimon J. Gerraty #endif 1116ca987d46SWarner Losh close(ef.fd); 1117afc571b1SSimon J. Gerraty } 1118ca987d46SWarner Losh return (err); 1119ca987d46SWarner Losh } 1120ca987d46SWarner Losh 1121ca987d46SWarner Losh int 1122ca987d46SWarner Losh __elfN(parse_modmetadata)(struct preloaded_file *fp, elf_file_t ef, 1123ca987d46SWarner Losh Elf_Addr p_start, Elf_Addr p_end) 1124ca987d46SWarner Losh { 1125ca987d46SWarner Losh struct mod_metadata md; 1126ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 1127ca987d46SWarner Losh struct mod_metadata64 md64; 1128ca987d46SWarner Losh #elif defined(__amd64__) && __ELF_WORD_SIZE == 32 1129ca987d46SWarner Losh struct mod_metadata32 md32; 1130ca987d46SWarner Losh #endif 1131ca987d46SWarner Losh struct mod_depend *mdepend; 1132ca987d46SWarner Losh struct mod_version mver; 1133ca987d46SWarner Losh char *s; 1134ca987d46SWarner Losh int error, modcnt, minfolen; 1135ca987d46SWarner Losh Elf_Addr v, p; 1136ca987d46SWarner Losh 1137ca987d46SWarner Losh modcnt = 0; 1138ca987d46SWarner Losh p = p_start; 1139ca987d46SWarner Losh while (p < p_end) { 1140ca987d46SWarner Losh COPYOUT(p, &v, sizeof(v)); 1141ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, p, &v, sizeof(v)); 1142ca987d46SWarner Losh if (error == EOPNOTSUPP) 1143ca987d46SWarner Losh v += ef->off; 1144ca987d46SWarner Losh else if (error != 0) 1145ca987d46SWarner Losh return (error); 1146ca987d46SWarner Losh #if (defined(__i386__) || defined(__powerpc__)) && __ELF_WORD_SIZE == 64 1147ca987d46SWarner Losh COPYOUT(v, &md64, sizeof(md64)); 1148ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md64, sizeof(md64)); 1149ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1150ca987d46SWarner Losh md64.md_cval += ef->off; 1151ca987d46SWarner Losh md64.md_data += ef->off; 1152ca987d46SWarner Losh } else if (error != 0) 1153ca987d46SWarner Losh return (error); 1154ca987d46SWarner Losh md.md_version = md64.md_version; 1155ca987d46SWarner Losh md.md_type = md64.md_type; 1156ca987d46SWarner Losh md.md_cval = (const char *)(uintptr_t)md64.md_cval; 1157ca987d46SWarner Losh md.md_data = (void *)(uintptr_t)md64.md_data; 1158ca987d46SWarner Losh #elif defined(__amd64__) && __ELF_WORD_SIZE == 32 1159ca987d46SWarner Losh COPYOUT(v, &md32, sizeof(md32)); 1160ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md32, sizeof(md32)); 1161ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1162ca987d46SWarner Losh md32.md_cval += ef->off; 1163ca987d46SWarner Losh md32.md_data += ef->off; 1164ca987d46SWarner Losh } else if (error != 0) 1165ca987d46SWarner Losh return (error); 1166ca987d46SWarner Losh md.md_version = md32.md_version; 1167ca987d46SWarner Losh md.md_type = md32.md_type; 1168ca987d46SWarner Losh md.md_cval = (const char *)(uintptr_t)md32.md_cval; 1169ca987d46SWarner Losh md.md_data = (void *)(uintptr_t)md32.md_data; 1170ca987d46SWarner Losh #else 1171ca987d46SWarner Losh COPYOUT(v, &md, sizeof(md)); 1172ca987d46SWarner Losh error = __elfN(reloc_ptr)(fp, ef, v, &md, sizeof(md)); 1173ca987d46SWarner Losh if (error == EOPNOTSUPP) { 1174ca987d46SWarner Losh md.md_cval += ef->off; 11756b632498SEd Maste md.md_data = (void *)((uintptr_t)md.md_data + 11766b632498SEd Maste (uintptr_t)ef->off); 1177ca987d46SWarner Losh } else if (error != 0) 1178ca987d46SWarner Losh return (error); 1179ca987d46SWarner Losh #endif 1180ca987d46SWarner Losh p += sizeof(Elf_Addr); 1181ca987d46SWarner Losh switch(md.md_type) { 1182ca987d46SWarner Losh case MDT_DEPEND: 1183ca987d46SWarner Losh if (ef->kernel) /* kernel must not depend on anything */ 1184ca987d46SWarner Losh break; 1185ca987d46SWarner Losh s = strdupout((vm_offset_t)md.md_cval); 1186ca987d46SWarner Losh minfolen = sizeof(*mdepend) + strlen(s) + 1; 1187ca987d46SWarner Losh mdepend = malloc(minfolen); 1188ca987d46SWarner Losh if (mdepend == NULL) 1189ca987d46SWarner Losh return ENOMEM; 11906b632498SEd Maste COPYOUT((vm_offset_t)md.md_data, mdepend, 11916b632498SEd Maste sizeof(*mdepend)); 1192ca987d46SWarner Losh strcpy((char*)(mdepend + 1), s); 1193ca987d46SWarner Losh free(s); 11946b632498SEd Maste file_addmetadata(fp, MODINFOMD_DEPLIST, minfolen, 11956b632498SEd Maste mdepend); 1196ca987d46SWarner Losh free(mdepend); 1197ca987d46SWarner Losh break; 1198ca987d46SWarner Losh case MDT_VERSION: 1199ca987d46SWarner Losh s = strdupout((vm_offset_t)md.md_cval); 1200ca987d46SWarner Losh COPYOUT((vm_offset_t)md.md_data, &mver, sizeof(mver)); 1201ca987d46SWarner Losh file_addmodule(fp, s, mver.mv_version, NULL); 1202ca987d46SWarner Losh free(s); 1203ca987d46SWarner Losh modcnt++; 1204ca987d46SWarner Losh break; 1205ca987d46SWarner Losh } 1206ca987d46SWarner Losh } 1207ca987d46SWarner Losh if (modcnt == 0) { 1208ca987d46SWarner Losh s = fake_modname(fp->f_name); 1209ca987d46SWarner Losh file_addmodule(fp, s, 1, NULL); 1210ca987d46SWarner Losh free(s); 1211ca987d46SWarner Losh } 1212ca987d46SWarner Losh return 0; 1213ca987d46SWarner Losh } 1214ca987d46SWarner Losh 1215ca987d46SWarner Losh static unsigned long 1216ca987d46SWarner Losh elf_hash(const char *name) 1217ca987d46SWarner Losh { 1218ca987d46SWarner Losh const unsigned char *p = (const unsigned char *) name; 1219ca987d46SWarner Losh unsigned long h = 0; 1220ca987d46SWarner Losh unsigned long g; 1221ca987d46SWarner Losh 1222ca987d46SWarner Losh while (*p != '\0') { 1223ca987d46SWarner Losh h = (h << 4) + *p++; 1224ca987d46SWarner Losh if ((g = h & 0xf0000000) != 0) 1225ca987d46SWarner Losh h ^= g >> 24; 1226ca987d46SWarner Losh h &= ~g; 1227ca987d46SWarner Losh } 1228ca987d46SWarner Losh return h; 1229ca987d46SWarner Losh } 1230ca987d46SWarner Losh 12316b632498SEd Maste static const char __elfN(bad_symtable)[] = "elf" __XSTRING(__ELF_WORD_SIZE) 12326b632498SEd Maste "_lookup_symbol: corrupt symbol table\n"; 1233ca987d46SWarner Losh int 12346c7a932dSToomas Soome __elfN(lookup_symbol)(elf_file_t ef, const char* name, Elf_Sym *symp, 12356c7a932dSToomas Soome unsigned char type) 1236ca987d46SWarner Losh { 1237ca987d46SWarner Losh Elf_Hashelt symnum; 1238ca987d46SWarner Losh Elf_Sym sym; 1239ca987d46SWarner Losh char *strp; 1240ca987d46SWarner Losh unsigned long hash; 1241ca987d46SWarner Losh 12425e4279a8SRoger Pau Monné if (ef->nbuckets == 0) { 12435e4279a8SRoger Pau Monné printf(__elfN(bad_symtable)); 12445e4279a8SRoger Pau Monné return ENOENT; 12455e4279a8SRoger Pau Monné } 12465e4279a8SRoger Pau Monné 1247ca987d46SWarner Losh hash = elf_hash(name); 1248ca987d46SWarner Losh COPYOUT(&ef->buckets[hash % ef->nbuckets], &symnum, sizeof(symnum)); 1249ca987d46SWarner Losh 1250ca987d46SWarner Losh while (symnum != STN_UNDEF) { 1251ca987d46SWarner Losh if (symnum >= ef->nchains) { 1252ca987d46SWarner Losh printf(__elfN(bad_symtable)); 1253ca987d46SWarner Losh return ENOENT; 1254ca987d46SWarner Losh } 1255ca987d46SWarner Losh 1256ca987d46SWarner Losh COPYOUT(ef->symtab + symnum, &sym, sizeof(sym)); 1257ca987d46SWarner Losh if (sym.st_name == 0) { 1258ca987d46SWarner Losh printf(__elfN(bad_symtable)); 1259ca987d46SWarner Losh return ENOENT; 1260ca987d46SWarner Losh } 1261ca987d46SWarner Losh 1262ca987d46SWarner Losh strp = strdupout((vm_offset_t)(ef->strtab + sym.st_name)); 1263ca987d46SWarner Losh if (strcmp(name, strp) == 0) { 1264ca987d46SWarner Losh free(strp); 12650701dbdaSKyle Evans if (sym.st_shndx != SHN_UNDEF && sym.st_value != 0 && 12660701dbdaSKyle Evans ELF_ST_TYPE(sym.st_info) == type) { 1267ca987d46SWarner Losh *symp = sym; 1268ca987d46SWarner Losh return 0; 1269ca987d46SWarner Losh } 1270ca987d46SWarner Losh return ENOENT; 1271ca987d46SWarner Losh } 1272ca987d46SWarner Losh free(strp); 1273ca987d46SWarner Losh COPYOUT(&ef->chains[symnum], &symnum, sizeof(symnum)); 1274ca987d46SWarner Losh } 1275ca987d46SWarner Losh return ENOENT; 1276ca987d46SWarner Losh } 1277ca987d46SWarner Losh 1278ca987d46SWarner Losh /* 1279ca987d46SWarner Losh * Apply any intra-module relocations to the value. p is the load address 1280ca987d46SWarner Losh * of the value and val/len is the value to be modified. This does NOT modify 1281ca987d46SWarner Losh * the image in-place, because this is done by kern_linker later on. 1282ca987d46SWarner Losh * 1283ca987d46SWarner Losh * Returns EOPNOTSUPP if no relocation method is supplied. 1284ca987d46SWarner Losh */ 1285ca987d46SWarner Losh static int 1286ca987d46SWarner Losh __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef, 1287ca987d46SWarner Losh Elf_Addr p, void *val, size_t len) 1288ca987d46SWarner Losh { 1289ca987d46SWarner Losh size_t n; 1290ca987d46SWarner Losh Elf_Rela a; 1291ca987d46SWarner Losh Elf_Rel r; 1292ca987d46SWarner Losh int error; 1293ca987d46SWarner Losh 1294ca987d46SWarner Losh /* 1295ca987d46SWarner Losh * The kernel is already relocated, but we still want to apply 1296ca987d46SWarner Losh * offset adjustments. 1297ca987d46SWarner Losh */ 1298ca987d46SWarner Losh if (ef->kernel) 1299ca987d46SWarner Losh return (EOPNOTSUPP); 1300ca987d46SWarner Losh 1301ca987d46SWarner Losh for (n = 0; n < ef->relsz / sizeof(r); n++) { 1302ca987d46SWarner Losh COPYOUT(ef->rel + n, &r, sizeof(r)); 1303ca987d46SWarner Losh 1304ca987d46SWarner Losh error = __elfN(reloc)(ef, __elfN(symaddr), &r, ELF_RELOC_REL, 1305ca987d46SWarner Losh ef->off, p, val, len); 1306ca987d46SWarner Losh if (error != 0) 1307ca987d46SWarner Losh return (error); 1308ca987d46SWarner Losh } 1309ca987d46SWarner Losh for (n = 0; n < ef->relasz / sizeof(a); n++) { 1310ca987d46SWarner Losh COPYOUT(ef->rela + n, &a, sizeof(a)); 1311ca987d46SWarner Losh 1312ca987d46SWarner Losh error = __elfN(reloc)(ef, __elfN(symaddr), &a, ELF_RELOC_RELA, 1313ca987d46SWarner Losh ef->off, p, val, len); 1314ca987d46SWarner Losh if (error != 0) 1315ca987d46SWarner Losh return (error); 1316ca987d46SWarner Losh } 1317ca987d46SWarner Losh 1318ca987d46SWarner Losh return (0); 1319ca987d46SWarner Losh } 1320ca987d46SWarner Losh 1321ca987d46SWarner Losh static Elf_Addr 1322ca987d46SWarner Losh __elfN(symaddr)(struct elf_file *ef, Elf_Size symidx) 1323ca987d46SWarner Losh { 1324ca987d46SWarner Losh 1325ca987d46SWarner Losh /* Symbol lookup by index not required here. */ 1326ca987d46SWarner Losh return (0); 1327ca987d46SWarner Losh } 1328