/*
* Finish a fork operation, with process p2 nearly set up.
* Copy and update the pcb, set up the stack so that the child
* ready to run and return to user mode.
*/
void
cpu_fork(register struct thread *td1,register struct proc *p2,
struct thread *td2,int flags)
{
register struct proc *p1;
struct pcb *pcb2;
p1 = td1->td_proc;
if ((flags & RFPROC) == 0)
return;
/* It is assumed that the vm_thread_alloc called
* cpu_thread_alloc() before cpu_fork is called.
*/
/* Point the pcb to the top of the stack */
pcb2 = td2->td_pcb;
/* Copy p1's pcb, note that in this case
* our pcb also includes the td_frame being copied
* too. The older mips2 code did an additional copy
* of the td_frame, for us that's not needed any
* longer (this copy does them both)
*/
bcopy(td1->td_pcb, pcb2, sizeof(*pcb2));
/* Point mdproc and then copy over td1's contents
* md_proc is empty for MIPS
*/
td2->td_md.md_flags = td1->td_md.md_flags & MDTD_FPUSED;
/*
* Set up return-value registers as fork() libc stub expects.
*/
td2->td_frame->v0 = 0;
td2->td_frame->v1 = 1;
td2->td_frame->a3 = 0;
if (td1 == PCPU_GET(fpcurthread))
MipsSaveCurFPState(td1);
pcb2->pcb_context[PCB_REG_RA] = (register_t)(intptr_t)fork_trampoline;
/* Make sp 64-bit aligned */
pcb2->pcb_context[PCB_REG_SP] = (register_t)(((vm_offset_t)td2->td_pcb &
~(sizeof(__int64_t) - 1)) - CALLFRAME_SIZ);
pcb2->pcb_context[PCB_REG_S0] = (register_t)(intptr_t)fork_return;
pcb2->pcb_context[PCB_REG_S1] = (register_t)(intptr_t)td2;
pcb2->pcb_context[PCB_REG_S2] = (register_t)(intptr_t)td2->td_frame;
pcb2->pcb_context[PCB_REG_SR] = mips_rd_status() &
(MIPS_SR_KX | MIPS_SR_UX | MIPS_SR_INT_MASK);
/*
* FREEBSD_DEVELOPERS_FIXME:
* Setup any other CPU-Specific registers (Not MIPS Standard)
* and/or bits in other standard MIPS registers (if CPU-Specific)
* that are needed.
*/
td2->td_md.md_tls = td1->td_md.md_tls;
td2->td_md.md_saved_intr = MIPS_SR_INT_IE;
td2->td_md.md_spinlock_count = 1;
#ifdef CPU_CNMIPS
if (td1->td_md.md_flags & MDTD_COP2USED) {
if (td1->td_md.md_cop2owner == COP2_OWNER_USERLAND) {
if (td1->td_md.md_ucop2)
octeon_cop2_save(td1->td_md.md_ucop2);
else
panic("cpu_fork: ucop2 is NULL but COP2 is enabled");
}
else {
if (td1->td_md.md_cop2)
octeon_cop2_save(td1->td_md.md_cop2);
else
panic("cpu_fork: cop2 is NULL but COP2 is enabled");
}
}
if (td1->td_md.md_cop2) {
td2->td_md.md_cop2 = octeon_cop2_alloc_ctx();
memcpy(td2->td_md.md_cop2, td1->td_md.md_cop2,
sizeof(*td1->td_md.md_cop2));
}
if (td1->td_md.md_ucop2) {
td2->td_md.md_ucop2 = octeon_cop2_alloc_ctx();
memcpy(td2->td_md.md_ucop2, td1->td_md.md_ucop2,
sizeof(*td1->td_md.md_ucop2));
}
td2->td_md.md_cop2owner = td1->td_md.md_cop2owner;
pcb2->pcb_context[PCB_REG_SR] |= MIPS_SR_PX | MIPS_SR_UX | MIPS_SR_KX | MIPS_SR_SX;
/* Clear COP2 bits for userland & kernel */
td2->td_frame->sr &= ~MIPS_SR_COP_2_BIT;
pcb2->pcb_context[PCB_REG_SR] &= ~MIPS_SR_COP_2_BIT;
#endif
}
/*
* Clear registers on exec
* $sp is set to the stack pointer passed in. $pc is set to the entry
* point given by the exec_package passed in, as is $t9 (used for PIC
* code by the MIPS elf abi).
*/
void
exec_setregs(struct thread *td, struct image_params *imgp, u_long stack)
{
bzero((caddr_t)td->td_frame, sizeof(struct trapframe));
/*
* The stack pointer has to be aligned to accommodate the largest
* datatype at minimum. This probably means it should be 16-byte
* aligned, but for now we're 8-byte aligning it.
*/
td->td_frame->sp = ((register_t) stack) & ~(sizeof(__int64_t) - 1);
/*
* If we're running o32 or n32 programs but have 64-bit registers,
* GCC may use stack-relative addressing near the top of user
* address space that, due to sign extension, will yield an
* invalid address. For instance, if sp is 0x7fffff00 then GCC
* might do something like this to load a word from 0x7ffffff0:
*
* addu sp, sp, 32768
* lw t0, -32528(sp)
*
* On systems with 64-bit registers, sp is sign-extended to
* 0xffffffff80007f00 and the load is instead done from
* 0xffffffff7ffffff0.
*
* To prevent this, we subtract 64K from the stack pointer here.
*
* For consistency, we should just always do this unless we're
* running n64 programs. For now, since we don't support
* COMPAT_FREEBSD32 on n64 kernels, we just do it unless we're
* running n64 kernels.
*/
#if !defined(__mips_n64)
td->td_frame->sp -= 65536;
#endif
td->td_frame->pc = imgp->entry_addr & ~3;
td->td_frame->t9 = imgp->entry_addr & ~3; /* abicall req */
td->td_frame->sr = MIPS_SR_KSU_USER | MIPS_SR_EXL | MIPS_SR_INT_IE |
(mips_rd_status() & MIPS_SR_INT_MASK);
#if defined(__mips_n32)
td->td_frame->sr |= MIPS_SR_PX;
#elif defined(__mips_n64)
td->td_frame->sr |= MIPS_SR_PX | MIPS_SR_UX | MIPS_SR_KX;
#endif
#ifdef CPU_CNMIPS
td->td_frame->sr |= MIPS_SR_COP_2_BIT | MIPS_SR_PX | MIPS_SR_UX |
MIPS_SR_KX | MIPS_SR_SX;
#endif
/*
* FREEBSD_DEVELOPERS_FIXME:
* Setup any other CPU-Specific registers (Not MIPS Standard)
* and/or bits in other standard MIPS registers (if CPU-Specific)
* that are needed.
*/
/*
* Set up arguments for the rtld-capable crt0:
* a0 stack pointer
* a1 rtld cleanup (filled in by dynamic loader)
* a2 rtld object (filled in by dynamic loader)
* a3 ps_strings
*/
td->td_frame->a0 = (register_t) stack;
td->td_frame->a1 = 0;
td->td_frame->a2 = 0;
td->td_frame->a3 = (register_t)imgp->ps_strings;
td->td_md.md_flags &= ~MDTD_FPUSED;
if (PCPU_GET(fpcurthread) == td)
PCPU_SET(fpcurthread, (struct thread *)0);
td->td_md.md_ss_addr = 0;
}
