void signal_frame(uint8_t *trapframe, uint32_t d0, uint32_t d1, uint32_t a0,
uint32_t a1)
{
extern void *udata_shadow;
uint8_t *usp = get_usp();
udata_ptr = udata_shadow;
uint16_t ccr = *(uint16_t *)trapframe;
uint32_t addr = *(uint32_t *)(trapframe + 2);
int err = 0;
/* Build the user stack frame */
/* FIXME: eventually we should put the trap frame details and trap
info into the frame */
usp -= 4;
err |= uputl(addr, usp);
usp -= 4;
err |= uputw(ccr, usp);
usp -= 2;
err |=uputl(a1, usp);
usp -= 4;
err |= uputl(a0, usp);
usp -= 4;
err |= uputl(d1, usp);
usp -= 4;
err |= uputl(d0, usp);
usp -= 4;
err |= uputl(udata.u_codebase + 4, usp);
set_usp(usp);
if (err) {
kprintf("%d: stack fault\n", udata.u_ptab->p_pid);
doexit(dump_core(SIGKILL));
}
/* Now patch up the kernel frame */
*(uint16_t *)trapframe = 0;
*(uint32_t *)(trapframe + 2) = (uint32_t)udata.u_sigvec[udata.u_cursig];
udata.u_sigvec[udata.u_cursig] = SIG_DFL;
udata.u_cursig = 0;
}
arg_t _execve(void)
{
/* Not ideal on stack */
struct binfmt_flat binflat;
inoptr ino;
char **nargv; /* In user space */
char **nenvp; /* In user space */
struct s_argblk *abuf, *ebuf;
int argc;
uint32_t bin_size; /* Will need to be bigger on some cpus */
uaddr_t progbase, top;
uaddr_t go;
uint32_t true_brk;
if (!(ino = n_open_lock(name, NULLINOPTR)))
return (-1);
if (!((getperm(ino) & OTH_EX) &&
(ino->c_node.i_mode & F_REG) &&
(ino->c_node.i_mode & (OWN_EX | OTH_EX | GRP_EX)))) {
udata.u_error = EACCES;
goto nogood;
}
setftime(ino, A_TIME);
udata.u_offset = 0;
udata.u_count = sizeof(struct binfmt_flat);
udata.u_base = (void *)&binflat;
udata.u_sysio = true;
readi(ino, 0);
if (udata.u_done != sizeof(struct binfmt_flat)) {
udata.u_error = ENOEXEC;
goto nogood;
}
/* FIXME: ugly - save this as valid_hdr modifies it */
true_brk = binflat.bss_end;
/* Hard coded for our 68K format. We don't quite use the ucLinux
names, we don't want to load a ucLinux binary in error! */
if (memcmp(binflat.magic, "bFLT", 4) || !valid_hdr(ino, &binflat)) {
udata.u_error = ENOEXEC;
goto nogood2;
}
/* Memory needed */
bin_size = binflat.bss_end + binflat.stack_size;
/* Overflow ? */
if (bin_size < binflat.bss_end) {
udata.u_error = ENOEXEC;
goto nogood2;
}
/* Gather the arguments, and put them in temporary buffers. */
abuf = (struct s_argblk *) tmpbuf();
/* Put environment in another buffer. */
ebuf = (struct s_argblk *) tmpbuf();
/* Read args and environment from process memory */
if (rargs(argv, abuf) || rargs(envp, ebuf))
goto nogood3;
/* This must be the last test as it makes changes if it works */
/* FIXME: need to update this to support split code/data and to fix
stack handling nicely */
/* FIXME: ENOMEM fix needs to go to 16bit ? */
if ((udata.u_error = pagemap_realloc(0, bin_size, 0)) != 0)
goto nogood3;
/* Core dump and ptrace permission logic */
#ifdef CONFIG_LEVEL_2
/* Q: should uid == 0 mean we always allow core */
if ((!(getperm(ino) & OTH_RD)) ||
(ino->c_node.i_mode & (SET_UID | SET_GID)))
udata.u_flags |= U_FLAG_NOCORE;
else
udata.u_flags &= ~U_FLAG_NOCORE;
#endif
udata.u_codebase = progbase = pagemap_base();
/* From this point on we are commmited to the exec() completing
so we can start writing over the old program */
uput(&binflat, (uint8_t *)progbase, sizeof(struct binfmt_flat));
/* setuid, setgid if executable requires it */
if (ino->c_node.i_mode & SET_UID)
udata.u_euid = ino->c_node.i_uid;
if (ino->c_node.i_mode & SET_GID)
udata.u_egid = ino->c_node.i_gid;
top = progbase + bin_size;
udata.u_top = top;
udata.u_ptab->p_top = top;
// kprintf("user space at %p\n", progbase);
// kprintf("top at %p\n", progbase + bin_size);
bin_size = binflat.reloc_start + 4 * binflat.reloc_count;
go = (uint32_t)progbase + binflat.entry;
close_on_exec();
/*
* Read in the rest of the program, block by block. We rely upon
* the optimization path in readi to spot this is a big move to user
* space and move it directly.
*/
if (bin_size > sizeof(struct binfmt_flat)) {
/* We copied the header already */
bin_size -= sizeof(struct binfmt_flat);
udata.u_base = (uint8_t *)progbase +
sizeof(struct binfmt_flat);
udata.u_count = bin_size;
udata.u_sysio = false;
readi(ino, 0);
if (udata.u_done != bin_size)
goto nogood4;
}
/* Header isn't counted in relocations */
relocate(&binflat, progbase, bin_size);
/* This may wipe the relocations */
uzero((uint8_t *)progbase + binflat.data_end,
binflat.bss_end - binflat.data_end + binflat.stack_size);
/* Use of brk eats into the stack allocation */
/* Use the temporary we saved (hack) as we mangled bss_end */
udata.u_break = udata.u_codebase + true_brk;
/* Turn off caught signals */
memset(udata.u_sigvec, 0, sizeof(udata.u_sigvec));
/* place the arguments, environment and stack at the top of userspace memory. */
/* Write back the arguments and the environment */
nargv = wargs(((char *) top - 4), abuf, &argc);
nenvp = wargs((char *) (nargv), ebuf, NULL);
/* Fill in udata.u_name with Program invocation name */
uget((void *) ugetl(nargv, NULL), udata.u_name, 8);
memcpy(udata.u_ptab->p_name, udata.u_name, 8);
tmpfree(abuf);
tmpfree(ebuf);
i_unlock_deref(ino);
/* Shove argc and the address of argv just below envp */
uputl((uint32_t) nargv, nenvp - 1);
uputl((uint32_t) argc, nenvp - 2);
// Set stack pointer for the program
udata.u_isp = nenvp - 2;
/*
* Sort of - it's a good way to deal with all the stupidity of
* random 68K platforms we will have to handle, and a nice place
* to stuff the signal trampoline 8)
*/
install_vdso();
// kprintf("Go = %p ISP = %p\n", go, udata.u_isp);
doexec(go);
nogood4:
/* Must not run userspace */
ssig(udata.u_ptab, SIGKILL);
nogood3:
tmpfree(abuf);
tmpfree(ebuf);
nogood2:
nogood:
i_unlock_deref(ino);
return (-1);
}
static uint8_t pushl(uint16_t **usp, uint32_t v)
{
(*usp) -= 2;
return uputl(v, *usp);
}
