[src/trunk]: src/sys/arch/arc/arc Moved from /cvsroot/syssrc/sys/arch/pica/pi...

[soda <soda%NetBSD.org@localhost>]

details:   https://anonhg.NetBSD.org/src/rev/2c181358c217
branches:  trunk
changeset: 481118:2c181358c217
user:      soda <soda%NetBSD.org@localhost>
date:      Sun Jan 23 20:09:21 2000 +0000

description:
Moved from /cvsroot/syssrc/sys/arch/pica/pica/vm_machdep.c,v

diffstat:

 sys/arch/arc/arc/vm_machdep.c |  468 ++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 468 insertions(+), 0 deletions(-)

diffs (truncated from 472 to 300 lines):

diff -r ac0614bd2451 -r 2c181358c217 sys/arch/arc/arc/vm_machdep.c
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/sys/arch/arc/arc/vm_machdep.c     Sun Jan 23 20:09:21 2000 +0000
@@ -0,0 +1,468 @@
+/*     $NetBSD: vm_machdep.c,v 1.9 2000/01/23 20:09:21 soda Exp $      */
+
+/*
+ * Copyright (c) 1988 University of Utah.
+ * Copyright (c) 1992, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * 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.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * from: Utah Hdr: vm_machdep.c 1.21 91/04/06
+ *
+ *     from: @(#)vm_machdep.c  8.3 (Berkeley) 1/4/94
+ */
+
+
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/malloc.h>
+#include <sys/buf.h>
+#include <sys/vnode.h>
+#include <sys/user.h>
+
+#include <vm/vm.h>
+#include <vm/vm_kern.h>
+#include <vm/vm_page.h>
+#if 0
+#include <vm/vm_object.h>
+#endif
+
+#include <machine/pte.h>
+#include <machine/cpu.h>
+
+vm_offset_t kmem_alloc_wait_align();
+
+/*
+ * 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.
+ */
+cpu_fork(p1, p2)
+       register struct proc *p1, *p2;
+{
+       register struct user *up = p2->p_addr;
+       register pt_entry_t *pte;
+       register int i;
+       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;
+
+       /*
+        * Cache the PTEs for the user area in the machine dependent
+        * part of the proc struct so cpu_switch() can quickly map in
+        * the user struct and kernel stack. Note: if the virtual address
+        * translation changes (e.g. swapout) we have to update this.
+        */
+       pte = kvtopte(up);
+       for (i = 0; i < UPAGES; i++) {
+               p2->p_md.md_upte[i] = pte->pt_entry & ~(PG_G | PG_RO | PG_WIRED);
+               pte++;
+       }
+
+       /*
+        * Copy floating point state from the FP chip if this process
+        * has state stored there.
+        */
+       if (p1 == machFPCurProcPtr)
+               MachSaveCurFPState(p1);
+
+       /*
+        * 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.
+        */
+#ifdef DIAGNOSTIC
+       if (p1 != curproc && p1 != &proc0)
+               panic("cpu_fork: curproc");
+#endif
+       if (copykstack(up)) {
+               /*
+                * Return 1 in child.
+                */
+               return (1);
+       }
+       return (0);
+}
+
+/*
+ * Finish a swapin operation.
+ * We neded to update the cached PTEs for the user area in the
+ * machine dependent part of the proc structure.
+ */
+void
+cpu_swapin(p)
+       register struct proc *p;
+{
+       register struct user *up = p->p_addr;
+       register pt_entry_t *pte;
+       register int i;
+
+       /*
+        * Cache the PTEs for the user area in the machine dependent
+        * part of the proc struct so cpu_switch() can quickly map in
+        * the user struct and kernel stack.
+        */
+       pte = kvtopte(up);
+       for (i = 0; i < UPAGES; i++) {
+               p->p_md.md_upte[i] = pte->pt_entry & ~(PG_G | PG_RO | PG_WIRED);
+               pte++;
+       }
+}
+
+/*
+ * 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 switch_exit, which switches to a temporary
+ * pcb and stack and never returns.  We block memory allocation
+ * until switch_exit has made things safe again.
+ */
+void cpu_exit(p)
+       struct proc *p;
+{
+       extern struct proc *machFPCurProcPtr;
+
+       if (machFPCurProcPtr == p)
+               machFPCurProcPtr = (struct proc *)0;
+
+       vmspace_free(p->p_vmspace);
+
+       (void) splhigh();
+       kmem_free(kernel_map, (vm_offset_t)p->p_addr, ctob(UPAGES));
+       switch_exit();
+       /* NOTREACHED */
+}
+
+/*
+ * Dump the machine specific header information at the start of a core dump.
+ */
+cpu_coredump(p, vp, cred)
+       struct proc *p;
+       struct vnode *vp;
+       struct ucred *cred;
+{
+       extern struct proc *machFPCurProcPtr;
+
+       /*
+        * Copy floating point state from the FP chip if this process
+        * has state stored there.
+        */
+       if (p == machFPCurProcPtr)
+               MachSaveCurFPState(p);
+
+       return (vn_rdwr(UIO_WRITE, vp, (caddr_t)p->p_addr, ctob(UPAGES),
+           (off_t)0, UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, NULL,
+           p));
+}
+
+/*
+ * 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.
+ */
+pagemove(from, to, size)
+       register caddr_t from, to;
+       int size;
+{
+       register pt_entry_t *fpte, *tpte;
+
+       if (size % NBPG)
+               panic("pagemove");
+       fpte = kvtopte(from);
+       tpte = kvtopte(to);
+       if(((int)from & machCacheAliasMask) != ((int)to & machCacheAliasMask)) {
+               MachHitFlushDCache(from, size);
+       }
+       while (size > 0) {
+               MachTLBFlushAddr(from);
+               MachTLBUpdate(to, *fpte);
+               *tpte++ = *fpte;
+               fpte->pt_entry = PG_NV | PG_G;
+               fpte++;
+               size -= NBPG;
+               from += NBPG;
+               to += NBPG;
+       }
+}
+
+extern vm_map_t phys_map;
+
+/*
+ * Map a user I/O request into kernel virtual address space.
+ * Note: the pages are already locked by uvm_vslock(), so we
+ * do not need to pass an access_type to pmap_enter().   
+ */
+vmapbuf(bp)
+       register struct buf *bp;
+{
+       register caddr_t addr;
+       register vm_size_t sz;
+       struct proc *p;
+       int off;
+       vm_offset_t kva;
+       register vm_offset_t pa;
+
+       if ((bp->b_flags & B_PHYS) == 0)
+               panic("vmapbuf");
+       addr = bp->b_saveaddr = bp->b_un.b_addr;
+       off = (int)addr & PGOFSET;
+       p = bp->b_proc;
+       sz = round_page(bp->b_bcount + off);
+       kva = kmem_alloc_wait_align(phys_map, sz, (vm_size_t)addr & machCacheAliasMask);
+       bp->b_un.b_addr = (caddr_t) (kva + off);
+       sz = atop(sz);
+       while (sz--) {
+               pa = pmap_extract(vm_map_pmap(&p->p_vmspace->vm_map),
+                       (vm_offset_t)addr);
+               if (pa == 0)
+                       panic("vmapbuf: null page frame");
+               pmap_enter(vm_map_pmap(phys_map), kva, trunc_page(pa),
+                   VM_PROT_READ|VM_PROT_WRITE, TRUE, 0);
+               addr += PAGE_SIZE;
+               kva += PAGE_SIZE;
+       }
+}
+
+/*
+ * Unmap a previously-mapped user I/O request.
+ */
+vunmapbuf(bp)
+       register struct buf *bp;
+{
+       register caddr_t addr = bp->b_un.b_addr;
+       register vm_size_t sz;
+       vm_offset_t kva;
+
+       if ((bp->b_flags & B_PHYS) == 0)
+               panic("vunmapbuf");
+       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;
+       bp->b_saveaddr = NULL;
+}
+
+
+/*
+ *     SAVE_HINT:
+ *
+ *     Saves the specified entry as the hint for
+ *     future lookups.  Performs necessary interlocks.
+ */