int
main(int argc, char *argv[])
{
int fd;
u_long marks[MARK_MAX];
Elf_Ehdr elf;
if (argc != 2) {
(void)fprintf(stderr, "Usage: %s <file>\n", getprogname());
return 1;
}
if ((fd = open(argv[1], O_RDONLY)) == -1)
err(1, "Can't open `%s'", argv[1]);
if (read(fd, &elf, sizeof(elf)) != sizeof(elf))
err(1, "Can't read `%s'", argv[1]);
memset(marks, 0, sizeof(marks));
marks[MARK_START] = (u_long)malloc(2LL * 1024 * 2024 * 1024);
ELFNAMEEND(loadfile)(fd, &elf, marks, LOAD_ALL);
printf("%d\n", netbsd_version);
return 0;
}
/*
* Prepare an Elf binary's exec package
*
* First, set of the various offsets/lengths in the exec package.
*
* Then, mark the text image busy (so it can be demand paged) or error out if
* this is not possible. Finally, set up vmcmds for the text, data, bss, and
* stack segments.
*/
int
ELFNAME2(exec,makecmds)(struct proc *p, struct exec_package *epp)
{
Elf_Ehdr *eh = epp->ep_hdr;
Elf_Phdr *ph, *pp;
Elf_Addr phdr = 0;
int error, i;
char interp[MAXPATHLEN];
u_long pos = 0, phsize;
u_int8_t os = OOS_NULL;
if (epp->ep_hdrvalid < sizeof(Elf_Ehdr))
return (ENOEXEC);
if (ELFNAME(check_header)(eh, ET_EXEC) &&
ELFNAME(olf_check_header)(eh, ET_EXEC, &os))
return (ENOEXEC);
/*
* check if vnode is in open for writing, because we want to demand-
* page out of it. if it is, don't do it, for various reasons.
*/
if (epp->ep_vp->v_writecount != 0) {
#ifdef DIAGNOSTIC
if (epp->ep_vp->v_flag & VTEXT)
panic("exec: a VTEXT vnode has writecount != 0");
#endif
return (ETXTBSY);
}
/*
* Allocate space to hold all the program headers, and read them
* from the file
*/
phsize = eh->e_phnum * sizeof(Elf_Phdr);
ph = (Elf_Phdr *)malloc(phsize, M_TEMP, M_WAITOK);
if ((error = ELFNAME(read_from)(p, epp->ep_vp, eh->e_phoff, (caddr_t)ph,
phsize)) != 0)
goto bad;
epp->ep_tsize = ELFDEFNNAME(NO_ADDR);
epp->ep_dsize = ELFDEFNNAME(NO_ADDR);
interp[0] = '\0';
for (i = 0; i < eh->e_phnum; i++) {
pp = &ph[i];
if (pp->p_type == PT_INTERP) {
if (pp->p_filesz >= sizeof(interp))
goto bad;
if ((error = ELFNAME(read_from)(p, epp->ep_vp,
pp->p_offset, (caddr_t)interp, pp->p_filesz)) != 0)
goto bad;
break;
}
}
/*
* OK, we want a slightly different twist of the
* standard emulation package for "real" elf.
*/
epp->ep_emul = &ELFNAMEEND(emul);
pos = ELFDEFNNAME(NO_ADDR);
/*
* On the same architecture, we may be emulating different systems.
* See which one will accept this executable.
*
* Probe functions would normally see if the interpreter (if any)
* exists. Emulation packages may possibly replace the interpreter in
* interp[] with a changed path (/emul/xxx/<path>), and also
* set the ep_emul field in the exec package structure.
*/
error = ENOEXEC;
p->p_os = OOS_OPENBSD;
#ifdef NATIVE_EXEC_ELF
if (ELFNAME(os_pt_note)(p, epp, epp->ep_hdr, "OpenBSD", 8, 4) == 0) {
goto native;
}
#endif
for (i = 0;
i < sizeof(ELFNAME(probes)) / sizeof(ELFNAME(probes)[0]) && error;
i++) {
if (os == OOS_NULL || ((1 << os) & ELFNAME(probes)[i].os_mask))
error = ELFNAME(probes)[i].func ?
(*ELFNAME(probes)[i].func)(p, epp, interp, &pos, &os) :
0;
}
if (!error)
p->p_os = os;
#ifndef NATIVE_EXEC_ELF
else
goto bad;
#else
native:
#endif /* NATIVE_EXEC_ELF */
/*
* Load all the necessary sections
*/
for (i = 0; i < eh->e_phnum; i++) {
Elf_Addr addr = ELFDEFNNAME(NO_ADDR), size = 0;
int prot = 0;
pp = &ph[i];
switch (ph[i].p_type) {
case PT_LOAD:
/*
* Calcuates size of text and data segments
* by starting at first and going to end of last.
* 'rwx' sections are treated as data.
* this is correct for BSS_PLT, but may not be
* for DATA_PLT, is fine for TEXT_PLT.
*/
ELFNAME(load_psection)(&epp->ep_vmcmds, epp->ep_vp,
&ph[i], &addr, &size, &prot, 0);
/*
* Decide whether it's text or data by looking
* at the protection of the section
*/
if (prot & VM_PROT_WRITE) {
/* data section */
if (epp->ep_dsize == ELFDEFNNAME(NO_ADDR)) {
epp->ep_daddr = addr;
epp->ep_dsize = size;
} else {
if (addr < epp->ep_daddr) {
epp->ep_dsize =
epp->ep_dsize +
epp->ep_daddr -
addr;
epp->ep_daddr = addr;
} else
epp->ep_dsize = addr+size -
epp->ep_daddr;
}
} else if (prot & VM_PROT_EXECUTE) {
/* text section */
if (epp->ep_tsize == ELFDEFNNAME(NO_ADDR)) {
epp->ep_taddr = addr;
epp->ep_tsize = size;
} else {
if (addr < epp->ep_taddr) {
epp->ep_tsize =
epp->ep_tsize +
epp->ep_taddr -
addr;
epp->ep_taddr = addr;
} else
epp->ep_tsize = addr+size -
epp->ep_taddr;
}
}
break;
case PT_SHLIB:
error = ENOEXEC;
goto bad;
case PT_INTERP:
/* Already did this one */
case PT_DYNAMIC:
case PT_NOTE:
break;
case PT_PHDR:
/* Note address of program headers (in text segment) */
phdr = pp->p_vaddr;
break;
default:
/*
* Not fatal, we don't need to understand everything
* :-)
*/
break;
}
}
/*
* Check if we found a dynamically linked binary and arrange to load
* it's interpreter when the exec file is released.
*/
if (interp[0]) {
char *ip;
struct elf_args *ap;
ip = (char *)malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
ap = (struct elf_args *)
malloc(sizeof(struct elf_args), M_TEMP, M_WAITOK);
bcopy(interp, ip, MAXPATHLEN);
epp->ep_interp = ip;
epp->ep_interp_pos = pos;
ap->arg_phaddr = phdr;
ap->arg_phentsize = eh->e_phentsize;
ap->arg_phnum = eh->e_phnum;
ap->arg_entry = eh->e_entry;
ap->arg_os = os;
epp->ep_emul_arg = ap;
epp->ep_entry = eh->e_entry; /* keep check_exec() happy */
} else {
epp->ep_interp = NULL;
epp->ep_entry = eh->e_entry;
}
#if defined(COMPAT_SVR4) && defined(i386)
#ifndef ELF_MAP_PAGE_ZERO
/* Dell SVR4 maps page zero, yeuch! */
if (p->p_os == OOS_DELL)
#endif
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, PAGE_SIZE, 0,
epp->ep_vp, 0, VM_PROT_READ);
#endif
free((char *)ph, M_TEMP);
vn_marktext(epp->ep_vp);
return (exec_setup_stack(p, epp));
bad:
free((char *)ph, M_TEMP);
kill_vmcmds(&epp->ep_vmcmds);
return (ENOEXEC);
}