* Copyright (c) 1988 University of Utah.
* Copyright (c) 1992 The Regents of the University of California.
* This code is derived from software contributed to Berkeley by
* the Systems Programming Group of the University of Utah Computer
* Science Department and Ralph Campbell.
* %sccs.include.redist.c%
* from: Utah $Hdr: vm_machdep.c 1.21 91/04/06$
* @(#)vm_machdep.c 7.7 (Berkeley) %G%
* Finish a fork operation, with process p2 nearly set up.
* Copy and update the kernel stack and pcb, making the child
* ready to run, and marking it so that it can return differently
* than the parent. Returns 1 in the child process, 0 in the parent.
* We currently double-map the user area so that the stack is at the same
* address in each process; in the future we will probably relocate
* the frame pointers on the stack after copying.
register struct proc
*p1
, *p2
;
register struct user
*up
= p2
->p_addr
;
register pt_entry_t
*pte
;
extern struct proc
*machFPCurProcPtr
;
p2
->p_md
.md_regs
= up
->u_pcb
.pcb_regs
;
p2
->p_md
.md_flags
= p1
->p_md
.md_flags
& (MDP_FPUSED
| MDP_ULTRIX
);
* Convert the user struct virtual address to a physical one
* and cache it in the proc struct. Note: if the phyical address
* can change (due to memory compaction in kmem_alloc?),
* we will have to update things.
for (i
= 0; i
< UPAGES
; i
++) {
p2
->p_md
.md_upte
[i
] = pte
->pt_entry
& ~PG_G
;
* Copy floating point state from the FP chip if this process
* has state stored there.
if (p1
== machFPCurProcPtr
)
* Copy pcb and stack from proc p1 to p2.
* We do this as cheaply as possible, copying only the active
* part of the stack. The stack and pcb need to agree;
p2
->p_addr
->u_pcb
= p1
->p_addr
->u_pcb
;
/* cache segtab for ULTBMiss() */
p2
->p_addr
->u_pcb
.pcb_segtab
= (void *)p2
->p_vmspace
->vm_pmap
.pm_segtab
;
* Arrange for a non-local goto when the new process
* is started, to resume here, returning nonzero from setjmp.
panic("cpu_fork: curproc");
* cpu_exit is called as the last action during exit.
* We release the address space and machine-dependent resources,
* including the memory for the user structure and kernel stack.
* Once finished, we call swtch_exit, which switches to a temporary
* pcb and stack and never returns. We block memory allocation
* until swtch_exit has made things safe again.
extern struct proc
*machFPCurProcPtr
;
if (machFPCurProcPtr
== p
)
machFPCurProcPtr
= (struct proc
*)0;
vmspace_free(p
->p_vmspace
);
kmem_free(kernel_map
, (vm_offset_t
)p
->p_addr
, ctob(UPAGES
));
* Dump the machine specific header information at the start of a core dump.
cpu_coredump(p
, vp
, cred
)
extern struct proc
*machFPCurProcPtr
;
* Copy floating point state from the FP chip if this process
* has state stored there.
if (p
== machFPCurProcPtr
)
return (vn_rdwr(UIO_WRITE
, vp
, (caddr_t
)p
->p_addr
, ctob(UPAGES
),
(off_t
)0, UIO_SYSSPACE
, IO_NODELOCKED
|IO_UNIT
, cred
, (int *)NULL
,
* Move pages from one kernel virtual address to another.
* Both addresses are assumed to reside in the Sysmap,
* and size must be a multiple of CLSIZE.
register caddr_t from
, to
;
register pt_entry_t
*fpte
, *tpte
;
MachTLBUpdate(to
, *fpte
);
extern vm_map_t phys_map
;
* Map an IO request into kernel virtual address space. Requests fall into
* one of five catagories:
* B_PHYS|B_UAREA: User u-area swap.
* Address is relative to start of u-area (p_addr).
* B_PHYS|B_PAGET: User page table swap.
* Address is a kernel VA in usrpt (Usrptmap).
* B_PHYS|B_DIRTY: Dirty page push.
* Address is a VA in proc2's address space.
* B_PHYS|B_PGIN: Kernel pagein of user pages.
* Address is VA in user's address space.
* B_PHYS: User "raw" IO request.
* Address is VA in user's address space.
* All requests are (re)mapped into kernel VA space via the phys_map
if ((bp
->b_flags
& B_PHYS
) == 0)
addr
= bp
->b_saveaddr
= bp
->b_un
.b_addr
;
off
= (int)addr
& PGOFSET
;
sz
= round_page(bp
->b_bcount
+ off
);
kva
= kmem_alloc_wait(phys_map
, sz
);
bp
->b_un
.b_addr
= (caddr_t
) (kva
+ off
);
pa
= pmap_extract(vm_map_pmap(&p
->p_vmspace
->vm_map
),
panic("vmapbuf: null page frame");
pmap_enter(vm_map_pmap(phys_map
), kva
, trunc_page(pa
),
VM_PROT_READ
|VM_PROT_WRITE
, TRUE
);
* Free the io map PTEs associated with this IO operation.
* We also invalidate the TLB entries and restore the original b_addr.
register caddr_t addr
= bp
->b_un
.b_addr
;
if ((bp
->b_flags
& B_PHYS
) == 0)
sz
= round_page(bp
->b_bcount
+ ((int)addr
& PGOFSET
));
kva
= (vm_offset_t
)((int)addr
& ~PGOFSET
);
kmem_free_wakeup(phys_map
, kva
, sz
);
bp
->b_un
.b_addr
= bp
->b_saveaddr
;