/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * These routines simply provide wrappers around malloc(3C) and free(3C)
 * for now.  In the future we hope to provide a userland equivalent to
 * the kmem allocator, including cache allocators.
 */

#include <strings.h>
#include <stdlib.h>
#include <poll.h>

#ifdef _KMDB
#include <kmdb/kmdb_fault.h>
#endif
#include <mdb/mdb_debug.h>
#include <mdb/mdb_stdlib.h>
#include <mdb/mdb_frame.h>
#include <mdb/mdb_umem.h>
#include <mdb/mdb_err.h>
#include <mdb/mdb.h>

#define UMF_DEBUG                       0x1

#ifdef DEBUG
int mdb_umem_flags = UMF_DEBUG;
#else
int mdb_umem_flags = 0;
#endif

struct mdb_mblk {
        void *blk_addr;                 /* address of allocated block */
        size_t blk_size;                /* size of block in bytes */
        struct mdb_mblk *blk_next;      /* link to next block */
};

/*ARGSUSED*/
static void *
mdb_umem_handler(size_t nbytes, size_t align, uint_t flags)
{
#ifdef _KMDB

        /*
         * kmdb has a fixed, dedicated VA range in which to play.  This range
         * won't change size while the debugger is running, regardless of how
         * long we wait.  As a result, the only sensible course of action is
         * to fail the request.  If we're here, however, the request was made
         * with UM_SLEEP.  The caller is thus not expecting a NULL back.  We'll
         * have to fail the current dcmd set.
         */
        if (mdb.m_depth > 0) {
                warn("failed to allocate %lu bytes -- recovering\n",
                    (ulong_t)nbytes);

                kmdb_print_stack();

                longjmp(mdb.m_frame->f_pcb, MDB_ERR_NOMEM);
        }

#else

        /*
         * mdb, on the other hand, can afford to wait, as someone may actually
         * free something.
         */
        if (errno == EAGAIN) {
                void *ptr = NULL;
                char buf[64];

                (void) mdb_iob_snprintf(buf, sizeof (buf),
                    "[ sleeping for %lu bytes of free memory ... ]",
                    (ulong_t)nbytes);

                (void) mdb_iob_puts(mdb.m_err, buf);
                (void) mdb_iob_flush(mdb.m_err);

                do {
                        (void) poll(NULL, 0, 1000);
                        if (align != 0)
                                ptr = memalign(align, nbytes);
                        else
                                ptr = malloc(nbytes);
                } while (ptr == NULL && errno == EAGAIN);

                if (ptr != NULL)
                        return (ptr);

                (void) memset(buf, '\b', strlen(buf));
                (void) mdb_iob_puts(mdb.m_err, buf);
                (void) mdb_iob_flush(mdb.m_err);

                (void) memset(buf, ' ', strlen(buf));
                (void) mdb_iob_puts(mdb.m_err, buf);
                (void) mdb_iob_flush(mdb.m_err);

                (void) memset(buf, '\b', strlen(buf));
                (void) mdb_iob_puts(mdb.m_err, buf);
                (void) mdb_iob_flush(mdb.m_err);
        }
#endif

        die("failed to allocate %lu bytes -- terminating\n", (ulong_t)nbytes);

        /*NOTREACHED*/

        return (NULL);
}

static void
mdb_umem_gc_enter(void *ptr, size_t nbytes)
{
        mdb_mblk_t *blkp = mdb_alloc(sizeof (mdb_mblk_t), UM_SLEEP);

        blkp->blk_addr = ptr;
        blkp->blk_size = nbytes;
        blkp->blk_next = mdb.m_frame->f_mblks;

        mdb.m_frame->f_mblks = blkp;
}

/*
 * If we're compiled in debug mode, we use this function (gratuitously
 * stolen from kmem.c) to set uninitialized and freed regions to
 * special bit patterns.
 */
static void
mdb_umem_copy_pattern(uint32_t pattern, void *buf_arg, size_t size)
{
        /* LINTED - alignment of bufend */
        uint32_t *bufend = (uint32_t *)((char *)buf_arg + size);
        uint32_t *buf = buf_arg;

        while (buf < bufend - 3) {
                buf[3] = buf[2] = buf[1] = buf[0] = pattern;
                buf += 4;
        }

        while (buf < bufend)
                *buf++ = pattern;
}

void *
mdb_alloc_align(size_t nbytes, size_t align, uint_t flags)
{
        void *ptr;
        size_t obytes = nbytes;

        if (nbytes == 0 || nbytes > MDB_ALLOC_MAX)
                return (NULL);

        nbytes = (nbytes + sizeof (uint32_t) - 1) & ~(sizeof (uint32_t) - 1);
        if (nbytes < obytes || nbytes == 0)
                return (NULL);

        if (align != 0)
                ptr = memalign(align, nbytes);
        else
                ptr = malloc(nbytes);

        if (flags & UM_SLEEP) {
                while (ptr == NULL)
                        ptr = mdb_umem_handler(nbytes, align, flags);
        }

        if (ptr != NULL && (mdb_umem_flags & UMF_DEBUG) != 0)
                mdb_umem_copy_pattern(UMEM_UNINITIALIZED_PATTERN, ptr, nbytes);

        if (flags & UM_GC)
                mdb_umem_gc_enter(ptr, nbytes);

        return (ptr);
}

void *
mdb_alloc(size_t nbytes, uint_t flags)
{
        return (mdb_alloc_align(nbytes, 0, flags));
}

void *
mdb_zalloc(size_t nbytes, uint_t flags)
{
        void *ptr = mdb_alloc(nbytes, flags);

        if (ptr != NULL)
                bzero(ptr, nbytes);

        return (ptr);
}

void
mdb_free(void *ptr, size_t nbytes)
{
        ASSERT(ptr != NULL || nbytes == 0);

        nbytes = (nbytes + sizeof (uint32_t) - 1) & ~(sizeof (uint32_t) - 1);

        if (ptr != NULL) {
                if (mdb_umem_flags & UMF_DEBUG)
                        mdb_umem_copy_pattern(UMEM_FREE_PATTERN, ptr, nbytes);
                free(ptr);
        }
}

void
mdb_free_align(void *ptr, size_t nbytes)
{
        mdb_free(ptr, nbytes);
}

void
mdb_recycle(mdb_mblk_t **blkpp)
{
        mdb_mblk_t *blkp, *nblkp;

        for (blkp = *blkpp; blkp != NULL; blkp = nblkp) {
                mdb_dprintf(MDB_DBG_UMEM,
                    "garbage collect %p size %lu bytes\n", blkp->blk_addr,
                    (ulong_t)blkp->blk_size);

                nblkp = blkp->blk_next;
                mdb_free(blkp->blk_addr, blkp->blk_size);
                mdb_free(blkp, sizeof (mdb_mblk_t));
        }

        *blkpp = NULL;
}