AMD64 - Refactor uio_resid and size_t assumptions.
[dragonfly.git] / sys / boot / common / load_elf.c
CommitLineData
984263bc
MD
1/*-
2 * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3 * Copyright (c) 1998 Peter Wemm <peter@freebsd.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
5ee58eed 27 * $FreeBSD: src/sys/boot/common/load_elf.c,v 1.29 2003/08/25 23:30:41 obrien Exp $
79dc5fc6 28 * $DragonFly: src/sys/boot/common/load_elf.c,v 1.7 2008/09/02 17:21:12 dillon Exp $
984263bc
MD
29 */
30
31#include <sys/param.h>
32#include <sys/exec.h>
984263bc 33#include <sys/linker.h>
5ee58eed 34#include <sys/module.h>
984263bc 35#include <string.h>
984263bc
MD
36#include <machine/elf.h>
37#include <stand.h>
38#define FREEBSD_ELF
39#include <link.h>
40
41#include "bootstrap.h"
42
5ee58eed 43#define COPYOUT(s,d,l) archsw.arch_copyout((vm_offset_t)(s), d, l)
984263bc 44
5ee58eed
MD
45#if defined(__i386__) && __ELF_WORD_SIZE == 64
46#undef ELF_TARG_CLASS
47#undef ELF_TARG_MACH
48#define ELF_TARG_CLASS ELFCLASS64
49#define ELF_TARG_MACH EM_X86_64
50#endif
51
52typedef struct elf_file {
53 Elf_Phdr *ph;
54 Elf_Ehdr *ehdr;
55 Elf_Sym *symtab;
56 Elf_Hashelt *hashtab;
57 Elf_Hashelt nbuckets;
58 Elf_Hashelt nchains;
59 Elf_Hashelt *buckets;
60 Elf_Hashelt *chains;
61 Elf_Rela *rela;
62 size_t relasz;
63 char *strtab;
64 size_t strsz;
65 int fd;
66 caddr_t firstpage;
67 size_t firstlen;
68 int kernel;
69 u_int64_t off;
70} *elf_file_t;
71
72static int __elfN(loadimage)(struct preloaded_file *mp, elf_file_t ef, u_int64_t loadaddr);
73static int __elfN(lookup_symbol)(struct preloaded_file *mp, elf_file_t ef, const char* name, Elf_Sym* sym);
74#ifdef __sparc__
75static void __elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef,
76 void *p, void *val, size_t len);
77#endif
78static int __elfN(parse_modmetadata)(struct preloaded_file *mp, elf_file_t ef);
79static char *fake_modname(const char *name);
80
81const char *__elfN(kerneltype) = "elf kernel";
82const char *__elfN(moduletype) = "elf module";
984263bc
MD
83
84/*
85 * Attempt to load the file (file) as an ELF module. It will be stored at
86 * (dest), and a pointer to a module structure describing the loaded object
87 * will be saved in (result).
88 */
89int
5ee58eed 90__elfN(loadfile)(char *filename, u_int64_t dest, struct preloaded_file **result)
984263bc 91{
5ee58eed
MD
92 struct preloaded_file *fp, *kfp;
93 struct elf_file ef;
94 Elf_Ehdr *ehdr;
95 int err;
984263bc 96 u_int pad;
5ee58eed 97 ssize_t bytes_read;
984263bc 98
5ee58eed
MD
99 fp = NULL;
100 bzero(&ef, sizeof(struct elf_file));
984263bc
MD
101
102 /*
103 * Open the image, read and validate the ELF header
104 */
105 if (filename == NULL) /* can't handle nameless */
106 return(EFTYPE);
79dc5fc6 107 if ((ef.fd = rel_open(filename, O_RDONLY)) == -1)
984263bc 108 return(errno);
5ee58eed
MD
109 ef.firstpage = malloc(PAGE_SIZE);
110 if (ef.firstpage == NULL) {
111 close(ef.fd);
984263bc 112 return(ENOMEM);
5ee58eed
MD
113 }
114 bytes_read = read(ef.fd, ef.firstpage, PAGE_SIZE);
115 ef.firstlen = (size_t)bytes_read;
116 if (bytes_read < 0 || ef.firstlen <= sizeof(Elf_Ehdr)) {
984263bc
MD
117 err = EFTYPE; /* could be EIO, but may be small file */
118 goto oerr;
119 }
5ee58eed 120 ehdr = ef.ehdr = (Elf_Ehdr *)ef.firstpage;
984263bc
MD
121
122 /* Is it ELF? */
123 if (!IS_ELF(*ehdr)) {
124 err = EFTYPE;
125 goto oerr;
126 }
127 if (ehdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || /* Layout ? */
128 ehdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
129 ehdr->e_ident[EI_VERSION] != EV_CURRENT || /* Version ? */
130 ehdr->e_version != EV_CURRENT ||
131 ehdr->e_machine != ELF_TARG_MACH) { /* Machine ? */
132 err = EFTYPE;
133 goto oerr;
134 }
135
136
137 /*
138 * Check to see what sort of module we are.
139 */
5ee58eed 140 kfp = file_findfile(NULL, NULL);
984263bc
MD
141 if (ehdr->e_type == ET_DYN) {
142 /* Looks like a kld module */
5ee58eed
MD
143 if (kfp == NULL) {
144 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: can't load module before kernel\n");
984263bc
MD
145 err = EPERM;
146 goto oerr;
147 }
5ee58eed
MD
148 if (strcmp(__elfN(kerneltype), kfp->f_type)) {
149 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: can't load module with kernel type '%s'\n", kfp->f_type);
984263bc
MD
150 err = EPERM;
151 goto oerr;
152 }
153 /* Looks OK, got ahead */
5ee58eed 154 ef.kernel = 0;
984263bc
MD
155
156 /* Page-align the load address */
157 pad = (u_int)dest & PAGE_MASK;
158 if (pad != 0) {
159 pad = PAGE_SIZE - pad;
160 dest += pad;
161 }
162 } else if (ehdr->e_type == ET_EXEC) {
163 /* Looks like a kernel */
5ee58eed
MD
164 if (kfp != NULL) {
165 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: kernel already loaded\n");
984263bc
MD
166 err = EPERM;
167 goto oerr;
168 }
169 /*
170 * Calculate destination address based on kernel entrypoint
171 */
5ee58eed 172 dest = ehdr->e_entry;
984263bc 173 if (dest == 0) {
5ee58eed 174 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: not a kernel (maybe static binary?)\n");
984263bc
MD
175 err = EPERM;
176 goto oerr;
177 }
5ee58eed 178 ef.kernel = 1;
984263bc
MD
179
180 } else {
181 err = EFTYPE;
182 goto oerr;
183 }
184
185 /*
186 * Ok, we think we should handle this.
187 */
5ee58eed
MD
188 fp = file_alloc();
189 if (fp == NULL) {
190 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadfile: cannot allocate module info\n");
984263bc
MD
191 err = EPERM;
192 goto out;
193 }
5ee58eed 194 if (ef.kernel)
984263bc 195 setenv("kernelname", filename, 1);
5ee58eed
MD
196 fp->f_name = strdup(filename);
197 fp->f_type = strdup(ef.kernel ? __elfN(kerneltype) : __elfN(moduletype));
984263bc
MD
198
199#ifdef ELF_VERBOSE
5ee58eed
MD
200 if (ef.kernel)
201 printf("%s entry at 0x%jx\n", filename, (uintmax_t)dest);
984263bc
MD
202#else
203 printf("%s ", filename);
204#endif
205
5ee58eed
MD
206 fp->f_size = __elfN(loadimage)(fp, &ef, dest);
207 if (fp->f_size == 0 || fp->f_addr == 0)
984263bc
MD
208 goto ioerr;
209
210 /* save exec header as metadata */
5ee58eed 211 file_addmetadata(fp, MODINFOMD_ELFHDR, sizeof(*ehdr), ehdr);
984263bc
MD
212
213 /* Load OK, return module pointer */
5ee58eed 214 *result = (struct preloaded_file *)fp;
984263bc
MD
215 err = 0;
216 goto out;
217
218 ioerr:
219 err = EIO;
220 oerr:
5ee58eed 221 file_discard(fp);
984263bc 222 out:
5ee58eed
MD
223 if (ef.firstpage)
224 free(ef.firstpage);
225 close(ef.fd);
984263bc
MD
226 return(err);
227}
228
229/*
230 * With the file (fd) open on the image, and (ehdr) containing
231 * the Elf header, load the image at (off)
232 */
233static int
5ee58eed 234__elfN(loadimage)(struct preloaded_file *fp, elf_file_t ef, u_int64_t off)
984263bc 235{
5ee58eed
MD
236 int i;
237 u_int j;
238 Elf_Ehdr *ehdr;
239 Elf_Phdr *phdr, *php;
984263bc
MD
240 Elf_Shdr *shdr;
241 int ret;
242 vm_offset_t firstaddr;
243 vm_offset_t lastaddr;
244 void *buf;
245 size_t resid, chunk;
246 ssize_t result;
247 vm_offset_t dest;
5ee58eed 248 Elf_Addr ssym, esym;
984263bc 249 Elf_Dyn *dp;
5ee58eed 250 Elf_Addr adp;
984263bc 251 int ndp;
984263bc
MD
252 int symstrindex;
253 int symtabindex;
5ee58eed 254 Elf_Size size;
984263bc
MD
255 u_int fpcopy;
256
257 dp = NULL;
258 shdr = NULL;
259 ret = 0;
260 firstaddr = lastaddr = 0;
5ee58eed
MD
261 ehdr = ef->ehdr;
262 if (ef->kernel) {
984263bc 263#ifdef __i386__
5ee58eed
MD
264#if __ELF_WORD_SIZE == 64
265 off = - (off & 0xffffffffff000000ull);/* x86_64 relocates after locore */
266#else
984263bc 267 off = - (off & 0xff000000u); /* i386 relocates after locore */
5ee58eed 268#endif
984263bc
MD
269#endif
270 }
5ee58eed 271 ef->off = off;
984263bc 272
5ee58eed
MD
273 if ((ehdr->e_phoff + ehdr->e_phnum * sizeof(*phdr)) > ef->firstlen) {
274 printf("elf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: program header not within first page\n");
984263bc
MD
275 goto out;
276 }
5ee58eed 277 phdr = (Elf_Phdr *)(ef->firstpage + ehdr->e_phoff);
984263bc
MD
278
279 for (i = 0; i < ehdr->e_phnum; i++) {
280 /* We want to load PT_LOAD segments only.. */
281 if (phdr[i].p_type != PT_LOAD)
282 continue;
283
284#ifdef ELF_VERBOSE
285 printf("Segment: 0x%lx@0x%lx -> 0x%lx-0x%lx",
286 (long)phdr[i].p_filesz, (long)phdr[i].p_offset,
287 (long)(phdr[i].p_vaddr + off),
288 (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1));
289#else
290 if ((phdr[i].p_flags & PF_W) == 0) {
291 printf("text=0x%lx ", (long)phdr[i].p_filesz);
292 } else {
293 printf("data=0x%lx", (long)phdr[i].p_filesz);
294 if (phdr[i].p_filesz < phdr[i].p_memsz)
295 printf("+0x%lx", (long)(phdr[i].p_memsz -phdr[i].p_filesz));
296 printf(" ");
297 }
298#endif
299 fpcopy = 0;
5ee58eed
MD
300 if (ef->firstlen > phdr[i].p_offset) {
301 fpcopy = ef->firstlen - phdr[i].p_offset;
302 archsw.arch_copyin(ef->firstpage + phdr[i].p_offset,
984263bc
MD
303 phdr[i].p_vaddr + off, fpcopy);
304 }
305 if (phdr[i].p_filesz > fpcopy) {
5ee58eed
MD
306 if (lseek(ef->fd, (off_t)(phdr[i].p_offset + fpcopy),
307 SEEK_SET) == -1) {
308 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadexec: cannot seek\n");
984263bc
MD
309 goto out;
310 }
5ee58eed
MD
311 if (archsw.arch_readin(ef->fd, phdr[i].p_vaddr + off + fpcopy,
312 phdr[i].p_filesz - fpcopy) != (ssize_t)(phdr[i].p_filesz - fpcopy)) {
313 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadexec: archsw.readin failed\n");
984263bc
MD
314 goto out;
315 }
316 }
317 /* clear space from oversized segments; eg: bss */
318 if (phdr[i].p_filesz < phdr[i].p_memsz) {
319#ifdef ELF_VERBOSE
320 printf(" (bss: 0x%lx-0x%lx)",
321 (long)(phdr[i].p_vaddr + off + phdr[i].p_filesz),
322 (long)(phdr[i].p_vaddr + off + phdr[i].p_memsz - 1));
323#endif
324
325 /* no archsw.arch_bzero */
326 buf = malloc(PAGE_SIZE);
5ee58eed
MD
327 if (buf == NULL) {
328 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: malloc() failed\n");
329 goto out;
330 }
984263bc
MD
331 bzero(buf, PAGE_SIZE);
332 resid = phdr[i].p_memsz - phdr[i].p_filesz;
333 dest = phdr[i].p_vaddr + off + phdr[i].p_filesz;
334 while (resid > 0) {
e54488bb 335 chunk = szmin(PAGE_SIZE, resid);
984263bc
MD
336 archsw.arch_copyin(buf, dest, chunk);
337 resid -= chunk;
338 dest += chunk;
339 }
340 free(buf);
341 }
342#ifdef ELF_VERBOSE
343 printf("\n");
344#endif
345
346 if (firstaddr == 0 || firstaddr > (phdr[i].p_vaddr + off))
347 firstaddr = phdr[i].p_vaddr + off;
348 if (lastaddr == 0 || lastaddr < (phdr[i].p_vaddr + off + phdr[i].p_memsz))
349 lastaddr = phdr[i].p_vaddr + off + phdr[i].p_memsz;
350 }
351 lastaddr = roundup(lastaddr, sizeof(long));
352
353 /*
354 * Now grab the symbol tables. This isn't easy if we're reading a
355 * .gz file. I think the rule is going to have to be that you must
356 * strip a file to remove symbols before gzipping it so that we do not
357 * try to lseek() on it.
358 */
359 chunk = ehdr->e_shnum * ehdr->e_shentsize;
360 if (chunk == 0 || ehdr->e_shoff == 0)
361 goto nosyms;
362 shdr = malloc(chunk);
363 if (shdr == NULL)
364 goto nosyms;
5ee58eed
MD
365 if (lseek(ef->fd, (off_t)ehdr->e_shoff, SEEK_SET) == -1) {
366 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: cannot lseek() to section headers");
984263bc
MD
367 goto nosyms;
368 }
5ee58eed
MD
369 result = read(ef->fd, shdr, chunk);
370 if (result < 0 || (size_t)result != chunk) {
371 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: read section headers failed");
984263bc
MD
372 goto nosyms;
373 }
374 symtabindex = -1;
375 symstrindex = -1;
376 for (i = 0; i < ehdr->e_shnum; i++) {
377 if (shdr[i].sh_type != SHT_SYMTAB)
378 continue;
379 for (j = 0; j < ehdr->e_phnum; j++) {
380 if (phdr[j].p_type != PT_LOAD)
381 continue;
382 if (shdr[i].sh_offset >= phdr[j].p_offset &&
383 (shdr[i].sh_offset + shdr[i].sh_size <=
384 phdr[j].p_offset + phdr[j].p_filesz)) {
385 shdr[i].sh_offset = 0;
386 shdr[i].sh_size = 0;
387 break;
388 }
389 }
390 if (shdr[i].sh_offset == 0 || shdr[i].sh_size == 0)
391 continue; /* alread loaded in a PT_LOAD above */
392 /* Save it for loading below */
393 symtabindex = i;
394 symstrindex = shdr[i].sh_link;
395 }
396 if (symtabindex < 0 || symstrindex < 0)
397 goto nosyms;
398
399 /* Ok, committed to a load. */
400#ifndef ELF_VERBOSE
401 printf("syms=[");
402#endif
403 ssym = lastaddr;
404 for (i = symtabindex; i >= 0; i = symstrindex) {
405#ifdef ELF_VERBOSE
406 char *secname;
407
408 switch(shdr[i].sh_type) {
409 case SHT_SYMTAB: /* Symbol table */
410 secname = "symtab";
411 break;
412 case SHT_STRTAB: /* String table */
413 secname = "strtab";
414 break;
415 default:
416 secname = "WHOA!!";
417 break;
418 }
419#endif
420
421 size = shdr[i].sh_size;
422 archsw.arch_copyin(&size, lastaddr, sizeof(size));
5ee58eed 423 lastaddr += sizeof(size);
984263bc
MD
424
425#ifdef ELF_VERBOSE
426 printf("\n%s: 0x%lx@0x%lx -> 0x%lx-0x%lx", secname,
427 shdr[i].sh_size, shdr[i].sh_offset,
428 lastaddr, lastaddr + shdr[i].sh_size);
429#else
430 if (i == symstrindex)
431 printf("+");
5ee58eed 432 printf("0x%lx+0x%lx", (long)sizeof(size), (long)size);
984263bc
MD
433#endif
434
5ee58eed
MD
435 if (lseek(ef->fd, (off_t)shdr[i].sh_offset, SEEK_SET) == -1) {
436 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: could not seek for symbols - skipped!");
984263bc
MD
437 lastaddr = ssym;
438 ssym = 0;
439 goto nosyms;
440 }
5ee58eed
MD
441 result = archsw.arch_readin(ef->fd, lastaddr, shdr[i].sh_size);
442 if (result < 0 || (size_t)result != shdr[i].sh_size) {
443 printf("\nelf" __XSTRING(__ELF_WORD_SIZE) "_loadimage: could not read symbols - skipped!");
984263bc
MD
444 lastaddr = ssym;
445 ssym = 0;
446 goto nosyms;
447 }
448 /* Reset offsets relative to ssym */
449 lastaddr += shdr[i].sh_size;
5ee58eed 450 lastaddr = roundup(lastaddr, sizeof(size));
984263bc
MD
451 if (i == symtabindex)
452 symtabindex = -1;
453 else if (i == symstrindex)
454 symstrindex = -1;
455 }
456 esym = lastaddr;
457#ifndef ELF_VERBOSE
458 printf("]");
459#endif
460
5ee58eed
MD
461 file_addmetadata(fp, MODINFOMD_SSYM, sizeof(ssym), &ssym);
462 file_addmetadata(fp, MODINFOMD_ESYM, sizeof(esym), &esym);
984263bc
MD
463
464nosyms:
465 printf("\n");
466
467 ret = lastaddr - firstaddr;
5ee58eed 468 fp->f_addr = firstaddr;
984263bc 469
5ee58eed 470 php = NULL;
984263bc
MD
471 for (i = 0; i < ehdr->e_phnum; i++) {
472 if (phdr[i].p_type == PT_DYNAMIC) {
5ee58eed
MD
473 php = phdr + i;
474 adp = php->p_vaddr;
475 file_addmetadata(fp, MODINFOMD_DYNAMIC, sizeof(adp), &adp);
984263bc
MD
476 break;
477 }
478 }
479
5ee58eed 480 if (php == NULL) /* this is bad, we cannot get to symbols or _DYNAMIC */
984263bc
MD
481 goto out;
482
5ee58eed
MD
483 ndp = php->p_filesz / sizeof(Elf_Dyn);
484 if (ndp == 0)
984263bc 485 goto out;
5ee58eed
MD
486 dp = malloc(php->p_filesz);
487 if (dp == NULL)
488 goto out;
489 archsw.arch_copyout(php->p_vaddr + off, dp, php->p_filesz);
490
491 ef->strsz = 0;
984263bc 492 for (i = 0; i < ndp; i++) {
eecd52b2 493 if (dp[i].d_tag == 0)
984263bc
MD
494 break;
495 switch (dp[i].d_tag) {
5ee58eed
MD
496 case DT_HASH:
497 ef->hashtab = (Elf_Hashelt*)(uintptr_t)(dp[i].d_un.d_ptr + off);
498 break;
984263bc 499 case DT_STRTAB:
5ee58eed 500 ef->strtab = (char *)(uintptr_t)(dp[i].d_un.d_ptr + off);
984263bc
MD
501 break;
502 case DT_STRSZ:
5ee58eed
MD
503 ef->strsz = dp[i].d_un.d_val;
504 break;
505 case DT_SYMTAB:
506 ef->symtab = (Elf_Sym*)(uintptr_t)(dp[i].d_un.d_ptr + off);
507 break;
508 case DT_RELA:
509 ef->rela = (Elf_Rela *)(uintptr_t)(dp[i].d_un.d_ptr + off);
510 break;
511 case DT_RELASZ:
512 ef->relasz = dp[i].d_un.d_val;
984263bc
MD
513 break;
514 default:
515 break;
516 }
517 }
5ee58eed
MD
518 if (ef->hashtab == NULL || ef->symtab == NULL ||
519 ef->strtab == NULL || ef->strsz == 0)
520 goto out;
521 COPYOUT(ef->hashtab, &ef->nbuckets, sizeof(ef->nbuckets));
522 COPYOUT(ef->hashtab + 1, &ef->nchains, sizeof(ef->nchains));
523 ef->buckets = ef->hashtab + 2;
524 ef->chains = ef->buckets + ef->nbuckets;
525 if (__elfN(parse_modmetadata)(fp, ef) == 0)
984263bc
MD
526 goto out;
527
5ee58eed
MD
528 if (ef->kernel) /* kernel must not depend on anything */
529 goto out;
984263bc
MD
530
531out:
532 if (dp)
533 free(dp);
534 if (shdr)
535 free(shdr);
536 return ret;
537}
5ee58eed
MD
538
539static char invalid_name[] = "bad";
540
541char *
542fake_modname(const char *name)
543{
544 const char *sp, *ep;
545 char *fp;
546 size_t len;
547
548 sp = strrchr(name, '/');
549 if (sp)
550 sp++;
551 else
552 sp = name;
553 ep = strrchr(name, '.');
554 if (ep) {
555 if (ep == name) {
556 sp = invalid_name;
557 ep = invalid_name + sizeof(invalid_name) - 1;
558 }
559 } else
560 ep = name + strlen(name);
561 len = ep - sp;
562 fp = malloc(len + 1);
563 if (fp == NULL)
564 return NULL;
565 memcpy(fp, sp, len);
566 fp[len] = '\0';
567 return fp;
568}
569
570#if defined(__i386__) && __ELF_WORD_SIZE == 64
571struct mod_metadata64 {
572 int md_version; /* structure version MDTV_* */
573 int md_type; /* type of entry MDT_* */
574 u_int64_t md_data; /* specific data */
575 u_int64_t md_cval; /* common string label */
576};
577#endif
578
579int
580__elfN(parse_modmetadata)(struct preloaded_file *fp, elf_file_t ef)
581{
582 struct mod_metadata md;
583#if defined(__i386__) && __ELF_WORD_SIZE == 64
584 struct mod_metadata64 md64;
585#endif
586 struct mod_depend *mdepend;
587 struct mod_version mver;
588 Elf_Sym sym;
589 char *s;
590 int modcnt, minfolen;
591 Elf_Addr v, p, p_stop;
592
593 if (__elfN(lookup_symbol)(fp, ef, "__start_set_modmetadata_set", &sym) != 0)
594 return ENOENT;
595 p = sym.st_value + ef->off;
596 if (__elfN(lookup_symbol)(fp, ef, "__stop_set_modmetadata_set", &sym) != 0)
597 return ENOENT;
598 p_stop = sym.st_value + ef->off;
599
600 modcnt = 0;
601 while (p < p_stop) {
602 COPYOUT(p, &v, sizeof(v));
603#ifdef __sparc64__
604 __elfN(reloc_ptr)(fp, ef, p, &v, sizeof(v));
605#else
606 v += ef->off;
607#endif
608#if defined(__i386__) && __ELF_WORD_SIZE == 64
609 COPYOUT(v, &md64, sizeof(md64));
610 md.md_version = md64.md_version;
611 md.md_type = md64.md_type;
612 md.md_cval = (const char *)(uintptr_t)(md64.md_cval + ef->off);
613 md.md_data = (void *)(uintptr_t)(md64.md_data + ef->off);
614#else
615 COPYOUT(v, &md, sizeof(md));
616#ifdef __sparc64__
617 __elfN(reloc_ptr)(fp, ef, v, &md, sizeof(md));
618#else
619 md.md_cval += ef->off;
87004482 620 md.md_data = (uint8_t *)md.md_data + ef->off;
5ee58eed
MD
621#endif
622#endif
623 p += sizeof(Elf_Addr);
624 switch(md.md_type) {
625 case MDT_DEPEND:
626 if (ef->kernel) /* kernel must not depend on anything */
627 break;
628 s = strdupout((vm_offset_t)md.md_cval);
629 minfolen = sizeof(*mdepend) + strlen(s) + 1;
630 mdepend = malloc(minfolen);
631 if (mdepend == NULL)
632 return ENOMEM;
633 COPYOUT((vm_offset_t)md.md_data, mdepend, sizeof(*mdepend));
634 strcpy((char*)(mdepend + 1), s);
635 free(s);
636 file_addmetadata(fp, MODINFOMD_DEPLIST, minfolen, mdepend);
637 free(mdepend);
638 break;
639 case MDT_VERSION:
640 s = strdupout((vm_offset_t)md.md_cval);
641 COPYOUT((vm_offset_t)md.md_data, &mver, sizeof(mver));
642 file_addmodule(fp, s, mver.mv_version, NULL);
643 free(s);
644 modcnt++;
645 break;
646 }
647 }
648 if (modcnt == 0) {
649 s = fake_modname(fp->f_name);
650 file_addmodule(fp, s, 1, NULL);
651 free(s);
652 }
653 return 0;
654}
655
656static unsigned long
657elf_hash(const char *name)
658{
659 const unsigned char *p = (const unsigned char *) name;
660 unsigned long h = 0;
661 unsigned long g;
662
663 while (*p != '\0') {
664 h = (h << 4) + *p++;
665 if ((g = h & 0xf0000000) != 0)
666 h ^= g >> 24;
667 h &= ~g;
668 }
669 return h;
670}
671
672static const char __elfN(bad_symtable)[] = "elf" __XSTRING(__ELF_WORD_SIZE) "_lookup_symbol: corrupt symbol table\n";
673int
674__elfN(lookup_symbol)(struct preloaded_file *fp, elf_file_t ef, const char* name,
675 Elf_Sym *symp)
676{
677 Elf_Hashelt symnum;
678 Elf_Sym sym;
679 char *strp;
680 unsigned long hash;
681
682 hash = elf_hash(name);
683 COPYOUT(&ef->buckets[hash % ef->nbuckets], &symnum, sizeof(symnum));
684
685 while (symnum != STN_UNDEF) {
686 if (symnum >= ef->nchains) {
687 printf(__elfN(bad_symtable));
688 return ENOENT;
689 }
690
691 COPYOUT(ef->symtab + symnum, &sym, sizeof(sym));
692 if (sym.st_name == 0) {
693 printf(__elfN(bad_symtable));
694 return ENOENT;
695 }
696
697 strp = strdupout((vm_offset_t)(ef->strtab + sym.st_name));
698 if (strcmp(name, strp) == 0) {
699 free(strp);
700 if (sym.st_shndx != SHN_UNDEF ||
701 (sym.st_value != 0 &&
702 ELF_ST_TYPE(sym.st_info) == STT_FUNC)) {
703 *symp = sym;
704 return 0;
705 }
706 return ENOENT;
707 }
708 free(strp);
709 COPYOUT(&ef->chains[symnum], &symnum, sizeof(symnum));
710 }
711 return ENOENT;
712}
713
714#ifdef __sparc__
715/*
716 * Apply any intra-module relocations to the value. *p is the load address
717 * of the value and val/len is the value to be modified. This does NOT modify
718 * the image in-place, because this is done by kern_linker later on.
719 */
720static void
721__elfN(reloc_ptr)(struct preloaded_file *mp, elf_file_t ef,
722 void *p, void *val, size_t len)
723{
724 Elf_Addr off = (Elf_Addr)p - ef->off, word;
725 size_t n;
726 Elf_Rela r;
727
728 for (n = 0; n < ef->relasz / sizeof(r); n++) {
729 COPYOUT(ef->rela + n, &r, sizeof(r));
730
731 if (r.r_offset >= off && r.r_offset < off + len &&
732 ELF_R_TYPE(r.r_info) == R_SPARC_RELATIVE) {
733 word = ef->off + r.r_addend;
734 bcopy(&word, (char *)val + (r.r_offset - off),
735 sizeof(word));
736 }
737 }
738}
739#endif