pmap_kernel() is really kernel_pmap variable

[unix-history] / usr / src / sys / hp300 / hp300 / mem.c

/*
* Copyright (c) 1988 University of Utah.
* Copyright (c) 1982, 1986, 1990 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.
*
* %sccs.include.redist.c%
*
* from: Utah $Hdr: mem.c 1.14 90/10/12$
*
*      @(#)mem.c       7.9 (Berkeley) %G%
*/

/*
* Memory special file
*/

#include "param.h"
#include "conf.h"
#include "buf.h"
#include "systm.h"
#include "malloc.h"

#include "../include/cpu.h"

#include "vm/vm_param.h"
#include "vm/lock.h"
#include "vm/vm_prot.h"
#include "vm/pmap.h"

/*ARGSUSED*/
mmrw(dev, uio, flags)
       dev_t dev;
       struct uio *uio;
       int flags;
{
       register int o;
       register u_int c, v;
       register struct iovec *iov;
       int error = 0;
       caddr_t zbuf = NULL;
       extern u_int lowram;

       while (uio->uio_resid > 0 && error == 0) {
               iov = uio->uio_iov;
               if (iov->iov_len == 0) {
                       uio->uio_iov++;
                       uio->uio_iovcnt--;
                       if (uio->uio_iovcnt < 0)
                               panic("mmrw");
                       continue;
               }
               switch (minor(dev)) {

/* minor device 0 is physical memory */
               case 0:
                       v = uio->uio_offset;
#ifndef DEBUG
                       /* allow reads only in RAM (except for DEBUG) */
                       if (v >= 0xFFFFFFFC || v < lowram)
                               return (EFAULT);
#endif
                       pmap_enter(kernel_pmap, (vm_offset_t)vmmap,
                           trunc_page(v), uio->uio_rw == UIO_READ ?
                           VM_PROT_READ : VM_PROT_WRITE, TRUE);
                       o = (int)uio->uio_offset & PGOFSET;
                       c = (u_int)(NBPG - ((int)iov->iov_base & PGOFSET));
                       c = MIN(c, (u_int)(NBPG - o));
                       c = MIN(c, (u_int)iov->iov_len);
                       error = uiomove((caddr_t)&vmmap[o], (int)c, uio);
                       pmap_remove(kernel_pmap, (vm_offset_t)vmmap,
                           (vm_offset_t)&vmmap[NBPG]);
                       continue;

/* minor device 1 is kernel memory */
               case 1:
                       c = MIN(iov->iov_len, MAXPHYS);
                       if (!kernacc((caddr_t)uio->uio_offset, c,
                           uio->uio_rw == UIO_READ ? B_READ : B_WRITE))
                               return (EFAULT);
                       error = uiomove((caddr_t)uio->uio_offset, (int)c, uio);
                       continue;

/* minor device 2 is EOF/RATHOLE */
               case 2:
                       if (uio->uio_rw == UIO_WRITE)
                               uio->uio_resid = 0;
                       return (0);

/* minor device 12 (/dev/zero) is source of nulls on read, rathole on write */
               case 12:
                       if (uio->uio_rw == UIO_WRITE) {
                               c = iov->iov_len;
                               break;
                       }
                       if (zbuf == NULL) {
                               zbuf = (caddr_t)
                                   malloc(CLBYTES, M_TEMP, M_WAITOK);
                               bzero(zbuf, CLBYTES);
                       }
                       c = MIN(iov->iov_len, CLBYTES);
                       error = uiomove(zbuf, (int)c, uio);
                       continue;

               default:
                       return (ENXIO);
               }
               if (error)
                       break;
               iov->iov_base += c;
               iov->iov_len -= c;
               uio->uio_offset += c;
               uio->uio_resid -= c;
       }
       if (zbuf)
               free(zbuf, M_TEMP);
       return (error);
}