/*
 * Copyright (c) 1993 Jan-Simon Pendry
 * Copyright (c) 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Jan-Simon Pendry.
 *
 * 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.
 *
 *      @(#)procfs_status.c     8.3 (Berkeley) 2/17/94
 *
 * $FreeBSD: src/sys/miscfs/procfs/procfs_map.c,v 1.24.2.1 2001/08/04 13:12:24 rwatson Exp $
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/uio.h>
#include <sys/proc.h>
#include <sys/vnode.h>
#include <sys/sbuf.h>
#include <sys/malloc.h>
#include <vfs/procfs/procfs.h>

#include <vm/vm.h>
#include <sys/lock.h>
#include <vm/pmap.h>
#include <vm/vm_map.h>
#include <vm/vm_page.h>
#include <vm/vm_object.h>

#include <machine/limits.h>

int
procfs_domap(struct proc *curp, struct lwp *lp, struct pfsnode *pfs,
             struct uio *uio)
{
        struct proc *p = lp->lwp_proc;
        ssize_t buflen = uio->uio_offset + uio->uio_resid;
        struct vnode *vp;
        char *fullpath, *freepath;
        int error;
        vm_map_t map = &p->p_vmspace->vm_map;
        vm_map_entry_t entry;
        struct sbuf *sb = NULL;
        unsigned int last_timestamp;

        if (uio->uio_rw != UIO_READ)
                return (EOPNOTSUPP);

        error = 0;

        if (uio->uio_offset < 0 || uio->uio_resid < 0 || buflen >= INT_MAX)
                return EINVAL;
        sb = sbuf_new (sb, NULL, buflen+1, 0);
        if (sb == NULL)
                return EIO;

        /*
         * Lock the map so we can access it.  Release the process token
         * to avoid unnecessary token stalls while we are processing the
         * map.
         */
        vm_map_lock_read(map);
        lwkt_reltoken(&p->p_token);

        RB_FOREACH(entry, vm_map_rb_tree, &map->rb_root) {
                vm_map_backing_t ba;
                vm_object_t obj;
                int ref_count, flags;
                vm_offset_t e_start, e_end;
                vm_eflags_t e_eflags;
                vm_prot_t e_prot;
                int resident;
                char *type;

                switch(entry->maptype) {
                case VM_MAPTYPE_NORMAL:
                        ba = &entry->ba;
                        break;
                case VM_MAPTYPE_UKSMAP:
                        ba = NULL;
                        break;
                default:
                        /* ignore entry */
                        continue;
                }

                e_eflags = entry->eflags;
                e_prot = entry->protection;
                e_start = entry->ba.start;
                e_end = entry->ba.end;

                /*
                 * Don't count resident pages, its impossible on 64-bit.
                 * A single mapping could be gigabytes or terrabytes.
                 */
                resident = -1;
#if 0
                pmap_t pmap = vmspace_pmap(p->p_vmspace);
                vm_offset_t addr;

                resident = 0;
                addr = entry->ba.start;
                while (addr < entry->ba.end) {
                        if (pmap_extract(pmap, addr, NULL))
                                resident++;
                        addr += PAGE_SIZE;
                }
#endif
                if (ba) {
                        while (ba->backing_ba)
                                ba = ba->backing_ba;
                        obj = ba->object;
                        if (obj)
                                vm_object_hold(obj);
                } else {
                        obj = NULL;
                }
                last_timestamp = map->timestamp;
                vm_map_unlock(map);

                freepath = NULL;
                fullpath = "-";
                flags = 0;
                ref_count = 0;

                if (obj) {
                        switch(obj->type) {
                        default:
                        case OBJT_DEFAULT:
                                type = "default";
                                vp = NULL;
                                break;
                        case OBJT_VNODE:
                                type = "vnode";
                                vp = obj->handle;
                                vref(vp);
                                break;
                        case OBJT_SWAP:
                                type = "swap";
                                vp = NULL;
                                break;
                        case OBJT_DEVICE:
                                type = "device";
                                vp = NULL;
                                break;
                        case OBJT_MGTDEVICE:
                                type = "mgtdevice";
                                vp = NULL;
                                break;
                        }
                        if (ba->object) {
                                flags = ba->object->flags;
                                ref_count = ba->object->ref_count;
                        }
                        vm_object_drop(obj);
                        if (vp) {
                                vn_fullpath(p, vp, &fullpath, &freepath, 1);
                                vrele(vp);
                        }
                } else {
                        switch(entry->maptype) {
                        case VM_MAPTYPE_UNSPECIFIED:
                                type = "unspec";
                                break;
                        case VM_MAPTYPE_NORMAL:
                                type = "none";
                                break;
                        case VM_MAPTYPE_SUBMAP:
                                type = "submap";
                                break;
                        case VM_MAPTYPE_UKSMAP:
                                type = "uksmap";
                                break;
                        default:
                                type = "unknown";
                                break;
                        }
                }

                /*
                 * format:
                 *  start, end, res, priv res, cow, access, type, (fullpath).
                 */
                error = sbuf_printf(sb,
#if LONG_BIT == 64
                          "0x%016lx 0x%016lx %d %d %p %s%s%s %d %d "
#else
                          "0x%08lx 0x%08lx %d %d %p %s%s%s %d %d "
#endif
                          "0x%04x %s%s %s %s\n",
                        (u_long)e_start, (u_long)e_end,
                        resident, -1, (ba ? ba->object : NULL),
                        (e_prot & VM_PROT_READ) ? "r" : "-",
                        (e_prot & VM_PROT_WRITE) ? "w" : "-",
                        (e_prot & VM_PROT_EXECUTE) ? "x" : "-",
                        ref_count, 0, flags,
                        (e_eflags & MAP_ENTRY_COW) ? "COW" : "NCOW",
                        (e_eflags & MAP_ENTRY_NEEDS_COPY) ?" NC" : " NNC",
                        type, fullpath);

                if (freepath != NULL) {
                        kfree(freepath, M_TEMP);
                        freepath = NULL;
                }

                vm_map_lock_read(map);
                if (error == -1) {
                        error = 0;
                        break;
                }

                if (last_timestamp != map->timestamp) {
                        vm_map_entry_t reentry;
                        vm_map_lookup_entry(map, e_start, &reentry);
                        entry = reentry;
                }
        }
        vm_map_unlock_read(map);
        if (sbuf_finish(sb) == 0)
                buflen = sbuf_len(sb);
        error = uiomove_frombuf(sbuf_data(sb), buflen, uio);
        sbuf_delete(sb);

        lwkt_gettoken(&p->p_token);     /* re-acquire */

        return error;
}

int
procfs_validmap(struct lwp *lp)
{
        return ((lp->lwp_proc->p_flags & P_SYSTEM) == 0);
}