1 #define _SYSTEM 1 2 3 #include <minix/type.h> 4 #include <minix/const.h> 5 #include <minix/com.h> 6 #include <minix/syslib.h> 7 #include <sys/param.h> 8 #include <sys/mman.h> 9 #include <assert.h> 10 #include <unistd.h> 11 #include <errno.h> 12 #include <libexec.h> 13 #include <string.h> 14 #include <machine/elf.h> 15 #include <machine/vmparam.h> 16 #include <machine/memory.h> 17 #include <minix/syslib.h> 18 19 /* For verbose logging */ 20 #define ELF_DEBUG 0 21 22 /* Support only 32-bit ELF objects */ 23 #define __ELF_WORD_SIZE 32 24 25 #define SECTOR_SIZE 512 26 27 static int check_header(Elf_Ehdr *hdr); 28 29 static int elf_sane(Elf_Ehdr *hdr) 30 { 31 if (check_header(hdr) != OK) { 32 return 0; 33 } 34 35 if((hdr->e_type != ET_EXEC) && (hdr->e_type != ET_DYN)) { 36 return 0; 37 } 38 39 if ((hdr->e_phoff > SECTOR_SIZE) || 40 (hdr->e_phoff + hdr->e_phentsize * hdr->e_phnum) > SECTOR_SIZE) { 41 #if ELF_DEBUG 42 printf("peculiar phoff\n"); 43 #endif 44 return 0; 45 } 46 47 return 1; 48 } 49 50 static int elf_ph_sane(Elf_Phdr *phdr) 51 { 52 if (rounddown((uintptr_t)phdr, sizeof(Elf_Addr)) != (uintptr_t)phdr) { 53 return 0; 54 } 55 return 1; 56 } 57 58 static int elf_unpack(char *exec_hdr, 59 size_t hdr_len, Elf_Ehdr **hdr, Elf_Phdr **phdr) 60 { 61 if(hdr_len < sizeof(Elf_Ehdr)) 62 return ENOEXEC; 63 64 *hdr = (Elf_Ehdr *) exec_hdr; 65 if(!elf_sane(*hdr)) { 66 return ENOEXEC; 67 } 68 *phdr = (Elf_Phdr *)(exec_hdr + (*hdr)->e_phoff); 69 if(!elf_ph_sane(*phdr)) { 70 return ENOEXEC; 71 } 72 #if 0 73 if((int)((*phdr) + (*hdr)->e_phnum) >= hdr_len) return ENOEXEC; 74 #endif 75 return OK; 76 } 77 78 #define IS_ELF(ehdr) ((ehdr).e_ident[EI_MAG0] == ELFMAG0 && \ 79 (ehdr).e_ident[EI_MAG1] == ELFMAG1 && \ 80 (ehdr).e_ident[EI_MAG2] == ELFMAG2 && \ 81 (ehdr).e_ident[EI_MAG3] == ELFMAG3) 82 83 static int check_header(Elf_Ehdr *hdr) 84 { 85 if (!IS_ELF(*hdr) || 86 hdr->e_ident[EI_DATA] != ELF_TARG_DATA || 87 hdr->e_ident[EI_VERSION] != EV_CURRENT || 88 hdr->e_phentsize != sizeof(Elf_Phdr) || 89 hdr->e_version != ELF_TARG_VER) 90 return ENOEXEC; 91 92 return OK; 93 } 94 95 /* Return >0 if there is an ELF interpreter (i.e. it is a dynamically linked 96 * executable) and we could extract it successfully. 97 * Return 0 if there isn't one. 98 * Return <0 on error. 99 */ 100 int elf_has_interpreter(char *exec_hdr, /* executable header */ 101 size_t hdr_len, char *interp, size_t maxsz) 102 { 103 Elf_Ehdr *hdr = NULL; 104 Elf_Phdr *phdr = NULL; 105 int e, i; 106 107 if((e=elf_unpack(exec_hdr, hdr_len, &hdr, &phdr)) != OK) return 0; 108 109 for (i = 0; i < hdr->e_phnum; i++) { 110 switch (phdr[i].p_type) { 111 case PT_INTERP: 112 if(!interp) return 1; 113 if(phdr[i].p_filesz >= maxsz) 114 return -1; 115 if(phdr[i].p_offset + phdr[i].p_filesz >= hdr_len) 116 return -1; 117 memcpy(interp, exec_hdr + phdr[i].p_offset, phdr[i].p_filesz); 118 interp[phdr[i].p_filesz] = '\0'; 119 return 1; 120 default: 121 continue; 122 } 123 } 124 return 0; 125 } 126 127 int libexec_load_elf(struct exec_info *execi) 128 { 129 Elf_Ehdr *hdr = NULL; 130 Elf_Phdr *phdr = NULL; 131 int e, i = 0; 132 int first = 1; 133 vir_bytes startv = 0, stacklow; 134 135 assert(execi != NULL); 136 assert(execi->hdr != NULL); 137 138 if((e=elf_unpack(execi->hdr, execi->hdr_len, &hdr, &phdr)) != OK) { 139 return e; 140 } 141 142 /* this function can load the dynamic linker, but that 143 * shouldn't require an interpreter itself. 144 */ 145 i = elf_has_interpreter(execi->hdr, execi->hdr_len, NULL, 0); 146 if(i > 0) { 147 return ENOEXEC; 148 } 149 150 execi->stack_size = roundup(execi->stack_size, PAGE_SIZE); 151 execi->stack_high = rounddown(execi->stack_high, PAGE_SIZE); 152 stacklow = execi->stack_high - execi->stack_size; 153 154 assert(execi->copymem); 155 assert(execi->clearmem); 156 assert(execi->allocmem_prealloc_cleared); 157 assert(execi->allocmem_prealloc_junk); 158 assert(execi->allocmem_ondemand); 159 160 for (i = 0; i < hdr->e_phnum; i++) { 161 Elf_Phdr *ph = &phdr[i]; 162 off_t file_limit = ph->p_offset + ph->p_filesz; 163 /* sanity check binary before wiping out the target process */ 164 if(execi->filesize < file_limit) { 165 return ENOEXEC; 166 } 167 } 168 169 if(execi->clearproc) execi->clearproc(execi); 170 171 for (i = 0; i < hdr->e_phnum; i++) { 172 vir_bytes seg_membytes, page_offset, p_vaddr, vaddr; 173 vir_bytes chunk, vfileend, vmemend; 174 off_t foffset, fbytes; 175 Elf_Phdr *ph = &phdr[i]; 176 int try_mmap = 1; 177 u16_t clearend = 0; 178 int pagechunk; 179 int mmap_prot = PROT_READ; 180 181 if(!(ph->p_flags & PF_R)) { 182 printf("libexec: warning: unreadable segment\n"); 183 } 184 185 if(ph->p_flags & PF_W) { 186 mmap_prot |= PROT_WRITE; 187 #if ELF_DEBUG 188 printf("libexec: adding PROT_WRITE\n"); 189 #endif 190 } else { 191 #if ELF_DEBUG 192 printf("libexec: not adding PROT_WRITE\n"); 193 #endif 194 } 195 196 if (ph->p_type != PT_LOAD || ph->p_memsz == 0) continue; 197 198 if((ph->p_vaddr % PAGE_SIZE) != (ph->p_offset % PAGE_SIZE)) { 199 printf("libexec: unaligned ELF program?\n"); 200 try_mmap = 0; 201 } 202 203 if(!execi->memmap) { 204 try_mmap = 0; 205 } 206 207 foffset = ph->p_offset; 208 fbytes = ph->p_filesz; 209 vaddr = p_vaddr = ph->p_vaddr + execi->load_offset; 210 seg_membytes = ph->p_memsz; 211 212 page_offset = vaddr % PAGE_SIZE; 213 vaddr -= page_offset; 214 foffset -= page_offset; 215 seg_membytes += page_offset; 216 fbytes += page_offset; 217 vfileend = p_vaddr + ph->p_filesz; 218 219 /* if there's usable memory after the file end, we have 220 * to tell VM to clear the memory part of the page when it's 221 * mapped in 222 */ 223 if((pagechunk = (vfileend % PAGE_SIZE)) 224 && ph->p_filesz < ph->p_memsz) { 225 clearend = PAGE_SIZE - pagechunk; 226 } 227 228 seg_membytes = roundup(seg_membytes, PAGE_SIZE); 229 fbytes = roundup(fbytes, PAGE_SIZE); 230 231 if(first || startv > vaddr) startv = vaddr; 232 first = 0; 233 234 if ((ph->p_flags & PF_X) != 0 && execi->text_size < seg_membytes) 235 execi->text_size = seg_membytes; 236 else 237 execi->data_size = seg_membytes; 238 239 if(try_mmap && execi->memmap(execi, vaddr, fbytes, foffset, clearend, mmap_prot) == OK) { 240 #if ELF_DEBUG 241 printf("libexec: mmap 0x%lx-0x%lx done, clearend 0x%x\n", 242 vaddr, vaddr+fbytes, clearend); 243 #endif 244 245 if(seg_membytes > fbytes) { 246 int rem_mem = seg_membytes - fbytes;; 247 vir_bytes remstart = vaddr + fbytes; 248 if(execi->allocmem_ondemand(execi, 249 remstart, rem_mem) != OK) { 250 printf("libexec: mmap extra mem failed\n"); 251 return ENOMEM; 252 } 253 #if ELF_DEBUG 254 else printf("libexec: allocated 0x%lx-0x%lx\n", 255 256 remstart, remstart+rem_mem); 257 #endif 258 } 259 } else { 260 /* make us some memory */ 261 if(execi->allocmem_prealloc_junk(execi, vaddr, seg_membytes) != OK) { 262 if(execi->clearproc) execi->clearproc(execi); 263 return ENOMEM; 264 } 265 266 #if ELF_DEBUG 267 printf("mmapped 0x%lx-0x%lx\n", vaddr, vaddr+seg_membytes); 268 #endif 269 270 /* Copy executable section into it */ 271 if(execi->copymem(execi, ph->p_offset, p_vaddr, ph->p_filesz) != OK) { 272 if(execi->clearproc) execi->clearproc(execi); 273 return ENOMEM; 274 } 275 276 #if ELF_DEBUG 277 printf("copied 0x%lx-0x%lx\n", p_vaddr, p_vaddr+ph->p_filesz); 278 #endif 279 280 /* Clear remaining bits */ 281 vmemend = vaddr + seg_membytes; 282 if((chunk = p_vaddr - vaddr) > 0) { 283 #if ELF_DEBUG 284 printf("start clearing 0x%lx-0x%lx\n", vaddr, vaddr+chunk); 285 #endif 286 execi->clearmem(execi, vaddr, chunk); 287 } 288 289 if((chunk = vmemend - vfileend) > 0) { 290 #if ELF_DEBUG 291 printf("end clearing 0x%lx-0x%lx\n", vfileend, vfileend+chunk); 292 #endif 293 execi->clearmem(execi, vfileend, chunk); 294 } 295 } 296 } 297 298 /* Make it a stack */ 299 if(execi->allocmem_ondemand(execi, stacklow, execi->stack_size) != OK) { 300 if(execi->clearproc) execi->clearproc(execi); 301 return ENOMEM; 302 } 303 304 #if ELF_DEBUG 305 printf("stack mmapped 0x%lx-0x%lx\n", stacklow, stacklow+execi->stack_size); 306 #endif 307 308 /* record entry point and lowest load vaddr for caller */ 309 execi->pc = hdr->e_entry + execi->load_offset; 310 execi->load_base = startv; 311 312 return OK; 313 } 314 315