/*
* Finish a fork operation, with lwp lp2 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(struct lwp *lp1, struct lwp *lp2, int flags)
{
struct pcb *pcb2;
if ((flags & RFPROC) == 0) {
if ((flags & RFMEM) == 0) {
/* unshare user LDT */
struct pcb *pcb1 = lp1->lwp_thread->td_pcb;
struct pcb_ldt *pcb_ldt = pcb1->pcb_ldt;
if (pcb_ldt && pcb_ldt->ldt_refcnt > 1) {
pcb_ldt = user_ldt_alloc(pcb1,pcb_ldt->ldt_len);
user_ldt_free(pcb1);
pcb1->pcb_ldt = pcb_ldt;
set_user_ldt(pcb1);
}
}
return;
}
#if NNPX > 0
/* Ensure that lp1's pcb is up to date. */
if (mdcpu->gd_npxthread == lp1->lwp_thread)
npxsave(lp1->lwp_thread->td_savefpu);
#endif
/*
* Copy lp1's PCB. This really only applies to the
* debug registers and FP state, but its faster to just copy the
* whole thing. Because we only save the PCB at switchout time,
* the register state may not be current.
*/
pcb2 = lp2->lwp_thread->td_pcb;
*pcb2 = *lp1->lwp_thread->td_pcb;
/*
* Create a new fresh stack for the new process.
* Copy the trap frame for the return to user mode as if from a
* syscall. This copies the user mode register values. The
* 16 byte offset saves space for vm86, and must match
* common_tss.esp0 (kernel stack pointer on entry from user mode)
*
* pcb_esp must allocate an additional call-return pointer below
* the trap frame which will be restored by cpu_restore from
* PCB_EIP, and the thread's td_sp pointer must allocate an
* additonal two worsd below the pcb_esp call-return pointer to
* hold the LWKT restore function pointer and eflags.
*
* The LWKT restore function pointer must be set to cpu_restore,
* which is our standard heavy weight process switch-in function.
* YYY eventually we should shortcut fork_return and fork_trampoline
* to use the LWKT restore function directly so we can get rid of
* all the extra crap we are setting up.
*/
lp2->lwp_md.md_regs = (struct trapframe *)((char *)pcb2 - 16) - 1;
bcopy(lp1->lwp_md.md_regs, lp2->lwp_md.md_regs, sizeof(*lp2->lwp_md.md_regs));
/*
* Set registers for trampoline to user mode. Leave space for the
* return address on stack. These are the kernel mode register values.
*/
pcb2->pcb_cr3 = vtophys(vmspace_pmap(lp2->lwp_proc->p_vmspace)->pm_pdir);
pcb2->pcb_edi = 0;
pcb2->pcb_esi = (int)fork_return; /* fork_trampoline argument */
pcb2->pcb_ebp = 0;
pcb2->pcb_esp = (int)lp2->lwp_md.md_regs - sizeof(void *);
pcb2->pcb_ebx = (int)lp2; /* fork_trampoline argument */
pcb2->pcb_eip = (int)fork_trampoline;
lp2->lwp_thread->td_sp = (char *)(pcb2->pcb_esp - sizeof(void *));
*(u_int32_t *)lp2->lwp_thread->td_sp = PSL_USER;
lp2->lwp_thread->td_sp -= sizeof(void *);
*(void **)lp2->lwp_thread->td_sp = (void *)cpu_heavy_restore;
/*
* pcb2->pcb_ldt: duplicated below, if necessary.
* pcb2->pcb_savefpu: cloned above.
* pcb2->pcb_flags: cloned above (always 0 here).
* pcb2->pcb_onfault: cloned above (always NULL here).
* pcb2->pcb_onfault_sp:cloned above (don't care)
*/
/*
* XXX don't copy the i/o pages. this should probably be fixed.
*/
pcb2->pcb_ext = NULL;
/* Copy the LDT, if necessary. */
if (pcb2->pcb_ldt != NULL) {
if (flags & RFMEM) {
pcb2->pcb_ldt->ldt_refcnt++;
} else {
pcb2->pcb_ldt = user_ldt_alloc(pcb2,
pcb2->pcb_ldt->ldt_len);
}
}
bcopy(&lp1->lwp_thread->td_tls, &lp2->lwp_thread->td_tls,
sizeof(lp2->lwp_thread->td_tls));
/*
* Now, cpu_switch() can schedule the new lwp.
* pcb_esp is loaded pointing to the cpu_switch() stack frame
* containing the return address when exiting cpu_switch.
* This will normally be to fork_trampoline(), which will have
* %ebx loaded with the new lwp's pointer. fork_trampoline()
* will set up a stack to call fork_return(lp, frame); to complete
* the return to user-mode.
*/
}
/*
* 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(struct thread *td1, struct proc *p2, struct thread *td2, int flags)
{
struct proc *p1;
struct pcb *pcb2;
struct mdproc *mdp1, *mdp2;
struct proc_ldt *pldt;
p1 = td1->td_proc;
if ((flags & RFPROC) == 0) {
if ((flags & RFMEM) == 0) {
/* unshare user LDT */
mdp1 = &p1->p_md;
mtx_lock(&dt_lock);
if ((pldt = mdp1->md_ldt) != NULL &&
pldt->ldt_refcnt > 1 &&
user_ldt_alloc(p1, 1) == NULL)
panic("could not copy LDT");
mtx_unlock(&dt_lock);
}
return;
}
/* Ensure that td1's pcb is up to date. */
fpuexit(td1);
update_pcb_bases(td1->td_pcb);
/* Point the pcb to the top of the stack */
pcb2 = get_pcb_td(td2);
td2->td_pcb = pcb2;
/* Copy td1's pcb */
bcopy(td1->td_pcb, pcb2, sizeof(*pcb2));
/* Properly initialize pcb_save */
pcb2->pcb_save = get_pcb_user_save_pcb(pcb2);
bcopy(get_pcb_user_save_td(td1), get_pcb_user_save_pcb(pcb2),
cpu_max_ext_state_size);
/* Point mdproc and then copy over td1's contents */
mdp2 = &p2->p_md;
bcopy(&p1->p_md, mdp2, sizeof(*mdp2));
/*
* Create a new fresh stack for the new process.
* Copy the trap frame for the return to user mode as if from a
* syscall. This copies most of the user mode register values.
*/
td2->td_frame = (struct trapframe *)td2->td_pcb - 1;
bcopy(td1->td_frame, td2->td_frame, sizeof(struct trapframe));
td2->td_frame->tf_rax = 0; /* Child returns zero */
td2->td_frame->tf_rflags &= ~PSL_C; /* success */
td2->td_frame->tf_rdx = 1;
/*
* If the parent process has the trap bit set (i.e. a debugger had
* single stepped the process to the system call), we need to clear
* the trap flag from the new frame unless the debugger had set PF_FORK
* on the parent. Otherwise, the child will receive a (likely
* unexpected) SIGTRAP when it executes the first instruction after
* returning to userland.
*/
if ((p1->p_pfsflags & PF_FORK) == 0)
td2->td_frame->tf_rflags &= ~PSL_T;
/*
* Set registers for trampoline to user mode. Leave space for the
* return address on stack. These are the kernel mode register values.
*/
pcb2->pcb_r12 = (register_t)fork_return; /* fork_trampoline argument */
pcb2->pcb_rbp = 0;
pcb2->pcb_rsp = (register_t)td2->td_frame - sizeof(void *);
pcb2->pcb_rbx = (register_t)td2; /* fork_trampoline argument */
pcb2->pcb_rip = (register_t)fork_trampoline;
/*-
* pcb2->pcb_dr*: cloned above.
* pcb2->pcb_savefpu: cloned above.
* pcb2->pcb_flags: cloned above.
* pcb2->pcb_onfault: cloned above (always NULL here?).
* pcb2->pcb_[fg]sbase: cloned above
*/
/* Setup to release spin count in fork_exit(). */
td2->td_md.md_spinlock_count = 1;
td2->td_md.md_saved_flags = PSL_KERNEL | PSL_I;
td2->td_md.md_invl_gen.gen = 0;
/* As an i386, do not copy io permission bitmap. */
pcb2->pcb_tssp = NULL;
/* New segment registers. */
set_pcb_flags_raw(pcb2, PCB_FULL_IRET);
/* Copy the LDT, if necessary. */
mdp1 = &td1->td_proc->p_md;
mdp2 = &p2->p_md;
if (mdp1->md_ldt == NULL) {
mdp2->md_ldt = NULL;
return;
}
mtx_lock(&dt_lock);
if (mdp1->md_ldt != NULL) {
if (flags & RFMEM) {
mdp1->md_ldt->ldt_refcnt++;
mdp2->md_ldt = mdp1->md_ldt;
bcopy(&mdp1->md_ldt_sd, &mdp2->md_ldt_sd, sizeof(struct
system_segment_descriptor));
} else {
mdp2->md_ldt = NULL;
mdp2->md_ldt = user_ldt_alloc(p2, 0);
if (mdp2->md_ldt == NULL)
panic("could not copy LDT");
amd64_set_ldt_data(td2, 0, max_ldt_segment,
(struct user_segment_descriptor *)
mdp1->md_ldt->ldt_base);
}
} else
mdp2->md_ldt = NULL;
mtx_unlock(&dt_lock);
/*
* Now, cpu_switch() can schedule the new process.
* pcb_rsp is loaded pointing to the cpu_switch() stack frame
* containing the return address when exiting cpu_switch.
* This will normally be to fork_trampoline(), which will have
* %ebx loaded with the new proc's pointer. fork_trampoline()
* will set up a stack to call fork_return(p, frame); to complete
* the return to user-mode.
*/
}
