161
162 if (modptr) {
163 ef->modptr = modptr;
164 baseptr = preload_search_info(modptr, MODINFO_ADDR);
165 if (baseptr)
166 linker_kernel_file->address = *(caddr_t *)baseptr;
167 sizeptr = preload_search_info(modptr, MODINFO_SIZE);
168 if (sizeptr)
169 linker_kernel_file->size = *(size_t *)sizeptr;
170 }
171 (void)parse_module_symbols(linker_kernel_file);
172 linker_current_file = linker_kernel_file;
173 linker_kernel_file->flags |= LINKER_FILE_LINKED;
174 }
175#endif
176}
177
178SYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0);
179
180static int
181parse_module_symbols(linker_file_t lf)
182{
183 elf_file_t ef = lf->priv;
184 caddr_t pointer;
185 caddr_t ssym, esym, base;
186 caddr_t strtab;
187 int strcnt;
188 Elf_Sym* symtab;
189 int symcnt;
190
191 if (ef->modptr == NULL)
192 return 0;
193 pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_SSYM);
194 if (pointer == NULL)
195 return 0;
196 ssym = *(caddr_t *)pointer;
197 pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_ESYM);
198 if (pointer == NULL)
199 return 0;
200 esym = *(caddr_t *)pointer;
201
202 base = ssym;
203
204 symcnt = *(long *)base;
205 base += sizeof(long);
206 symtab = (Elf_Sym *)base;
207 base += roundup(symcnt, sizeof(long));
208
209 if (base > esym || base < ssym) {
210 printf("Symbols are corrupt!\n");
211 return EINVAL;
212 }
213
214 strcnt = *(long *)base;
215 base += sizeof(long);
216 strtab = base;
217 base += roundup(strcnt, sizeof(long));
218
219 if (base > esym || base < ssym) {
220 printf("Symbols are corrupt!\n");
221 return EINVAL;
222 }
223
224 ef->ddbsymtab = symtab;
225 ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
226 ef->ddbstrtab = strtab;
227 ef->ddbstrcnt = strcnt;
228
229 return 0;
230}
231
232static int
233parse_dynamic(linker_file_t lf)
234{
235 elf_file_t ef = lf->priv;
236 const Elf_Dyn *dp;
237 int plttype = DT_REL;
238
239 for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
240 switch (dp->d_tag) {
241 case DT_HASH:
242 {
243 /* From src/libexec/rtld-elf/rtld.c */
244 const Elf_Off *hashtab = (const Elf_Off *)
245 (ef->address + dp->d_un.d_ptr);
246 ef->nbuckets = hashtab[0];
247 ef->nchains = hashtab[1];
248 ef->buckets = hashtab + 2;
249 ef->chains = ef->buckets + ef->nbuckets;
250 break;
251 }
252 case DT_STRTAB:
253 ef->strtab = (caddr_t) (ef->address + dp->d_un.d_ptr);
254 break;
255 case DT_STRSZ:
256 ef->strsz = dp->d_un.d_val;
257 break;
258 case DT_SYMTAB:
259 ef->symtab = (Elf_Sym*) (ef->address + dp->d_un.d_ptr);
260 break;
261 case DT_SYMENT:
262 if (dp->d_un.d_val != sizeof(Elf_Sym))
263 return ENOEXEC;
264 break;
265 case DT_PLTGOT:
266 ef->got = (Elf_Addr *) (ef->address + dp->d_un.d_ptr);
267 break;
268 case DT_REL:
269 ef->rel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr);
270 break;
271 case DT_RELSZ:
272 ef->relsize = dp->d_un.d_val;
273 break;
274 case DT_RELENT:
275 if (dp->d_un.d_val != sizeof(Elf_Rel))
276 return ENOEXEC;
277 break;
278 case DT_JMPREL:
279 ef->pltrel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr);
280 break;
281 case DT_PLTRELSZ:
282 ef->pltrelsize = dp->d_un.d_val;
283 break;
284 case DT_RELA:
285 ef->rela = (const Elf_Rela *) (ef->address + dp->d_un.d_ptr);
286 break;
287 case DT_RELASZ:
288 ef->relasize = dp->d_un.d_val;
289 break;
290 case DT_RELAENT:
291 if (dp->d_un.d_val != sizeof(Elf_Rela))
292 return ENOEXEC;
293 break;
294 case DT_PLTREL:
295 plttype = dp->d_un.d_val;
296 if (plttype != DT_REL && plttype != DT_RELA)
297 return ENOEXEC;
298 break;
299 }
300 }
301
302 if (plttype == DT_RELA) {
303 ef->pltrela = (const Elf_Rela *) ef->pltrel;
304 ef->pltrel = NULL;
305 ef->pltrelasize = ef->pltrelsize;
306 ef->pltrelsize = 0;
307 }
308
309 ef->ddbsymtab = ef->symtab;
310 ef->ddbsymcnt = ef->nchains;
311 ef->ddbstrtab = ef->strtab;
312 ef->ddbstrcnt = ef->strsz;
313
314 return 0;
315}
316
317static void
318link_elf_error(const char *s)
319{
320 printf("kldload: %s\n", s);
321}
322
323static int
324link_elf_load_module(const char *filename, linker_file_t *result)
325{
326 caddr_t modptr, baseptr, sizeptr, dynptr;
327 char *type;
328 elf_file_t ef;
329 linker_file_t lf;
330 int error;
331 vm_offset_t dp;
332
333 /* Look to see if we have the module preloaded */
334 modptr = preload_search_by_name(filename);
335 if (modptr == NULL)
336 return (link_elf_load_file(filename, result));
337
338 /* It's preloaded, check we can handle it and collect information */
339 type = (char *)preload_search_info(modptr, MODINFO_TYPE);
340 baseptr = preload_search_info(modptr, MODINFO_ADDR);
341 sizeptr = preload_search_info(modptr, MODINFO_SIZE);
342 dynptr = preload_search_info(modptr, MODINFO_METADATA|MODINFOMD_DYNAMIC);
343 if (type == NULL || strcmp(type, "elf module") != 0)
344 return (EFTYPE);
345 if (baseptr == NULL || sizeptr == NULL || dynptr == NULL)
346 return (EINVAL);
347
348 ef = malloc(sizeof(struct elf_file), M_LINKER, M_WAITOK);
349 if (ef == NULL)
350 return (ENOMEM);
351 bzero(ef, sizeof(*ef));
352 ef->modptr = modptr;
353 ef->address = *(caddr_t *)baseptr;
354#ifdef SPARSE_MAPPING
355 ef->object = 0;
356#endif
357 dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr;
358 ef->dynamic = (Elf_Dyn *)dp;
359 lf = linker_make_file(filename, ef, &link_elf_module_ops);
360 if (lf == NULL) {
361 free(ef, M_LINKER);
362 return ENOMEM;
363 }
364 lf->address = ef->address;
365 lf->size = *(size_t *)sizeptr;
366
367 error = parse_dynamic(lf);
368 if (error) {
369 linker_file_unload(lf);
370 return error;
371 }
372 error = load_dependancies(lf);
373 if (error) {
374 linker_file_unload(lf);
375 return error;
376 }
377 error = relocate_file(lf);
378 if (error) {
379 linker_file_unload(lf);
380 return error;
381 }
382 (void)parse_module_symbols(lf);
383 lf->flags |= LINKER_FILE_LINKED;
384 *result = lf;
385 return (0);
386}
387
388static int
389link_elf_load_file(const char* filename, linker_file_t* result)
390{
391 struct nameidata nd;
392 struct proc* p = curproc; /* XXX */
393 Elf_Ehdr *hdr;
394 caddr_t firstpage;
395 int nbytes, i;
396 Elf_Phdr *phdr;
397 Elf_Phdr *phlimit;
398 Elf_Phdr *segs[2];
399 int nsegs;
400 Elf_Phdr *phdyn;
401 Elf_Phdr *phphdr;
402 caddr_t mapbase;
403 size_t mapsize;
404 Elf_Off base_offset;
405 Elf_Addr base_vaddr;
406 Elf_Addr base_vlimit;
407 int error = 0;
408 int resid;
409 elf_file_t ef;
410 linker_file_t lf;
411 char *pathname;
412 Elf_Shdr *shdr;
413 int symtabindex;
414 int symstrindex;
415 int symcnt;
416 int strcnt;
417
418 shdr = NULL;
419 lf = NULL;
420
421 pathname = linker_search_path(filename);
422 if (pathname == NULL)
423 return ENOENT;
424
425 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, pathname, p);
426 error = vn_open(&nd, FREAD, 0);
427 free(pathname, M_LINKER);
428 if (error)
429 return error;
430
431 /*
432 * Read the elf header from the file.
433 */
434 firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK);
435 if (firstpage == NULL) {
436 error = ENOMEM;
437 goto out;
438 }
439 hdr = (Elf_Ehdr *)firstpage;
440 error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0,
441 UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
442 nbytes = PAGE_SIZE - resid;
443 if (error)
444 goto out;
445
446 if (!IS_ELF(*hdr)) {
447 error = ENOEXEC;
448 goto out;
449 }
450
451 if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS
452 || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) {
453 link_elf_error("Unsupported file layout");
454 error = ENOEXEC;
455 goto out;
456 }
457 if (hdr->e_ident[EI_VERSION] != EV_CURRENT
458 || hdr->e_version != EV_CURRENT) {
459 link_elf_error("Unsupported file version");
460 error = ENOEXEC;
461 goto out;
462 }
463 if (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN) {
464 link_elf_error("Unsupported file type");
465 error = ENOEXEC;
466 goto out;
467 }
468 if (hdr->e_machine != ELF_TARG_MACH) {
469 link_elf_error("Unsupported machine");
470 error = ENOEXEC;
471 goto out;
472 }
473
474 /*
475 * We rely on the program header being in the first page. This is
476 * not strictly required by the ABI specification, but it seems to
477 * always true in practice. And, it simplifies things considerably.
478 */
479 if (!((hdr->e_phentsize == sizeof(Elf_Phdr)) &&
480 (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) &&
481 (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= nbytes)))
482 link_elf_error("Unreadable program headers");
483
484 /*
485 * Scan the program header entries, and save key information.
486 *
487 * We rely on there being exactly two load segments, text and data,
488 * in that order.
489 */
490 phdr = (Elf_Phdr *) (firstpage + hdr->e_phoff);
491 phlimit = phdr + hdr->e_phnum;
492 nsegs = 0;
493 phdyn = NULL;
494 phphdr = NULL;
495 while (phdr < phlimit) {
496 switch (phdr->p_type) {
497
498 case PT_LOAD:
499 if (nsegs == 2) {
500 link_elf_error("Too many sections");
501 error = ENOEXEC;
502 goto out;
503 }
504 segs[nsegs] = phdr;
505 ++nsegs;
506 break;
507
508 case PT_PHDR:
509 phphdr = phdr;
510 break;
511
512 case PT_DYNAMIC:
513 phdyn = phdr;
514 break;
515 }
516
517 ++phdr;
518 }
519 if (phdyn == NULL) {
520 link_elf_error("Object is not dynamically-linked");
521 error = ENOEXEC;
522 goto out;
523 }
524
525 /*
526 * Allocate the entire address space of the object, to stake out our
527 * contiguous region, and to establish the base address for relocation.
528 */
529 base_offset = trunc_page(segs[0]->p_offset);
530 base_vaddr = trunc_page(segs[0]->p_vaddr);
531 base_vlimit = round_page(segs[1]->p_vaddr + segs[1]->p_memsz);
532 mapsize = base_vlimit - base_vaddr;
533
534 ef = malloc(sizeof(struct elf_file), M_LINKER, M_WAITOK);
535 bzero(ef, sizeof(*ef));
536#ifdef SPARSE_MAPPING
537 ef->object = vm_object_allocate(OBJT_DEFAULT, mapsize >> PAGE_SHIFT);
538 if (ef->object == NULL) {
539 free(ef, M_LINKER);
540 error = ENOMEM;
541 goto out;
542 }
543 vm_object_reference(ef->object);
544 ef->address = (caddr_t) vm_map_min(kernel_map);
545 error = vm_map_find(kernel_map, ef->object, 0,
546 (vm_offset_t *) &ef->address,
547 mapsize, 1,
548 VM_PROT_ALL, VM_PROT_ALL, 0);
549 if (error) {
550 vm_object_deallocate(ef->object);
551 free(ef, M_LINKER);
552 goto out;
553 }
554#else
555 ef->address = malloc(mapsize, M_LINKER, M_WAITOK);
556#endif
557 mapbase = ef->address;
558
559 /*
560 * Read the text and data sections and zero the bss.
561 */
562 for (i = 0; i < 2; i++) {
563 caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr;
564 error = vn_rdwr(UIO_READ, nd.ni_vp,
565 segbase, segs[i]->p_filesz, segs[i]->p_offset,
566 UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
567 if (error) {
568#ifdef SPARSE_MAPPING
569 vm_map_remove(kernel_map, (vm_offset_t) ef->address,
570 (vm_offset_t) ef->address
571 + (ef->object->size << PAGE_SHIFT));
572 vm_object_deallocate(ef->object);
573#else
574 free(ef->address, M_LINKER);
575#endif
576 free(ef, M_LINKER);
577 goto out;
578 }
579 bzero(segbase + segs[i]->p_filesz,
580 segs[i]->p_memsz - segs[i]->p_filesz);
581
582#ifdef SPARSE_MAPPING
583 /*
584 * Wire down the pages
585 */
586 vm_map_pageable(kernel_map,
587 (vm_offset_t) segbase,
588 (vm_offset_t) segbase + segs[i]->p_memsz,
589 FALSE);
590#endif
591 }
592
593 ef->dynamic = (const Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr);
594
595 lf = linker_make_file(filename, ef, &link_elf_file_ops);
596 if (lf == NULL) {
597#ifdef SPARSE_MAPPING
598 vm_map_remove(kernel_map, (vm_offset_t) ef->address,
599 (vm_offset_t) ef->address
600 + (ef->object->size << PAGE_SHIFT));
601 vm_object_deallocate(ef->object);
602#else
603 free(ef->address, M_LINKER);
604#endif
605 free(ef, M_LINKER);
606 error = ENOMEM;
607 goto out;
608 }
609 lf->address = ef->address;
610 lf->size = mapsize;
611
612 error = parse_dynamic(lf);
613 if (error)
614 goto out;
615 error = load_dependancies(lf);
616 if (error)
617 goto out;
618 error = relocate_file(lf);
619 if (error)
620 goto out;
621
622 /* Try and load the symbol table if it's present. (you can strip it!) */
623 nbytes = hdr->e_shnum * hdr->e_shentsize;
624 if (nbytes == 0 || hdr->e_shoff == 0)
625 goto nosyms;
626 shdr = malloc(nbytes, M_LINKER, M_WAITOK);
627 if (shdr == NULL) {
628 error = ENOMEM;
629 goto out;
630 }
631 bzero(shdr, nbytes);
632 error = vn_rdwr(UIO_READ, nd.ni_vp,
633 (caddr_t)shdr, nbytes, hdr->e_shoff,
634 UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
635 if (error)
636 goto out;
637 symtabindex = -1;
638 symstrindex = -1;
639 for (i = 0; i < hdr->e_shnum; i++) {
640 if (shdr[i].sh_type == SHT_SYMTAB) {
641 symtabindex = i;
642 symstrindex = shdr[i].sh_link;
643 }
644 }
645 if (symtabindex < 0 || symstrindex < 0)
646 goto nosyms;
647
648 symcnt = shdr[symtabindex].sh_size;
649 ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK);
650 strcnt = shdr[symstrindex].sh_size;
651 ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK);
652
653 if (ef->symbase == NULL || ef->strbase == NULL) {
654 error = ENOMEM;
655 goto out;
656 }
657 error = vn_rdwr(UIO_READ, nd.ni_vp,
658 ef->symbase, symcnt, shdr[symtabindex].sh_offset,
659 UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
660 if (error)
661 goto out;
662 error = vn_rdwr(UIO_READ, nd.ni_vp,
663 ef->strbase, strcnt, shdr[symstrindex].sh_offset,
664 UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
665 if (error)
666 goto out;
667
668 ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
669 ef->ddbsymtab = (const Elf_Sym *)ef->symbase;
670 ef->ddbstrcnt = strcnt;
671 ef->ddbstrtab = ef->strbase;
672
673 lf->flags |= LINKER_FILE_LINKED;
674
675nosyms:
676
677 *result = lf;
678
679out:
680 if (error && lf)
681 linker_file_unload(lf);
682 if (shdr)
683 free(shdr, M_LINKER);
684 if (firstpage)
685 free(firstpage, M_LINKER);
686 VOP_UNLOCK(nd.ni_vp, 0, p);
687 vn_close(nd.ni_vp, FREAD, p->p_ucred, p);
688
689 return error;
690}
691
692static void
693link_elf_unload_file(linker_file_t file)
694{
695 elf_file_t ef = file->priv;
696
697 if (ef) {
698#ifdef SPARSE_MAPPING
699 if (ef->object) {
700 vm_map_remove(kernel_map, (vm_offset_t) ef->address,
701 (vm_offset_t) ef->address
702 + (ef->object->size << PAGE_SHIFT));
703 vm_object_deallocate(ef->object);
704 }
705#else
706 if (ef->address)
707 free(ef->address, M_LINKER);
708#endif
709 if (ef->symbase)
710 free(ef->symbase, M_LINKER);
711 if (ef->strbase)
712 free(ef->strbase, M_LINKER);
713 free(ef, M_LINKER);
714 }
715}
716
717static void
718link_elf_unload_module(linker_file_t file)
719{
720 elf_file_t ef = file->priv;
721
722 if (ef)
723 free(ef, M_LINKER);
724 if (file->filename)
725 preload_delete_name(file->filename);
726}
727
728static int
729load_dependancies(linker_file_t lf)
730{
731 elf_file_t ef = lf->priv;
732 linker_file_t lfdep;
733 char* name;
734 const Elf_Dyn *dp;
735 int error = 0;
736
737 /*
738 * All files are dependant on /kernel.
739 */
740 if (linker_kernel_file) {
741 linker_kernel_file->refs++;
742 linker_file_add_dependancy(lf, linker_kernel_file);
743 }
744
745 for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
746 if (dp->d_tag == DT_NEEDED) {
747 name = ef->strtab + dp->d_un.d_val;
748
749 error = linker_load_file(name, &lfdep);
750 if (error)
751 goto out;
752 error = linker_file_add_dependancy(lf, lfdep);
753 if (error)
754 goto out;
755 }
756 }
757
758out:
759 return error;
760}
761
762static const char *
763symbol_name(elf_file_t ef, Elf_Word r_info)
764{
765 const Elf_Sym *ref;
766
767 if (ELF_R_SYM(r_info)) {
768 ref = ef->symtab + ELF_R_SYM(r_info);
769 return ef->strtab + ref->st_name;
770 } else
771 return NULL;
772}
773
774static int
775relocate_file(linker_file_t lf)
776{
777 elf_file_t ef = lf->priv;
778 const Elf_Rel *rellim;
779 const Elf_Rel *rel;
780 const Elf_Rela *relalim;
781 const Elf_Rela *rela;
782 const char *symname;
783
784 /* Perform relocations without addend if there are any: */
785 rel = ef->rel;
786 if (rel) {
787 rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize);
788 while (rel < rellim) {
789 symname = symbol_name(ef, rel->r_info);
790 if (elf_reloc(lf, rel, ELF_RELOC_REL, symname)) {
791 printf("link_elf: symbol %s undefined\n", symname);
792 return ENOENT;
793 }
794 rel++;
795 }
796 }
797
798 /* Perform relocations with addend if there are any: */
799 rela = ef->rela;
800 if (rela) {
801 relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize);
802 while (rela < relalim) {
803 symname = symbol_name(ef, rela->r_info);
804 if (elf_reloc(lf, rela, ELF_RELOC_RELA, symname)) {
805 printf("link_elf: symbol %s undefined\n", symname);
806 return ENOENT;
807 }
808 rela++;
809 }
810 }
811
812 /* Perform PLT relocations without addend if there are any: */
813 rel = ef->pltrel;
814 if (rel) {
815 rellim = (const Elf_Rel *)((const char *)ef->pltrel + ef->pltrelsize);
816 while (rel < rellim) {
817 symname = symbol_name(ef, rel->r_info);
818 if (elf_reloc(lf, rel, ELF_RELOC_REL, symname)) {
819 printf("link_elf: symbol %s undefined\n", symname);
820 return ENOENT;
821 }
822 rel++;
823 }
824 }
825
826 /* Perform relocations with addend if there are any: */
827 rela = ef->pltrela;
828 if (rela) {
829 relalim = (const Elf_Rela *)((const char *)ef->pltrela + ef->pltrelasize);
830 while (rela < relalim) {
831 symname = symbol_name(ef, rela->r_info);
832 if (elf_reloc(lf, rela, ELF_RELOC_RELA, symname)) {
833 printf("link_elf: symbol %s undefined\n", symname);
834 return ENOENT;
835 }
836 rela++;
837 }
838 }
839
840 return 0;
841}
842
843/*
844 * Hash function for symbol table lookup. Don't even think about changing
845 * this. It is specified by the System V ABI.
846 */
847static unsigned long
848elf_hash(const char *name)
849{
850 const unsigned char *p = (const unsigned char *) name;
851 unsigned long h = 0;
852 unsigned long g;
853
854 while (*p != '\0') {
855 h = (h << 4) + *p++;
856 if ((g = h & 0xf0000000) != 0)
857 h ^= g >> 24;
858 h &= ~g;
859 }
860 return h;
861}
862
863int
864link_elf_lookup_symbol(linker_file_t lf, const char* name, c_linker_sym_t* sym)
865{
866 elf_file_t ef = lf->priv;
867 unsigned long symnum;
868 const Elf_Sym* symp;
869 const char *strp;
870 unsigned long hash;
871 int i;
872
873 /* First, search hashed global symbols */
874 hash = elf_hash(name);
875 symnum = ef->buckets[hash % ef->nbuckets];
876
877 while (symnum != STN_UNDEF) {
878 if (symnum >= ef->nchains) {
879 printf("link_elf_lookup_symbol: corrupt symbol table\n");
880 return ENOENT;
881 }
882
883 symp = ef->symtab + symnum;
884 if (symp->st_name == 0) {
885 printf("link_elf_lookup_symbol: corrupt symbol table\n");
886 return ENOENT;
887 }
888
889 strp = ef->strtab + symp->st_name;
890
891 if (strcmp(name, strp) == 0) {
892 if (symp->st_shndx != SHN_UNDEF ||
893 (symp->st_value != 0 &&
894 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
895 *sym = (c_linker_sym_t) symp;
896 return 0;
897 } else
898 return ENOENT;
899 }
900
901 symnum = ef->chains[symnum];
902 }
903
904 /* If we have not found it, look at the full table (if loaded) */
905 if (ef->symtab == ef->ddbsymtab)
906 return ENOENT;
907
908 /* Exhaustive search */
909 for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
910 strp = ef->ddbstrtab + symp->st_name;
911 if (strcmp(name, strp) == 0) {
912 if (symp->st_shndx != SHN_UNDEF ||
913 (symp->st_value != 0 &&
914 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
915 *sym = (c_linker_sym_t) symp;
916 return 0;
917 } else
918 return ENOENT;
919 }
920 }
921
922 return ENOENT;
923}
924
925static int
926link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, linker_symval_t* symval)
927{
928 elf_file_t ef = lf->priv;
929 const Elf_Sym* es = (const Elf_Sym*) sym;
930
931 if (es >= ef->symtab && ((es - ef->symtab) < ef->nchains)) {
932 symval->name = ef->strtab + es->st_name;
933 symval->value = (caddr_t) ef->address + es->st_value;
934 symval->size = es->st_size;
935 return 0;
936 }
937 if (ef->symtab == ef->ddbsymtab)
938 return ENOENT;
939 if (es >= ef->ddbsymtab && ((es - ef->ddbsymtab) < ef->ddbsymcnt)) {
940 symval->name = ef->ddbstrtab + es->st_name;
941 symval->value = (caddr_t) ef->address + es->st_value;
942 symval->size = es->st_size;
943 return 0;
944 }
945 return ENOENT;
946}
947
948static int
949link_elf_search_symbol(linker_file_t lf, caddr_t value,
950 c_linker_sym_t* sym, long* diffp)
951{
952 elf_file_t ef = lf->priv;
| 161
162 if (modptr) {
163 ef->modptr = modptr;
164 baseptr = preload_search_info(modptr, MODINFO_ADDR);
165 if (baseptr)
166 linker_kernel_file->address = *(caddr_t *)baseptr;
167 sizeptr = preload_search_info(modptr, MODINFO_SIZE);
168 if (sizeptr)
169 linker_kernel_file->size = *(size_t *)sizeptr;
170 }
171 (void)parse_module_symbols(linker_kernel_file);
172 linker_current_file = linker_kernel_file;
173 linker_kernel_file->flags |= LINKER_FILE_LINKED;
174 }
175#endif
176}
177
178SYSINIT(link_elf, SI_SUB_KLD, SI_ORDER_SECOND, link_elf_init, 0);
179
180static int
181parse_module_symbols(linker_file_t lf)
182{
183 elf_file_t ef = lf->priv;
184 caddr_t pointer;
185 caddr_t ssym, esym, base;
186 caddr_t strtab;
187 int strcnt;
188 Elf_Sym* symtab;
189 int symcnt;
190
191 if (ef->modptr == NULL)
192 return 0;
193 pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_SSYM);
194 if (pointer == NULL)
195 return 0;
196 ssym = *(caddr_t *)pointer;
197 pointer = preload_search_info(ef->modptr, MODINFO_METADATA|MODINFOMD_ESYM);
198 if (pointer == NULL)
199 return 0;
200 esym = *(caddr_t *)pointer;
201
202 base = ssym;
203
204 symcnt = *(long *)base;
205 base += sizeof(long);
206 symtab = (Elf_Sym *)base;
207 base += roundup(symcnt, sizeof(long));
208
209 if (base > esym || base < ssym) {
210 printf("Symbols are corrupt!\n");
211 return EINVAL;
212 }
213
214 strcnt = *(long *)base;
215 base += sizeof(long);
216 strtab = base;
217 base += roundup(strcnt, sizeof(long));
218
219 if (base > esym || base < ssym) {
220 printf("Symbols are corrupt!\n");
221 return EINVAL;
222 }
223
224 ef->ddbsymtab = symtab;
225 ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
226 ef->ddbstrtab = strtab;
227 ef->ddbstrcnt = strcnt;
228
229 return 0;
230}
231
232static int
233parse_dynamic(linker_file_t lf)
234{
235 elf_file_t ef = lf->priv;
236 const Elf_Dyn *dp;
237 int plttype = DT_REL;
238
239 for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
240 switch (dp->d_tag) {
241 case DT_HASH:
242 {
243 /* From src/libexec/rtld-elf/rtld.c */
244 const Elf_Off *hashtab = (const Elf_Off *)
245 (ef->address + dp->d_un.d_ptr);
246 ef->nbuckets = hashtab[0];
247 ef->nchains = hashtab[1];
248 ef->buckets = hashtab + 2;
249 ef->chains = ef->buckets + ef->nbuckets;
250 break;
251 }
252 case DT_STRTAB:
253 ef->strtab = (caddr_t) (ef->address + dp->d_un.d_ptr);
254 break;
255 case DT_STRSZ:
256 ef->strsz = dp->d_un.d_val;
257 break;
258 case DT_SYMTAB:
259 ef->symtab = (Elf_Sym*) (ef->address + dp->d_un.d_ptr);
260 break;
261 case DT_SYMENT:
262 if (dp->d_un.d_val != sizeof(Elf_Sym))
263 return ENOEXEC;
264 break;
265 case DT_PLTGOT:
266 ef->got = (Elf_Addr *) (ef->address + dp->d_un.d_ptr);
267 break;
268 case DT_REL:
269 ef->rel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr);
270 break;
271 case DT_RELSZ:
272 ef->relsize = dp->d_un.d_val;
273 break;
274 case DT_RELENT:
275 if (dp->d_un.d_val != sizeof(Elf_Rel))
276 return ENOEXEC;
277 break;
278 case DT_JMPREL:
279 ef->pltrel = (const Elf_Rel *) (ef->address + dp->d_un.d_ptr);
280 break;
281 case DT_PLTRELSZ:
282 ef->pltrelsize = dp->d_un.d_val;
283 break;
284 case DT_RELA:
285 ef->rela = (const Elf_Rela *) (ef->address + dp->d_un.d_ptr);
286 break;
287 case DT_RELASZ:
288 ef->relasize = dp->d_un.d_val;
289 break;
290 case DT_RELAENT:
291 if (dp->d_un.d_val != sizeof(Elf_Rela))
292 return ENOEXEC;
293 break;
294 case DT_PLTREL:
295 plttype = dp->d_un.d_val;
296 if (plttype != DT_REL && plttype != DT_RELA)
297 return ENOEXEC;
298 break;
299 }
300 }
301
302 if (plttype == DT_RELA) {
303 ef->pltrela = (const Elf_Rela *) ef->pltrel;
304 ef->pltrel = NULL;
305 ef->pltrelasize = ef->pltrelsize;
306 ef->pltrelsize = 0;
307 }
308
309 ef->ddbsymtab = ef->symtab;
310 ef->ddbsymcnt = ef->nchains;
311 ef->ddbstrtab = ef->strtab;
312 ef->ddbstrcnt = ef->strsz;
313
314 return 0;
315}
316
317static void
318link_elf_error(const char *s)
319{
320 printf("kldload: %s\n", s);
321}
322
323static int
324link_elf_load_module(const char *filename, linker_file_t *result)
325{
326 caddr_t modptr, baseptr, sizeptr, dynptr;
327 char *type;
328 elf_file_t ef;
329 linker_file_t lf;
330 int error;
331 vm_offset_t dp;
332
333 /* Look to see if we have the module preloaded */
334 modptr = preload_search_by_name(filename);
335 if (modptr == NULL)
336 return (link_elf_load_file(filename, result));
337
338 /* It's preloaded, check we can handle it and collect information */
339 type = (char *)preload_search_info(modptr, MODINFO_TYPE);
340 baseptr = preload_search_info(modptr, MODINFO_ADDR);
341 sizeptr = preload_search_info(modptr, MODINFO_SIZE);
342 dynptr = preload_search_info(modptr, MODINFO_METADATA|MODINFOMD_DYNAMIC);
343 if (type == NULL || strcmp(type, "elf module") != 0)
344 return (EFTYPE);
345 if (baseptr == NULL || sizeptr == NULL || dynptr == NULL)
346 return (EINVAL);
347
348 ef = malloc(sizeof(struct elf_file), M_LINKER, M_WAITOK);
349 if (ef == NULL)
350 return (ENOMEM);
351 bzero(ef, sizeof(*ef));
352 ef->modptr = modptr;
353 ef->address = *(caddr_t *)baseptr;
354#ifdef SPARSE_MAPPING
355 ef->object = 0;
356#endif
357 dp = (vm_offset_t)ef->address + *(vm_offset_t *)dynptr;
358 ef->dynamic = (Elf_Dyn *)dp;
359 lf = linker_make_file(filename, ef, &link_elf_module_ops);
360 if (lf == NULL) {
361 free(ef, M_LINKER);
362 return ENOMEM;
363 }
364 lf->address = ef->address;
365 lf->size = *(size_t *)sizeptr;
366
367 error = parse_dynamic(lf);
368 if (error) {
369 linker_file_unload(lf);
370 return error;
371 }
372 error = load_dependancies(lf);
373 if (error) {
374 linker_file_unload(lf);
375 return error;
376 }
377 error = relocate_file(lf);
378 if (error) {
379 linker_file_unload(lf);
380 return error;
381 }
382 (void)parse_module_symbols(lf);
383 lf->flags |= LINKER_FILE_LINKED;
384 *result = lf;
385 return (0);
386}
387
388static int
389link_elf_load_file(const char* filename, linker_file_t* result)
390{
391 struct nameidata nd;
392 struct proc* p = curproc; /* XXX */
393 Elf_Ehdr *hdr;
394 caddr_t firstpage;
395 int nbytes, i;
396 Elf_Phdr *phdr;
397 Elf_Phdr *phlimit;
398 Elf_Phdr *segs[2];
399 int nsegs;
400 Elf_Phdr *phdyn;
401 Elf_Phdr *phphdr;
402 caddr_t mapbase;
403 size_t mapsize;
404 Elf_Off base_offset;
405 Elf_Addr base_vaddr;
406 Elf_Addr base_vlimit;
407 int error = 0;
408 int resid;
409 elf_file_t ef;
410 linker_file_t lf;
411 char *pathname;
412 Elf_Shdr *shdr;
413 int symtabindex;
414 int symstrindex;
415 int symcnt;
416 int strcnt;
417
418 shdr = NULL;
419 lf = NULL;
420
421 pathname = linker_search_path(filename);
422 if (pathname == NULL)
423 return ENOENT;
424
425 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, pathname, p);
426 error = vn_open(&nd, FREAD, 0);
427 free(pathname, M_LINKER);
428 if (error)
429 return error;
430
431 /*
432 * Read the elf header from the file.
433 */
434 firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK);
435 if (firstpage == NULL) {
436 error = ENOMEM;
437 goto out;
438 }
439 hdr = (Elf_Ehdr *)firstpage;
440 error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0,
441 UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
442 nbytes = PAGE_SIZE - resid;
443 if (error)
444 goto out;
445
446 if (!IS_ELF(*hdr)) {
447 error = ENOEXEC;
448 goto out;
449 }
450
451 if (hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS
452 || hdr->e_ident[EI_DATA] != ELF_TARG_DATA) {
453 link_elf_error("Unsupported file layout");
454 error = ENOEXEC;
455 goto out;
456 }
457 if (hdr->e_ident[EI_VERSION] != EV_CURRENT
458 || hdr->e_version != EV_CURRENT) {
459 link_elf_error("Unsupported file version");
460 error = ENOEXEC;
461 goto out;
462 }
463 if (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN) {
464 link_elf_error("Unsupported file type");
465 error = ENOEXEC;
466 goto out;
467 }
468 if (hdr->e_machine != ELF_TARG_MACH) {
469 link_elf_error("Unsupported machine");
470 error = ENOEXEC;
471 goto out;
472 }
473
474 /*
475 * We rely on the program header being in the first page. This is
476 * not strictly required by the ABI specification, but it seems to
477 * always true in practice. And, it simplifies things considerably.
478 */
479 if (!((hdr->e_phentsize == sizeof(Elf_Phdr)) &&
480 (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) &&
481 (hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= nbytes)))
482 link_elf_error("Unreadable program headers");
483
484 /*
485 * Scan the program header entries, and save key information.
486 *
487 * We rely on there being exactly two load segments, text and data,
488 * in that order.
489 */
490 phdr = (Elf_Phdr *) (firstpage + hdr->e_phoff);
491 phlimit = phdr + hdr->e_phnum;
492 nsegs = 0;
493 phdyn = NULL;
494 phphdr = NULL;
495 while (phdr < phlimit) {
496 switch (phdr->p_type) {
497
498 case PT_LOAD:
499 if (nsegs == 2) {
500 link_elf_error("Too many sections");
501 error = ENOEXEC;
502 goto out;
503 }
504 segs[nsegs] = phdr;
505 ++nsegs;
506 break;
507
508 case PT_PHDR:
509 phphdr = phdr;
510 break;
511
512 case PT_DYNAMIC:
513 phdyn = phdr;
514 break;
515 }
516
517 ++phdr;
518 }
519 if (phdyn == NULL) {
520 link_elf_error("Object is not dynamically-linked");
521 error = ENOEXEC;
522 goto out;
523 }
524
525 /*
526 * Allocate the entire address space of the object, to stake out our
527 * contiguous region, and to establish the base address for relocation.
528 */
529 base_offset = trunc_page(segs[0]->p_offset);
530 base_vaddr = trunc_page(segs[0]->p_vaddr);
531 base_vlimit = round_page(segs[1]->p_vaddr + segs[1]->p_memsz);
532 mapsize = base_vlimit - base_vaddr;
533
534 ef = malloc(sizeof(struct elf_file), M_LINKER, M_WAITOK);
535 bzero(ef, sizeof(*ef));
536#ifdef SPARSE_MAPPING
537 ef->object = vm_object_allocate(OBJT_DEFAULT, mapsize >> PAGE_SHIFT);
538 if (ef->object == NULL) {
539 free(ef, M_LINKER);
540 error = ENOMEM;
541 goto out;
542 }
543 vm_object_reference(ef->object);
544 ef->address = (caddr_t) vm_map_min(kernel_map);
545 error = vm_map_find(kernel_map, ef->object, 0,
546 (vm_offset_t *) &ef->address,
547 mapsize, 1,
548 VM_PROT_ALL, VM_PROT_ALL, 0);
549 if (error) {
550 vm_object_deallocate(ef->object);
551 free(ef, M_LINKER);
552 goto out;
553 }
554#else
555 ef->address = malloc(mapsize, M_LINKER, M_WAITOK);
556#endif
557 mapbase = ef->address;
558
559 /*
560 * Read the text and data sections and zero the bss.
561 */
562 for (i = 0; i < 2; i++) {
563 caddr_t segbase = mapbase + segs[i]->p_vaddr - base_vaddr;
564 error = vn_rdwr(UIO_READ, nd.ni_vp,
565 segbase, segs[i]->p_filesz, segs[i]->p_offset,
566 UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
567 if (error) {
568#ifdef SPARSE_MAPPING
569 vm_map_remove(kernel_map, (vm_offset_t) ef->address,
570 (vm_offset_t) ef->address
571 + (ef->object->size << PAGE_SHIFT));
572 vm_object_deallocate(ef->object);
573#else
574 free(ef->address, M_LINKER);
575#endif
576 free(ef, M_LINKER);
577 goto out;
578 }
579 bzero(segbase + segs[i]->p_filesz,
580 segs[i]->p_memsz - segs[i]->p_filesz);
581
582#ifdef SPARSE_MAPPING
583 /*
584 * Wire down the pages
585 */
586 vm_map_pageable(kernel_map,
587 (vm_offset_t) segbase,
588 (vm_offset_t) segbase + segs[i]->p_memsz,
589 FALSE);
590#endif
591 }
592
593 ef->dynamic = (const Elf_Dyn *) (mapbase + phdyn->p_vaddr - base_vaddr);
594
595 lf = linker_make_file(filename, ef, &link_elf_file_ops);
596 if (lf == NULL) {
597#ifdef SPARSE_MAPPING
598 vm_map_remove(kernel_map, (vm_offset_t) ef->address,
599 (vm_offset_t) ef->address
600 + (ef->object->size << PAGE_SHIFT));
601 vm_object_deallocate(ef->object);
602#else
603 free(ef->address, M_LINKER);
604#endif
605 free(ef, M_LINKER);
606 error = ENOMEM;
607 goto out;
608 }
609 lf->address = ef->address;
610 lf->size = mapsize;
611
612 error = parse_dynamic(lf);
613 if (error)
614 goto out;
615 error = load_dependancies(lf);
616 if (error)
617 goto out;
618 error = relocate_file(lf);
619 if (error)
620 goto out;
621
622 /* Try and load the symbol table if it's present. (you can strip it!) */
623 nbytes = hdr->e_shnum * hdr->e_shentsize;
624 if (nbytes == 0 || hdr->e_shoff == 0)
625 goto nosyms;
626 shdr = malloc(nbytes, M_LINKER, M_WAITOK);
627 if (shdr == NULL) {
628 error = ENOMEM;
629 goto out;
630 }
631 bzero(shdr, nbytes);
632 error = vn_rdwr(UIO_READ, nd.ni_vp,
633 (caddr_t)shdr, nbytes, hdr->e_shoff,
634 UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
635 if (error)
636 goto out;
637 symtabindex = -1;
638 symstrindex = -1;
639 for (i = 0; i < hdr->e_shnum; i++) {
640 if (shdr[i].sh_type == SHT_SYMTAB) {
641 symtabindex = i;
642 symstrindex = shdr[i].sh_link;
643 }
644 }
645 if (symtabindex < 0 || symstrindex < 0)
646 goto nosyms;
647
648 symcnt = shdr[symtabindex].sh_size;
649 ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK);
650 strcnt = shdr[symstrindex].sh_size;
651 ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK);
652
653 if (ef->symbase == NULL || ef->strbase == NULL) {
654 error = ENOMEM;
655 goto out;
656 }
657 error = vn_rdwr(UIO_READ, nd.ni_vp,
658 ef->symbase, symcnt, shdr[symtabindex].sh_offset,
659 UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
660 if (error)
661 goto out;
662 error = vn_rdwr(UIO_READ, nd.ni_vp,
663 ef->strbase, strcnt, shdr[symstrindex].sh_offset,
664 UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
665 if (error)
666 goto out;
667
668 ef->ddbsymcnt = symcnt / sizeof(Elf_Sym);
669 ef->ddbsymtab = (const Elf_Sym *)ef->symbase;
670 ef->ddbstrcnt = strcnt;
671 ef->ddbstrtab = ef->strbase;
672
673 lf->flags |= LINKER_FILE_LINKED;
674
675nosyms:
676
677 *result = lf;
678
679out:
680 if (error && lf)
681 linker_file_unload(lf);
682 if (shdr)
683 free(shdr, M_LINKER);
684 if (firstpage)
685 free(firstpage, M_LINKER);
686 VOP_UNLOCK(nd.ni_vp, 0, p);
687 vn_close(nd.ni_vp, FREAD, p->p_ucred, p);
688
689 return error;
690}
691
692static void
693link_elf_unload_file(linker_file_t file)
694{
695 elf_file_t ef = file->priv;
696
697 if (ef) {
698#ifdef SPARSE_MAPPING
699 if (ef->object) {
700 vm_map_remove(kernel_map, (vm_offset_t) ef->address,
701 (vm_offset_t) ef->address
702 + (ef->object->size << PAGE_SHIFT));
703 vm_object_deallocate(ef->object);
704 }
705#else
706 if (ef->address)
707 free(ef->address, M_LINKER);
708#endif
709 if (ef->symbase)
710 free(ef->symbase, M_LINKER);
711 if (ef->strbase)
712 free(ef->strbase, M_LINKER);
713 free(ef, M_LINKER);
714 }
715}
716
717static void
718link_elf_unload_module(linker_file_t file)
719{
720 elf_file_t ef = file->priv;
721
722 if (ef)
723 free(ef, M_LINKER);
724 if (file->filename)
725 preload_delete_name(file->filename);
726}
727
728static int
729load_dependancies(linker_file_t lf)
730{
731 elf_file_t ef = lf->priv;
732 linker_file_t lfdep;
733 char* name;
734 const Elf_Dyn *dp;
735 int error = 0;
736
737 /*
738 * All files are dependant on /kernel.
739 */
740 if (linker_kernel_file) {
741 linker_kernel_file->refs++;
742 linker_file_add_dependancy(lf, linker_kernel_file);
743 }
744
745 for (dp = ef->dynamic; dp->d_tag != DT_NULL; dp++) {
746 if (dp->d_tag == DT_NEEDED) {
747 name = ef->strtab + dp->d_un.d_val;
748
749 error = linker_load_file(name, &lfdep);
750 if (error)
751 goto out;
752 error = linker_file_add_dependancy(lf, lfdep);
753 if (error)
754 goto out;
755 }
756 }
757
758out:
759 return error;
760}
761
762static const char *
763symbol_name(elf_file_t ef, Elf_Word r_info)
764{
765 const Elf_Sym *ref;
766
767 if (ELF_R_SYM(r_info)) {
768 ref = ef->symtab + ELF_R_SYM(r_info);
769 return ef->strtab + ref->st_name;
770 } else
771 return NULL;
772}
773
774static int
775relocate_file(linker_file_t lf)
776{
777 elf_file_t ef = lf->priv;
778 const Elf_Rel *rellim;
779 const Elf_Rel *rel;
780 const Elf_Rela *relalim;
781 const Elf_Rela *rela;
782 const char *symname;
783
784 /* Perform relocations without addend if there are any: */
785 rel = ef->rel;
786 if (rel) {
787 rellim = (const Elf_Rel *)((const char *)ef->rel + ef->relsize);
788 while (rel < rellim) {
789 symname = symbol_name(ef, rel->r_info);
790 if (elf_reloc(lf, rel, ELF_RELOC_REL, symname)) {
791 printf("link_elf: symbol %s undefined\n", symname);
792 return ENOENT;
793 }
794 rel++;
795 }
796 }
797
798 /* Perform relocations with addend if there are any: */
799 rela = ef->rela;
800 if (rela) {
801 relalim = (const Elf_Rela *)((const char *)ef->rela + ef->relasize);
802 while (rela < relalim) {
803 symname = symbol_name(ef, rela->r_info);
804 if (elf_reloc(lf, rela, ELF_RELOC_RELA, symname)) {
805 printf("link_elf: symbol %s undefined\n", symname);
806 return ENOENT;
807 }
808 rela++;
809 }
810 }
811
812 /* Perform PLT relocations without addend if there are any: */
813 rel = ef->pltrel;
814 if (rel) {
815 rellim = (const Elf_Rel *)((const char *)ef->pltrel + ef->pltrelsize);
816 while (rel < rellim) {
817 symname = symbol_name(ef, rel->r_info);
818 if (elf_reloc(lf, rel, ELF_RELOC_REL, symname)) {
819 printf("link_elf: symbol %s undefined\n", symname);
820 return ENOENT;
821 }
822 rel++;
823 }
824 }
825
826 /* Perform relocations with addend if there are any: */
827 rela = ef->pltrela;
828 if (rela) {
829 relalim = (const Elf_Rela *)((const char *)ef->pltrela + ef->pltrelasize);
830 while (rela < relalim) {
831 symname = symbol_name(ef, rela->r_info);
832 if (elf_reloc(lf, rela, ELF_RELOC_RELA, symname)) {
833 printf("link_elf: symbol %s undefined\n", symname);
834 return ENOENT;
835 }
836 rela++;
837 }
838 }
839
840 return 0;
841}
842
843/*
844 * Hash function for symbol table lookup. Don't even think about changing
845 * this. It is specified by the System V ABI.
846 */
847static unsigned long
848elf_hash(const char *name)
849{
850 const unsigned char *p = (const unsigned char *) name;
851 unsigned long h = 0;
852 unsigned long g;
853
854 while (*p != '\0') {
855 h = (h << 4) + *p++;
856 if ((g = h & 0xf0000000) != 0)
857 h ^= g >> 24;
858 h &= ~g;
859 }
860 return h;
861}
862
863int
864link_elf_lookup_symbol(linker_file_t lf, const char* name, c_linker_sym_t* sym)
865{
866 elf_file_t ef = lf->priv;
867 unsigned long symnum;
868 const Elf_Sym* symp;
869 const char *strp;
870 unsigned long hash;
871 int i;
872
873 /* First, search hashed global symbols */
874 hash = elf_hash(name);
875 symnum = ef->buckets[hash % ef->nbuckets];
876
877 while (symnum != STN_UNDEF) {
878 if (symnum >= ef->nchains) {
879 printf("link_elf_lookup_symbol: corrupt symbol table\n");
880 return ENOENT;
881 }
882
883 symp = ef->symtab + symnum;
884 if (symp->st_name == 0) {
885 printf("link_elf_lookup_symbol: corrupt symbol table\n");
886 return ENOENT;
887 }
888
889 strp = ef->strtab + symp->st_name;
890
891 if (strcmp(name, strp) == 0) {
892 if (symp->st_shndx != SHN_UNDEF ||
893 (symp->st_value != 0 &&
894 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
895 *sym = (c_linker_sym_t) symp;
896 return 0;
897 } else
898 return ENOENT;
899 }
900
901 symnum = ef->chains[symnum];
902 }
903
904 /* If we have not found it, look at the full table (if loaded) */
905 if (ef->symtab == ef->ddbsymtab)
906 return ENOENT;
907
908 /* Exhaustive search */
909 for (i = 0, symp = ef->ddbsymtab; i < ef->ddbsymcnt; i++, symp++) {
910 strp = ef->ddbstrtab + symp->st_name;
911 if (strcmp(name, strp) == 0) {
912 if (symp->st_shndx != SHN_UNDEF ||
913 (symp->st_value != 0 &&
914 ELF_ST_TYPE(symp->st_info) == STT_FUNC)) {
915 *sym = (c_linker_sym_t) symp;
916 return 0;
917 } else
918 return ENOENT;
919 }
920 }
921
922 return ENOENT;
923}
924
925static int
926link_elf_symbol_values(linker_file_t lf, c_linker_sym_t sym, linker_symval_t* symval)
927{
928 elf_file_t ef = lf->priv;
929 const Elf_Sym* es = (const Elf_Sym*) sym;
930
931 if (es >= ef->symtab && ((es - ef->symtab) < ef->nchains)) {
932 symval->name = ef->strtab + es->st_name;
933 symval->value = (caddr_t) ef->address + es->st_value;
934 symval->size = es->st_size;
935 return 0;
936 }
937 if (ef->symtab == ef->ddbsymtab)
938 return ENOENT;
939 if (es >= ef->ddbsymtab && ((es - ef->ddbsymtab) < ef->ddbsymcnt)) {
940 symval->name = ef->ddbstrtab + es->st_name;
941 symval->value = (caddr_t) ef->address + es->st_value;
942 symval->size = es->st_size;
943 return 0;
944 }
945 return ENOENT;
946}
947
948static int
949link_elf_search_symbol(linker_file_t lf, caddr_t value,
950 c_linker_sym_t* sym, long* diffp)
951{
952 elf_file_t ef = lf->priv;
|