int
exec_linux_aout_prep_nmagic(struct proc *p, struct exec_package *epp)
{
struct exec *execp = epp->ep_hdr;
long bsize, baddr;
epp->ep_taddr = LINUX_N_TXTADDR(*execp, NMAGIC);
epp->ep_tsize = execp->a_text;
epp->ep_daddr = LINUX_N_DATADDR(*execp, NMAGIC);
epp->ep_dsize = execp->a_data + execp->a_bss;
epp->ep_entry = execp->a_entry;
/* set up command for text segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, execp->a_text,
epp->ep_taddr, epp->ep_vp, LINUX_N_TXTOFF(*execp, NMAGIC),
VM_PROT_READ|VM_PROT_EXECUTE);
/* set up command for data segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, execp->a_data,
epp->ep_daddr, epp->ep_vp, LINUX_N_DATOFF(*execp, NMAGIC),
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
/* set up command for bss segment */
baddr = round_page(epp->ep_daddr + execp->a_data);
bsize = epp->ep_daddr + epp->ep_dsize - baddr;
if (bsize > 0)
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, bsize, baddr,
NULLVP, 0, VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
return (exec_setup_stack(p, epp));
}
int
exec_linux_aout_prep_qmagic(struct proc *p, struct exec_package *epp)
{
struct exec *execp = epp->ep_hdr;
epp->ep_taddr = LINUX_N_TXTADDR(*execp, QMAGIC);
epp->ep_tsize = execp->a_text;
epp->ep_daddr = LINUX_N_DATADDR(*execp, QMAGIC);
epp->ep_dsize = execp->a_data + execp->a_bss;
epp->ep_entry = execp->a_entry;
/*
* 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 ((execp->a_text != 0 || execp->a_data != 0) &&
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);
}
vn_marktext(epp->ep_vp);
/* set up command for text segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_pagedvn, execp->a_text,
epp->ep_taddr, epp->ep_vp, LINUX_N_TXTOFF(*execp, QMAGIC),
VM_PROT_READ|VM_PROT_EXECUTE);
/* set up command for data segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_pagedvn, execp->a_data,
epp->ep_daddr, epp->ep_vp, LINUX_N_DATOFF(*execp, QMAGIC),
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
/* set up command for bss segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, execp->a_bss,
epp->ep_daddr + execp->a_data, NULLVP, 0,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
return (exec_setup_stack(p, epp));
}
int
exec_linux_aout_prep_omagic(struct proc *p, struct exec_package *epp)
{
struct exec *execp = epp->ep_hdr;
long dsize, bsize, baddr;
epp->ep_taddr = LINUX_N_TXTADDR(*execp, OMAGIC);
epp->ep_tsize = execp->a_text;
epp->ep_daddr = LINUX_N_DATADDR(*execp, OMAGIC);
epp->ep_dsize = execp->a_data + execp->a_bss;
epp->ep_entry = execp->a_entry;
/* set up command for text and data segments */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
execp->a_text + execp->a_data, epp->ep_taddr, epp->ep_vp,
LINUX_N_TXTOFF(*execp, OMAGIC), VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
/* set up command for bss segment */
baddr = round_page(epp->ep_daddr + execp->a_data);
bsize = epp->ep_daddr + epp->ep_dsize - baddr;
if (bsize > 0)
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, bsize, baddr,
NULLVP, 0, VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
/*
* Make sure (# of pages) mapped above equals (vm_tsize + vm_dsize);
* obreak(2) relies on this fact. Both `vm_tsize' and `vm_dsize' are
* computed (in execve(2)) by rounding *up* `ep_tsize' and `ep_dsize'
* respectively to page boundaries.
* Compensate `ep_dsize' for the amount of data covered by the last
* text page.
*/
dsize = epp->ep_dsize + execp->a_text - round_page(execp->a_text);
epp->ep_dsize = (dsize > 0) ? dsize : 0;
return (exec_setup_stack(p, epp));
}
/*
* 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);
}