/*-
 * 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, and code derived from software contributed to
 * Berkeley by William Jolitz.
 *
 * 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. 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: mem.c 1.13 89/10/08$
 *      from: @(#)mem.c 7.2 (Berkeley) 5/9/91
 * $FreeBSD: src/sys/i386/i386/mem.c,v 1.79.2.9 2003/01/04 22:58:01 njl Exp $
 */

/*
 * Memory special file
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/conf.h>
#include <sys/fcntl.h>
#include <sys/filio.h>
#include <sys/interrupt.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/memrange.h>
#include <sys/proc.h>
#include <sys/caps.h>
#include <sys/queue.h>
#include <sys/random.h>
#include <sys/signalvar.h>
#include <sys/uio.h>
#include <sys/vnode.h>
#include <sys/sysctl.h>

#include <sys/signal2.h>
#include <sys/spinlock2.h>

#include <vm/vm.h>
#include <vm/pmap.h>
#include <vm/vm_map.h>
#include <vm/vm_extern.h>


static  d_open_t        mmopen;
static  d_close_t       mmclose;
static  d_read_t        mmread;
static  d_write_t       mmwrite;
static  d_ioctl_t       mmioctl;
#if 0
static  d_mmap_t        memmmap;
#endif
static  d_kqfilter_t    mmkqfilter;
static int memuksmap(vm_map_backing_t ba, int op, cdev_t dev, vm_page_t fake);

#define CDEV_MAJOR 2
static struct dev_ops mem_ops = {
        { "mem", 0, D_MPSAFE | D_QUICK },
        .d_open =       mmopen,
        .d_close =      mmclose,
        .d_read =       mmread,
        .d_write =      mmwrite,
        .d_ioctl =      mmioctl,
        .d_kqfilter =   mmkqfilter,
#if 0
        .d_mmap =       memmmap,
#endif
        .d_uksmap =     memuksmap
};

static struct dev_ops mem_ops_mem = {
        { "mem", 0, D_MEM | D_MPSAFE | D_QUICK },
        .d_open =       mmopen,
        .d_close =      mmclose,
        .d_read =       mmread,
        .d_write =      mmwrite,
        .d_ioctl =      mmioctl,
        .d_kqfilter =   mmkqfilter,
#if 0
        .d_mmap =       memmmap,
#endif
        .d_uksmap =     memuksmap
};

static struct dev_ops mem_ops_noq = {
        { "mem", 0, D_MPSAFE },
        .d_open =       mmopen,
        .d_close =      mmclose,
        .d_read =       mmread,
        .d_write =      mmwrite,
        .d_ioctl =      mmioctl,
        .d_kqfilter =   mmkqfilter,
#if 0
        .d_mmap =       memmmap,
#endif
        .d_uksmap =     memuksmap
};

static int rand_bolt;
static caddr_t  zbuf;
static cdev_t   zerodev = NULL;
static struct lock mem_lock = LOCK_INITIALIZER("memlk", 0, 0);

MALLOC_DEFINE(M_MEMDESC, "memdesc", "memory range descriptors");
static int mem_ioctl (cdev_t, u_long, caddr_t, int, struct ucred *);
static int random_ioctl (cdev_t, u_long, caddr_t, int, struct ucred *);

struct mem_range_softc mem_range_softc;

static int seedenable;
SYSCTL_INT(_kern, OID_AUTO, seedenable, CTLFLAG_RW, &seedenable, 0, "");

static int
mmopen(struct dev_open_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        int error;

        switch (minor(dev)) {
        case 0:
        case 1:
                /*
                 * /dev/mem and /dev/kmem
                 */
                error = caps_priv_check(ap->a_cred, SYSCAP_RESTRICTEDROOT |
                                                    __SYSCAP_NOROOTTEST);
                if (error == 0) {
                        if (ap->a_oflags & FWRITE) {
                                if (securelevel > 0 || kernel_mem_readonly)
                                        error = EPERM;
                        }
                }
                break;
        case 3:
        case 4:
                /*
                 * /dev/random
                 * /dev/urandom
                 *
                 * Cannot be written to from RESTRICTEDROOT environments.
                 */
                error = 0;
                if (ap->a_oflags & FWRITE) {
                        error = caps_priv_check(ap->a_cred,
                                                SYSCAP_RESTRICTEDROOT |
                                                __SYSCAP_NOROOTTEST);
                }
                break;
        case 6:
                /*
                 * /dev/kpmap can only be opened for reading.
                 */
                error = 0;
                if (ap->a_oflags & FWRITE)
                        error = EPERM;
                break;
        case 14:
                /*
                 * /dev/io
                 */
                error = caps_priv_check(ap->a_cred, SYSCAP_RESTRICTEDROOT);
                if (error == 0) {
                        if (securelevel > 0 || kernel_mem_readonly)
                                error = EPERM;
                        else
                                error = cpu_set_iopl();
                }
                break;
        default:
                error = 0;
                break;
        }
        return (error);
}

static int
mmclose(struct dev_close_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        int error;

        switch (minor(dev)) {
        case 14:
                error = cpu_clr_iopl();
                break;
        default:
                error = 0;
                break;
        }
        return (error);
}


static int
mmrw(cdev_t dev, struct uio *uio, int flags)
{
        int o;
        u_int c;
        u_int poolsize;
        u_long v;
        struct iovec *iov;
        int error = 0;
        caddr_t buf = NULL;

        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)) {
                case 0:
                        /*
                         * minor device 0 is physical memory, /dev/mem 
                         */
                        v = uio->uio_offset;
                        v &= ~(long)PAGE_MASK;
                        pmap_kenter((vm_offset_t)ptvmmap, v);
                        o = (int)uio->uio_offset & PAGE_MASK;
                        c = (u_int)(PAGE_SIZE - ((uintptr_t)iov->iov_base & PAGE_MASK));
                        c = min(c, (u_int)(PAGE_SIZE - o));
                        c = min(c, (u_int)iov->iov_len);
                        error = uiomove((caddr_t)&ptvmmap[o], (int)c, uio);
                        pmap_kremove((vm_offset_t)ptvmmap);
                        continue;

                case 1: {
                        /*
                         * minor device 1 is kernel memory, /dev/kmem 
                         */
                        vm_offset_t saddr, eaddr;
                        int prot;

                        c = iov->iov_len;

                        /*
                         * Make sure that all of the pages are currently 
                         * resident so that we don't create any zero-fill
                         * pages.
                         */
                        saddr = trunc_page(uio->uio_offset);
                        eaddr = round_page(uio->uio_offset + c);
                        if (saddr > eaddr)
                                return EFAULT;

                        /*
                         * Make sure the kernel addresses are mapped.
                         * platform_direct_mapped() can be used to bypass
                         * default mapping via the page table (virtual kernels
                         * contain a lot of out-of-band data).
                         */
                        prot = VM_PROT_READ;
                        if (uio->uio_rw != UIO_READ)
                                prot |= VM_PROT_WRITE;
                        error = kvm_access_check(saddr, eaddr, prot);
                        if (error)
                                return (error);
                        error = uiomove((caddr_t)(vm_offset_t)uio->uio_offset,
                                        (int)c, uio);
                        continue;
                }
                case 2:
                        /*
                         * minor device 2 (/dev/null) is EOF/RATHOLE
                         */
                        if (uio->uio_rw == UIO_READ)
                                return (0);
                        c = iov->iov_len;
                        break;
                case 3:
                        /*
                         * minor device 3 (/dev/random) is source of filth
                         * on read, seeder on write
                         */
                        if (buf == NULL)
                                buf = kmalloc(PAGE_SIZE, M_TEMP, M_WAITOK);
                        c = min(iov->iov_len, PAGE_SIZE);
                        if (uio->uio_rw == UIO_WRITE) {
                                error = uiomove(buf, (int)c, uio);
                                if (error == 0 &&
                                    seedenable &&
                                    securelevel <= 0)
                                {
                                        error = add_buffer_randomness_src(buf, c, RAND_SRC_SEEDING);
                                } else if (error == 0) {
                                        error = EPERM;
                                }
                        } else {
                                poolsize = read_random(buf, c, 0);
                                if (poolsize == 0) {
                                        if (buf)
                                                kfree(buf, M_TEMP);
                                        if ((flags & IO_NDELAY) != 0)
                                                return (EWOULDBLOCK);
                                        return (0);
                                }
                                c = min(c, poolsize);
                                error = uiomove(buf, (int)c, uio);
                        }
                        continue;
                case 4:
                        /*
                         * minor device 4 (/dev/urandom) is source of muck
                         * on read, writes are disallowed.
                         */
                        c = min(iov->iov_len, PAGE_SIZE);
                        if (uio->uio_rw == UIO_WRITE) {
                                error = EPERM;
                                break;
                        }
                        if (CURSIG(curthread->td_lwp) != 0) {
                                /*
                                 * Use tsleep() to get the error code right.
                                 * It should return immediately.
                                 */
                                error = tsleep(&rand_bolt, PCATCH, "urand", 1);
                                if (error != 0 && error != EWOULDBLOCK)
                                        continue;
                        }
                        if (buf == NULL)
                                buf = kmalloc(PAGE_SIZE, M_TEMP, M_WAITOK);
                        poolsize = read_random(buf, c, 1);
                        c = min(c, poolsize);
                        error = uiomove(buf, (int)c, uio);
                        continue;
                /* case 5: read/write not supported, mmap only */
                /* case 6: read/write not supported, mmap only */
                case 12:
                        /*
                         * minor device 12 (/dev/zero) is source of nulls 
                         * on read, write are disallowed.
                         */
                        if (uio->uio_rw == UIO_WRITE) {
                                c = iov->iov_len;
                                break;
                        }
                        if (zbuf == NULL) {
                                zbuf = (caddr_t)kmalloc(PAGE_SIZE, M_TEMP,
                                    M_WAITOK | M_ZERO);
                        }
                        c = min(iov->iov_len, PAGE_SIZE);
                        error = uiomove(zbuf, (int)c, uio);
                        continue;
                default:
                        return (ENODEV);
                }
                if (error)
                        break;
                iov->iov_base = (char *)iov->iov_base + c;
                iov->iov_len -= c;
                uio->uio_offset += c;
                uio->uio_resid -= c;
        }
        if (buf)
                kfree(buf, M_TEMP);
        return (error);
}

static int
mmread(struct dev_read_args *ap)
{
        return(mmrw(ap->a_head.a_dev, ap->a_uio, ap->a_ioflag));
}

static int
mmwrite(struct dev_write_args *ap)
{
        return(mmrw(ap->a_head.a_dev, ap->a_uio, ap->a_ioflag));
}

/*******************************************************\
* allow user processes to MMAP some memory sections     *
* instead of going through read/write                   *
\*******************************************************/

static int user_kernel_mapping(vm_map_backing_t ba, int num,
                        vm_ooffset_t offset, vm_ooffset_t *resultp);

static int
memuksmap(vm_map_backing_t ba, int op, cdev_t dev, vm_page_t fake)
{
        vm_ooffset_t result;
        int error;
        struct lwp *lp;

        error = 0;

        switch(op) {
        case UKSMAPOP_ADD:
                /*
                 * We only need to track mappings for /dev/lpmap, all process
                 * mappings will be deleted when the process exits and we
                 * do not need to track kernel mappings.
                 */
                if (minor(dev) == 7) {
                        lp = ba->aux_info;
                        spin_lock(&lp->lwp_spin);
                        TAILQ_INSERT_TAIL(&lp->lwp_lpmap_backing_list,
                                          ba, entry);
                        spin_unlock(&lp->lwp_spin);
                }
                break;
        case UKSMAPOP_REM:
                /*
                 * We only need to track mappings for /dev/lpmap, all process
                 * mappings will be deleted when the process exits and we
                 * do not need to track kernel mappings.
                 */
                if (minor(dev) == 7) {
                        lp = ba->aux_info;
                        spin_lock(&lp->lwp_spin);
                        TAILQ_REMOVE(&lp->lwp_lpmap_backing_list, ba, entry);
                        spin_unlock(&lp->lwp_spin);
                }
                break;
        case UKSMAPOP_FAULT:
                switch (minor(dev)) {
                case 0:
                        /*
                         * minor device 0 is physical memory
                         */
                        fake->phys_addr = ptoa(fake->pindex);
                        break;
                case 1:
                        /*
                         * minor device 1 is kernel memory
                         */
                        fake->phys_addr = vtophys(ptoa(fake->pindex));
                        break;
                case 5:
                case 6:
                case 7:
                        /*
                         * minor device 5 is /dev/upmap (see sys/upmap.h)
                         * minor device 6 is /dev/kpmap (see sys/upmap.h)
                         * minor device 7 is /dev/lpmap (see sys/upmap.h)
                         */
                        result = 0;
                        error = user_kernel_mapping(ba,
                                                    minor(dev),
                                                    ptoa(fake->pindex),
                                                    &result);
                        fake->phys_addr = result;
                        break;
                default:
                        error = EINVAL;
                        break;
                }
                break;
        default:
                error = EINVAL;
                break;
        }
        return error;
}

static int
mmioctl(struct dev_ioctl_args *ap)
{
        cdev_t dev = ap->a_head.a_dev;
        int error;

        lockmgr(&mem_lock, LK_EXCLUSIVE);

        switch (minor(dev)) {
        case 0:
                error = mem_ioctl(dev, ap->a_cmd, ap->a_data,
                                  ap->a_fflag, ap->a_cred);
                break;
        case 3:
        case 4:
                error = random_ioctl(dev, ap->a_cmd, ap->a_data,
                                     ap->a_fflag, ap->a_cred);
                break;
        default:
                error = ENODEV;
                break;
        }

        lockmgr(&mem_lock, LK_RELEASE);

        return (error);
}

/*
 * Operations for changing memory attributes.
 *
 * This is basically just an ioctl shim for mem_range_attr_get
 * and mem_range_attr_set.
 */
static int 
mem_ioctl(cdev_t dev, u_long cmd, caddr_t data, int flags, struct ucred *cred)
{
        int nd, error = 0;
        struct mem_range_op *mo = (struct mem_range_op *)data;
        struct mem_range_desc *md;
        
        /* is this for us? */
        if ((cmd != MEMRANGE_GET) &&
            (cmd != MEMRANGE_SET))
                return (ENOTTY);

        /* any chance we can handle this? */
        if (mem_range_softc.mr_op == NULL)
                return (EOPNOTSUPP);

        /* do we have any descriptors? */
        if (mem_range_softc.mr_ndesc == 0)
                return (ENXIO);

        switch (cmd) {
        case MEMRANGE_GET:
                nd = imin(mo->mo_arg[0], mem_range_softc.mr_ndesc);
                if (nd > 0) {
                        md = (struct mem_range_desc *)
                                kmalloc(nd * sizeof(struct mem_range_desc),
                                       M_MEMDESC, M_WAITOK);
                        error = mem_range_attr_get(md, &nd);
                        if (!error)
                                error = copyout(md, mo->mo_desc, 
                                        nd * sizeof(struct mem_range_desc));
                        kfree(md, M_MEMDESC);
                } else {
                        nd = mem_range_softc.mr_ndesc;
                }
                mo->mo_arg[0] = nd;
                break;
                
        case MEMRANGE_SET:
                md = (struct mem_range_desc *)kmalloc(sizeof(struct mem_range_desc),
                                                    M_MEMDESC, M_WAITOK);
                error = copyin(mo->mo_desc, md, sizeof(struct mem_range_desc));
                /* clamp description string */
                md->mr_owner[sizeof(md->mr_owner) - 1] = 0;
                if (error == 0)
                        error = mem_range_attr_set(md, &mo->mo_arg[0]);
                kfree(md, M_MEMDESC);
                break;
        }
        return (error);
}

/*
 * Implementation-neutral, kernel-callable functions for manipulating
 * memory range attributes.
 */
int
mem_range_attr_get(struct mem_range_desc *mrd, int *arg)
{
        /* can we handle this? */
        if (mem_range_softc.mr_op == NULL)
                return (EOPNOTSUPP);

        if (*arg == 0) {
                *arg = mem_range_softc.mr_ndesc;
        } else {
                bcopy(mem_range_softc.mr_desc, mrd, (*arg) * sizeof(struct mem_range_desc));
        }
        return (0);
}

int
mem_range_attr_set(struct mem_range_desc *mrd, int *arg)
{
        /* can we handle this? */
        if (mem_range_softc.mr_op == NULL)
                return (EOPNOTSUPP);

        return (mem_range_softc.mr_op->set(&mem_range_softc, mrd, arg));
}

void
mem_range_AP_init(void)
{
        if (mem_range_softc.mr_op && mem_range_softc.mr_op->initAP)
                mem_range_softc.mr_op->initAP(&mem_range_softc);
}

static int 
random_ioctl(cdev_t dev, u_long cmd, caddr_t data, int flags, struct ucred *cred)
{
        int error;
        int intr;
        
        /*
         * Even inspecting the state is privileged, since it gives a hint
         * about how easily the randomness might be guessed.
         */
        error = 0;

        switch (cmd) {
        /* Really handled in upper layer */
        case FIOASYNC:
                break;
        case MEM_SETIRQ:
                intr = *(int16_t *)data;
                if ((error = caps_priv_check(cred, SYSCAP_RESTRICTEDROOT)) != 0)
                        break;
                if (intr < 0 || intr >= MAX_INTS)
                        return (EINVAL);
                register_randintr(intr);
                break;
        case MEM_CLEARIRQ:
                intr = *(int16_t *)data;
                if ((error = caps_priv_check(cred, SYSCAP_RESTRICTEDROOT)) != 0)
                        break;
                if (intr < 0 || intr >= MAX_INTS)
                        return (EINVAL);
                unregister_randintr(intr);
                break;
        case MEM_RETURNIRQ:
                error = ENOTSUP;
                break;
        case MEM_FINDIRQ:
                intr = *(int16_t *)data;
                if ((error = caps_priv_check(cred, SYSCAP_RESTRICTEDROOT)) != 0)
                        break;
                if (intr < 0 || intr >= MAX_INTS)
                        return (EINVAL);
                intr = next_registered_randintr(intr);
                if (intr == MAX_INTS)
                        return (ENOENT);
                *(u_int16_t *)data = intr;
                break;
        default:
                error = ENOTSUP;
                break;
        }
        return (error);
}

static int
mm_filter_read(struct knote *kn, long hint)
{
        return (1);
}

static int
mm_filter_write(struct knote *kn, long hint)
{
        return (1);
}

static void
dummy_filter_detach(struct knote *kn) {}

/* Implemented in kern_nrandom.c */
static struct filterops random_read_filtops =
        { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, dummy_filter_detach, random_filter_read };

static struct filterops mm_read_filtops =
        { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, dummy_filter_detach, mm_filter_read };

static struct filterops mm_write_filtops =
        { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, dummy_filter_detach, mm_filter_write };

static int
mmkqfilter(struct dev_kqfilter_args *ap)
{
        struct knote *kn = ap->a_kn;
        cdev_t dev = ap->a_head.a_dev;

        ap->a_result = 0;
        switch (kn->kn_filter) {
        case EVFILT_READ:
                switch (minor(dev)) {
                case 3:
                        kn->kn_fop = &random_read_filtops;
                        break;
                default:
                        kn->kn_fop = &mm_read_filtops;
                        break;
                }
                break;
        case EVFILT_WRITE:
                kn->kn_fop = &mm_write_filtops;
                break;
        default:
                ap->a_result = EOPNOTSUPP;
                return (0);
        }

        return (0);
}

int
iszerodev(cdev_t dev)
{
        return (zerodev == dev);
}

/*
 * /dev/lpmap, /dev/upmap, /dev/kpmap.
 */
static int
user_kernel_mapping(vm_map_backing_t ba, int num, vm_ooffset_t offset,
                    vm_ooffset_t *resultp)
{
        struct proc *p;
        struct lwp *lp;
        int error;
        int invfork;

        if (offset < 0)
                return (EINVAL);

        error = EINVAL;

        switch(num) {
        case 5:
                /*
                 * /dev/upmap - maps RW per-process shared user-kernel area.
                 */

                /*
                 * If this is a child currently in vfork the pmap is shared
                 * with the parent!  We need to actually set-up the parent's
                 * p_upmap, not the child's, and we need to set the invfork
                 * flag.  Userland will probably adjust its static state so
                 * it must be consistent with the parent or userland will be
                 * really badly confused.
                 *
                 * (this situation can happen when user code in vfork() calls
                 *  libc's getpid() or some other function which then decides
                 *  it wants the upmap).
                 */
                p = ba->aux_info;
                if (p == NULL)
                        break;
                if (p->p_flags & P_PPWAIT) {
                        p = p->p_pptr;
                        if (p == NULL)
                                return (EINVAL);
                        invfork = 1;
                } else {
                        invfork = 0;
                }

                /*
                 * Create the kernel structure as required, set the invfork
                 * flag if we are faulting in on a vfork().
                 */
                if (p->p_upmap == NULL)
                        proc_usermap(p, invfork);
                if (p->p_upmap && invfork)
                        p->p_upmap->invfork = invfork;

                /*
                 * Extract address for pmap
                 */
                if (p->p_upmap &&
                    offset < roundup2(sizeof(*p->p_upmap), PAGE_SIZE)) {
                        /* only good for current process */
                        *resultp = pmap_kextract((vm_offset_t)p->p_upmap +
                                                 offset);
                        error = 0;
                }
                break;
        case 6:
                /*
                 * /dev/kpmap - maps RO shared kernel global page
                 *
                 * Extract address for pmap
                 */
                if (kpmap &&
                    offset < roundup2(sizeof(*kpmap), PAGE_SIZE)) {
                        *resultp = pmap_kextract((vm_offset_t)kpmap + offset);
                        error = 0;
                }
                break;
        case 7:
                /*
                 * /dev/lpmap - maps RW per-thread shared user-kernel area.
                 */
                lp = ba->aux_info;
                if (lp == NULL)
                        break;

                /*
                 * Create the kernel structure as required
                 */
                if (lp->lwp_lpmap == NULL)
                        lwp_usermap(lp, -1);    /* second arg not yet XXX */

                /*
                 * Extract address for pmap
                 */
                if (lp->lwp_lpmap &&
                    offset < roundup2(sizeof(*lp->lwp_lpmap), PAGE_SIZE)) {
                        /* only good for current process */
                        *resultp = pmap_kextract((vm_offset_t)lp->lwp_lpmap +
                                                 offset);
                        error = 0;
                }
                break;
        default:
                break;
        }
        return error;
}

static void
mem_drvinit(void *unused)
{

        /* Initialise memory range handling */
        if (mem_range_softc.mr_op != NULL)
                mem_range_softc.mr_op->init(&mem_range_softc);

        make_dev(&mem_ops_mem, 0, UID_ROOT, GID_KMEM, 0640, "mem");
        make_dev(&mem_ops_mem, 1, UID_ROOT, GID_KMEM, 0640, "kmem");
        make_dev(&mem_ops, 2, UID_ROOT, GID_WHEEL, 0666, "null");
        make_dev(&mem_ops, 3, UID_ROOT, GID_WHEEL, 0644, "random");
        make_dev(&mem_ops, 4, UID_ROOT, GID_WHEEL, 0644, "urandom");
        make_dev(&mem_ops, 5, UID_ROOT, GID_WHEEL, 0666, "upmap");
        make_dev(&mem_ops, 6, UID_ROOT, GID_WHEEL, 0444, "kpmap");
        make_dev(&mem_ops, 7, UID_ROOT, GID_WHEEL, 0666, "lpmap");
        zerodev = make_dev(&mem_ops, 12, UID_ROOT, GID_WHEEL, 0666, "zero");
        make_dev(&mem_ops_noq, 14, UID_ROOT, GID_WHEEL, 0600, "io");
}

SYSINIT(memdev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE + CDEV_MAJOR, mem_drvinit,
    NULL);