/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <sys/signal.h>
#include <sys/systm.h>
#include <sys/user.h>
#include <sys/mman.h>
#include <sys/class.h>
#include <sys/proc.h>
#include <sys/procfs.h>
#include <sys/kmem.h>
#include <sys/cred.h>
#include <sys/archsystm.h>
#include <sys/machsystm.h>

#include <sys/reboot.h>
#include <sys/uadmin.h>

#include <sys/vfs.h>
#include <sys/vnode.h>
#include <sys/session.h>
#include <sys/ucontext.h>

#include <sys/dnlc.h>
#include <sys/var.h>
#include <sys/cmn_err.h>
#include <sys/debug.h>
#include <sys/thread.h>
#include <sys/vtrace.h>
#include <sys/consdev.h>
#include <sys/frame.h>
#include <sys/stack.h>
#include <sys/swap.h>
#include <sys/vmparam.h>
#include <sys/cpuvar.h>

#include <sys/privregs.h>

#include <vm/hat.h>
#include <vm/anon.h>
#include <vm/as.h>
#include <vm/page.h>
#include <vm/seg.h>
#include <vm/seg_kmem.h>
#include <vm/seg_map.h>
#include <vm/seg_vn.h>
#include <vm/vm_dep.h>

#include <sys/exec.h>
#include <sys/acct.h>
#include <sys/modctl.h>
#include <sys/tuneable.h>

#include <c2/audit.h>

#include <sys/trap.h>
#include <sys/sunddi.h>
#include <sys/bootconf.h>
#include <sys/memlist.h>
#include <sys/memlist_plat.h>
#include <sys/systeminfo.h>
#include <sys/promif.h>
#include <sys/prom_plat.h>

u_longlong_t    spec_hole_start = 0x80000000000ull;
u_longlong_t    spec_hole_end = 0xfffff80000000000ull;

pgcnt_t
num_phys_pages()
{
        pgcnt_t npages = 0;
        struct memlist *mp;

        for (mp = phys_install; mp != NULL; mp = mp->ml_next)
                npages += mp->ml_size >> PAGESHIFT;

        return (npages);
}


pgcnt_t
size_virtalloc(prom_memlist_t *avail, size_t nelems)
{

        u_longlong_t    start, end;
        pgcnt_t         allocpages = 0;
        uint_t          hole_allocated = 0;
        uint_t          i;

        for (i = 0; i < nelems - 1; i++) {

                start = avail[i].addr + avail[i].size;
                end = avail[i + 1].addr;

                /*
                 * Notes:
                 *
                 * (1) OBP on platforms with US I/II pre-allocates the hole
                 * represented by [spec_hole_start, spec_hole_end);
                 * pre-allocation is done to make this range unavailable
                 * for any allocation.
                 *
                 * (2) OBP on starcat always pre-allocates the hole similar to
                 * platforms with US I/II.
                 *
                 * (3) OBP on serengeti does _not_ pre-allocate the hole.
                 *
                 * (4) OBP ignores Spitfire Errata #21; i.e. it does _not_
                 * fill up or pre-allocate an additional 4GB on both sides
                 * of the hole.
                 *
                 * (5) kernel virtual range [spec_hole_start, spec_hole_end)
                 * is _not_ used on any platform including those with
                 * UltraSPARC III where there is no hole.
                 *
                 * Algorithm:
                 *
                 * Check if range [spec_hole_start, spec_hole_end) is
                 * pre-allocated by OBP; if so, subtract that range from
                 * allocpages.
                 */
                if (end >= spec_hole_end && start <= spec_hole_start)
                        hole_allocated = 1;

                allocpages += btopr(end - start);
        }

        if (hole_allocated)
                allocpages -= btop(spec_hole_end - spec_hole_start);

        return (allocpages);
}

/*
 * Returns the max contiguous physical memory present in the
 * memlist "physavail".
 */
uint64_t
get_max_phys_size(
        struct memlist  *physavail)
{
        uint64_t        max_size = 0;

        for (; physavail; physavail = physavail->ml_next) {
                if (physavail->ml_size > max_size)
                        max_size = physavail->ml_size;
        }

        return (max_size);
}


static void
more_pages(uint64_t base, uint64_t len)
{
        void kphysm_add();

        kphysm_add(base, len, 1);
}

static void
less_pages(uint64_t base, uint64_t len)
{
        uint64_t pa, end = base + len;
        extern int kcage_on;

        for (pa = base; pa < end; pa += PAGESIZE) {
                pfn_t pfnum;
                page_t *pp;

                pfnum = (pfn_t)(pa >> PAGESHIFT);
                if ((pp = page_numtopp_nolock(pfnum)) == NULL)
                        cmn_err(CE_PANIC, "missing pfnum %lx", pfnum);

                /*
                 * must break up any large pages that may have
                 * constituent pages being utilized for
                 * prom_alloc()'s. page_reclaim() can't handle
                 * large pages.
                 */
                if (pp->p_szc != 0)
                        page_boot_demote(pp);

                if (!PAGE_LOCKED(pp) && pp->p_lckcnt == 0) {
                        /*
                         * Ahhh yes, a prom page,
                         * suck it off the freelist,
                         * lock it, and hashin on prom_pages vp.
                         */
                        if (page_trylock(pp, SE_EXCL) == 0)
                                cmn_err(CE_PANIC, "prom page locked");

                        (void) page_reclaim(pp, NULL);
                        /*
                         * vnode offsets on the prom_ppages vnode
                         * are page numbers (gack) for >32 bit
                         * physical memory machines.
                         */
                        (void) page_hashin(pp, &promvp,
                            (offset_t)pfnum, NULL);

                        if (kcage_on) {
                                ASSERT(pp->p_szc == 0);
                                if (PP_ISNORELOC(pp) == 0) {
                                        PP_SETNORELOC(pp);
                                        PLCNT_XFER_NORELOC(pp);
                                }
                        }
                        (void) page_pp_lock(pp, 0, 1);
                }
        }
}

void
diff_memlists(struct memlist *proto, struct memlist *diff, void (*func)())
{
        uint64_t p_base, p_end, d_base, d_end;

        while (proto != NULL) {
                /*
                 * find diff item which may overlap with proto item
                 * if none, apply func to all of proto item
                 */
                while (diff != NULL &&
                    proto->ml_address >= diff->ml_address + diff->ml_size)
                        diff = diff->ml_next;
                if (diff == NULL) {
                        (*func)(proto->ml_address, proto->ml_size);
                        proto = proto->ml_next;
                        continue;
                }
                if (proto->ml_address == diff->ml_address &&
                    proto->ml_size == diff->ml_size) {
                        proto = proto->ml_next;
                        diff = diff->ml_next;
                        continue;
                }

                p_base = proto->ml_address;
                p_end = p_base + proto->ml_size;
                d_base = diff->ml_address;
                d_end = d_base + diff->ml_size;
                /*
                 * here p_base < d_end
                 * there are 5 cases
                 */

                /*
                 *      d_end
                 *      d_base
                 *  p_end
                 *  p_base
                 *
                 * apply func to all of proto item
                 */
                if (p_end <= d_base) {
                        (*func)(p_base, proto->ml_size);
                        proto = proto->ml_next;
                        continue;
                }

                /*
                 * ...
                 *      d_base
                 *  p_base
                 *
                 * normalize by applying func from p_base to d_base
                 */
                if (p_base < d_base)
                        (*func)(p_base, d_base - p_base);

                if (p_end <= d_end) {
                        /*
                         *      d_end
                         *  p_end
                         *      d_base
                         *  p_base
                         *
                         *      -or-
                         *
                         *      d_end
                         *  p_end
                         *  p_base
                         *      d_base
                         *
                         * any non-overlapping ranges applied above,
                         * so just continue
                         */
                        proto = proto->ml_next;
                        continue;
                }

                /*
                 *  p_end
                 *      d_end
                 *      d_base
                 *  p_base
                 *
                 *      -or-
                 *
                 *  p_end
                 *      d_end
                 *  p_base
                 *      d_base
                 *
                 * Find overlapping d_base..d_end ranges, and apply func
                 * where no overlap occurs.  Stop when d_base is above
                 * p_end
                 */
                for (p_base = d_end, diff = diff->ml_next; diff != NULL;
                    p_base = d_end, diff = diff->ml_next) {
                        d_base = diff->ml_address;
                        d_end = d_base + diff->ml_size;
                        if (p_end <= d_base) {
                                (*func)(p_base, p_end - p_base);
                                break;
                        } else
                                (*func)(p_base, d_base - p_base);
                }
                if (diff == NULL)
                        (*func)(p_base, p_end - p_base);
                proto = proto->ml_next;
        }
}

void
sync_memlists(struct memlist *orig, struct memlist *new)
{

        /*
         * Find pages allocated via prom by looking for
         * pages on orig, but no on new.
         */
        diff_memlists(orig, new, less_pages);

        /*
         * Find pages free'd via prom by looking for
         * pages on new, but not on orig.
         */
        diff_memlists(new, orig, more_pages);
}


/*
 * Find the page number of the highest installed physical
 * page and the number of pages installed (one cannot be
 * calculated from the other because memory isn't necessarily
 * contiguous).
 */
void
installed_top_size_memlist_array(
        prom_memlist_t *list,   /* base of array */
        size_t  nelems,         /* number of elements */
        pfn_t *topp,            /* return ptr for top value */
        pgcnt_t *sumpagesp)     /* return prt for sum of installed pages */
{
        pfn_t top = 0;
        pgcnt_t sumpages = 0;
        pfn_t highp;            /* high page in a chunk */
        size_t i;

        for (i = 0; i < nelems; list++, i++) {
                highp = (list->addr + list->size - 1) >> PAGESHIFT;
                if (top < highp)
                        top = highp;
                sumpages += (list->size >> PAGESHIFT);
        }

        *topp = top;
        *sumpagesp = sumpages;
}

/*
 * Copy a memory list.  Used in startup() to copy boot's
 * memory lists to the kernel.
 */
void
copy_memlist(
        prom_memlist_t  *src,
        size_t          nelems,
        struct memlist  **dstp)
{
        struct memlist *dst, *prev;
        size_t  i;

        dst = *dstp;
        prev = dst;

        for (i = 0; i < nelems; src++, i++) {
                dst->ml_address = src->addr;
                dst->ml_size = src->size;
                dst->ml_next = 0;
                if (prev == dst) {
                        dst->ml_prev = 0;
                        dst++;
                } else {
                        dst->ml_prev = prev;
                        prev->ml_next = dst;
                        dst++;
                        prev++;
                }
        }

        *dstp = dst;
}


static struct bootmem_props {
        prom_memlist_t  *ptr;
        size_t          nelems;         /* actual number of elements */
        size_t          maxsize;        /* max buffer */
} bootmem_props[3];

#define PHYSINSTALLED   0
#define PHYSAVAIL       1
#define VIRTAVAIL       2

/*
 * Comapct contiguous memory list elements
 */
static void
compact_promlist(struct bootmem_props *bpp)
{
        int i = 0, j;
        struct prom_memlist *pmp = bpp->ptr;

        for (;;) {
                if (pmp[i].addr + pmp[i].size == pmp[i+1].addr) {
                        pmp[i].size += pmp[i+1].size;
                        bpp->nelems--;
                        for (j = i + 1; j < bpp->nelems; j++)
                                pmp[j] = pmp[j+1];
                        pmp[j].addr = 0;
                } else
                        i++;
                if (i == bpp->nelems)
                        break;
        }
}

/*
 *  Sort prom memory lists into ascending order
 */
static void
sort_promlist(struct bootmem_props *bpp)
{
        int i, j, min;
        struct prom_memlist *pmp = bpp->ptr;
        struct prom_memlist temp;

        for (i = 0; i < bpp->nelems; i++) {
                min = i;

                for (j = i+1; j < bpp->nelems; j++)  {
                        if (pmp[j].addr < pmp[min].addr)
                                min = j;
                }

                if (i != min)  {
                        /* Swap pmp[i] and pmp[min] */
                        temp = pmp[min];
                        pmp[min] = pmp[i];
                        pmp[i] = temp;
                }
        }
}

static int max_bootlist_sz;

void
init_boot_memlists(void)
{
        size_t  size, len;
        char *start;
        struct bootmem_props *tmp;

        /*
         * These lists can get fragmented as the prom allocates
         * memory, so generously round up.
         */
        size = prom_phys_installed_len() + prom_phys_avail_len() +
            prom_virt_avail_len();
        size *= 4;
        size = roundup(size, PAGESIZE);
        start = prom_alloc(0, size, BO_NO_ALIGN);

        /*
         * Get physinstalled
         */
        tmp = &bootmem_props[PHYSINSTALLED];
        len = prom_phys_installed_len();
        if (len == 0)
                panic("no \"reg\" in /memory");
        tmp->nelems = len / sizeof (struct prom_memlist);
        tmp->maxsize = len;
        tmp->ptr = (prom_memlist_t *)start;
        start += len;
        size -= len;
        (void) prom_phys_installed((caddr_t)tmp->ptr);
        sort_promlist(tmp);
        compact_promlist(tmp);

        /*
         * Start out giving each half of available space
         */
        max_bootlist_sz = size;
        len = size / 2;
        tmp = &bootmem_props[PHYSAVAIL];
        tmp->maxsize = len;
        tmp->ptr = (prom_memlist_t *)start;
        start += len;

        tmp = &bootmem_props[VIRTAVAIL];
        tmp->maxsize = len;
        tmp->ptr = (prom_memlist_t *)start;
}


void
copy_boot_memlists(
    prom_memlist_t **physinstalled, size_t *physinstalled_len,
    prom_memlist_t **physavail, size_t *physavail_len,
    prom_memlist_t **virtavail, size_t *virtavail_len)
{
        size_t  plen, vlen, move = 0;
        struct bootmem_props *il, *pl, *vl;

        plen = prom_phys_avail_len();
        if (plen == 0)
                panic("no \"available\" in /memory");
        vlen = prom_virt_avail_len();
        if (vlen == 0)
                panic("no \"available\" in /virtual-memory");
        if (plen + vlen > max_bootlist_sz)
                panic("ran out of prom_memlist space");

        pl = &bootmem_props[PHYSAVAIL];
        vl = &bootmem_props[VIRTAVAIL];

        /*
         * re-adjust ptrs if needed
         */
        if (plen > pl->maxsize) {
                /* move virt avail up */
                move = plen - pl->maxsize;
                pl->maxsize = plen;
                vl->ptr += move / sizeof (struct prom_memlist);
                vl->maxsize -= move;
        } else if (vlen > vl->maxsize) {
                /* move virt avail down */
                move = vlen - vl->maxsize;
                vl->maxsize = vlen;
                vl->ptr -= move / sizeof (struct prom_memlist);
                pl->maxsize -= move;
        }

        pl->nelems = plen / sizeof (struct prom_memlist);
        vl->nelems = vlen / sizeof (struct prom_memlist);

        /* now we can retrieve the properties */
        (void) prom_phys_avail((caddr_t)pl->ptr);
        (void) prom_virt_avail((caddr_t)vl->ptr);

        /* .. and sort them */
        sort_promlist(pl);
        sort_promlist(vl);

        il = &bootmem_props[PHYSINSTALLED];
        *physinstalled = il->ptr;
        *physinstalled_len = il->nelems;

        *physavail = pl->ptr;
        *physavail_len = pl->nelems;

        *virtavail = vl->ptr;
        *virtavail_len = vl->nelems;
}


/*
 * Find the page number of the highest installed physical
 * page and the number of pages installed (one cannot be
 * calculated from the other because memory isn't necessarily
 * contiguous).
 */
void
installed_top_size(
        struct memlist *list,   /* pointer to start of installed list */
        pfn_t *topp,            /* return ptr for top value */
        pgcnt_t *sumpagesp)     /* return prt for sum of installed pages */
{
        pfn_t top = 0;
        pfn_t highp;            /* high page in a chunk */
        pgcnt_t sumpages = 0;

        for (; list; list = list->ml_next) {
                highp = (list->ml_address + list->ml_size - 1) >> PAGESHIFT;
                if (top < highp)
                        top = highp;
                sumpages += (uint_t)(list->ml_size >> PAGESHIFT);
        }

        *topp = top;
        *sumpagesp = sumpages;
}