/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <kmdb/kctl/kctl.h>
#include <kmdb/kctl/kctl_wr.h>
#include <kmdb/kmdb_kctl.h>
#include <kmdb/kmdb_kdi.h>
#include <kmdb/kmdb_auxv.h>
#include <mdb/mdb_errno.h>

#include <sys/sysmacros.h>
#include <sys/reboot.h>
#include <sys/atomic.h>
#include <sys/bootconf.h>
#include <sys/kmdb.h>
#include <sys/kobj.h>
#include <sys/kobj_impl.h>
#include <sys/promimpl.h>
#include <sys/kdi_impl.h>
#include <sys/ctf_api.h>
#include <vm/seg_kmem.h>

kctl_t kctl;

#define KCTL_EXECNAME           "/kernel/drv/kmdb"

#if defined(_LP64)
#define KCTL_MEM_GOALSZ         (20 * 1024 * 1024)
#else
#define KCTL_MEM_GOALSZ         (10 * 1024 * 1024)
#endif

/*
 * kmdb will call its own copies of the promif routines during
 * initialization.  As these routines are intended to be used when the
 * world is stopped, they don't attempt to grab the PROM lock.  Very
 * Bad Things could happen if kmdb called a prom routine while someone
 * else was calling the kernel's copy of another prom routine, so we
 * grab the PROM lock ourselves before we start initialization.
 */
#ifdef __sparc
#define KCTL_PROM_LOCK          promif_preprom()
#define KCTL_PROM_UNLOCK        promif_postprom()
#else
#define KCTL_PROM_LOCK
#define KCTL_PROM_UNLOCK
#endif

static int
kctl_init(void)
{
        if (kobj_kdi.kdi_version != KDI_VERSION) {
                kctl_warn("kmdb/kernel version mismatch (expected %d, "
                    "found %d)", KDI_VERSION, kobj_kdi.kdi_version);
                return (-1);
        }

        sema_init(&kctl.kctl_wr_avail_sem, 0, NULL, SEMA_DRIVER, NULL);
        mutex_init(&kctl.kctl_wr_lock, NULL, MUTEX_DRIVER, NULL);
        cv_init(&kctl.kctl_wr_cv, NULL, CV_DRIVER, NULL);
        mutex_init(&kctl.kctl_lock, NULL, MUTEX_DRIVER, NULL);

        kctl.kctl_execname = KCTL_EXECNAME; /* XXX get from modctl? */

        kctl.kctl_state = KCTL_ST_INACTIVE;

        kctl.kctl_dseg = kctl.kctl_mrbase = NULL;
        kctl.kctl_dseg_size = kctl.kctl_mrsize = 0;

        kctl_dmod_init();

        return (0);
}

static void
kctl_fini(void)
{
        kctl_dmod_fini();

        mutex_destroy(&kctl.kctl_lock);
        cv_destroy(&kctl.kctl_wr_cv);
        mutex_destroy(&kctl.kctl_wr_lock);
        sema_destroy(&kctl.kctl_wr_avail_sem);
}

static uint_t
kctl_set_state(uint_t state)
{
        uint_t ostate = kctl.kctl_state;

        /* forward progess only, please */
        if (state > ostate) {
                kctl_dprintf("new kctl state: %d", state);
                kctl.kctl_state = state;
        }

        return (ostate);
}

static int
kctl_boot_dseg_alloc(caddr_t dsegaddr, size_t dsegsz)
{
        /*
         * The Intel boot memory allocator will cleverly map us onto a 4M
         * page if we request the whole 4M Intel segment at once.  This
         * will break physical memory r/w, so we break the request into
         * chunks.  The allocator isn't smart enough to combine requests,
         * so it'll give us a bunch of 4k pages.
         */
        while (dsegsz >= 1024*1024) {
                size_t sz = MIN(dsegsz, 1024*1024);

                if (BOP_ALLOC(kctl.kctl_boot_ops, dsegaddr, sz, BO_NO_ALIGN) !=
                    dsegaddr)
                        return (-1);

                dsegaddr += sz;
                dsegsz -= sz;
        }

        return (0);
}

static int
kctl_dseg_alloc(caddr_t addr, size_t sz)
{
        ASSERT(((uintptr_t)addr & PAGEOFFSET) == 0);

        /* make sure there isn't something there already (like kadb) */
        if (hat_getpfnum(kas.a_hat, addr) != PFN_INVALID)
                return (EAGAIN);

        if (segkmem_xalloc(NULL, addr, sz, VM_NOSLEEP, 0, segkmem_page_create,
            NULL) == NULL)
                return (ENOMEM);

        return (0);
}

static void
kctl_dseg_free(caddr_t addr, size_t sz)
{
        ASSERT(((uintptr_t)addr & PAGEOFFSET) == 0);

        segkmem_free(NULL, addr, sz);
}

static void
kctl_memavail(void)
{
        size_t needed;
        caddr_t base;

        /*
         * We're now free to allocate the non-fixed portion of the debugger's
         * memory region.
         */

        needed = P2ROUNDUP(kctl.kctl_memgoalsz <= kctl.kctl_dseg_size ? 0 :
            kctl.kctl_memgoalsz - kctl.kctl_dseg_size, PAGESIZE);

        if (needed == 0)
                return;

        if ((base = kmem_zalloc(needed, KM_NOSLEEP)) == NULL) {
                /*
                 * If we're going to wedge the machine during debugger startup,
                 * at least let them know why it's going to wedge.
                 */
                cmn_err(CE_WARN, "retrying of kmdb allocation of 0x%lx bytes",
                    (ulong_t)needed);

                base = kmem_zalloc(needed, KM_SLEEP);
        }

        kdi_dvec->dv_memavail(base, needed);
        kctl.kctl_mrbase = base;
        kctl.kctl_mrsize = needed;
}

void
kctl_cleanup(void)
{
        uint_t state = kctl_set_state(KCTL_ST_DEACTIVATING);

        kctl_dprintf("cleaning up from state %d", state);

        ASSERT(kctl.kctl_boot_loaded == 0);

        switch (state) {
        case KCTL_ST_ACTIVE:
                boothowto &= ~RB_DEBUG;
                /* XXX there's a race here */
                kdi_dvec = NULL;
                /*FALLTHROUGH*/

        case KCTL_ST_DBG_ACTIVATED:
                KCTL_PROM_LOCK;
                kmdb_deactivate();
                KCTL_PROM_UNLOCK;
                /*FALLTHROUGH*/

        case KCTL_ST_THREAD_STARTED:
                if (curthread != kctl.kctl_wr_thr) {
                        kctl_wr_thr_stop();
                        kctl_wr_thr_join();
                }
                /*FALLTHROUGH*/

        case KCTL_ST_MOD_NOTIFIERS:
                kctl_mod_notify_unreg();
                /*FALLTHROUGH*/

        case KCTL_ST_KCTL_PREACTIVATED:
                kctl_depreactivate_isadep();
                /*FALLTHROUGH*/

        case KCTL_ST_INITIALIZED:
                /* There's no kmdb_fini */
        case KCTL_ST_DSEG_ALLOCED:
                kctl_dseg_free(kctl.kctl_dseg, kctl.kctl_dseg_size);

                if (kctl.kctl_mrbase != NULL)
                        kmem_free(kctl.kctl_mrbase, kctl.kctl_mrsize);
                /*FALLTHROUGH*/
        }

        kctl.kctl_state = KCTL_ST_INACTIVE;
}

static void
kctl_startup_modules(void)
{
        struct modctl *modp;

        /*
         * Normal module load and unload is now available.  Prior to this point,
         * we could only load modules, and that only when the debugger was being
         * initialized.
         *
         * We'll need to prepare the modules we've already loaded (if any) for
         * the brave new world in which boot is unmapped.
         */
        kctl_dmod_sync();

        /*
         * Process any outstanding loads or unloads and prepare for automatic
         * module loading and unloading.
         */
        (void) kctl_wr_process();

        kctl_mod_notify_reg();

        (void) kctl_set_state(KCTL_ST_MOD_NOTIFIERS);

        modp = &modules;
        do {
                kctl_mod_loaded(modp);
        } while ((modp = modp->mod_next) != &modules);
}

static void
kctl_startup_thread(void)
{
        /*
         * Create the worker thread, which will handle future requests from the
         * debugger.
         */
        kctl_wr_thr_start();

        (void) kctl_set_state(KCTL_ST_THREAD_STARTED);
}

static int
kctl_startup_boot(void)
{
        struct modctl_list *lp, **lpp;
        int rc;

        if (kctl_wr_process() < 0) {
                kctl_warn("kmdb: failed to load modules");
                return (-1);
        }

        mutex_enter(&mod_lock);

        for (lpp = kobj_linkmaps; *lpp != NULL; lpp++) {
                for (lp = *lpp; lp != NULL; lp = lp->modl_next) {
                        if ((rc = kctl_mod_decompress(lp->modl_modp)) != 0) {
                                kctl_warn("kmdb: failed to decompress CTF data "
                                    "for %s: %s", lp->modl_modp->mod_modname,
                                    ctf_errmsg(rc));
                        }
                }
        }

        mutex_exit(&mod_lock);

        return (0);
}

static int
kctl_startup_preactivate(void *romp, const char *cfg, const char **argv)
{
        kmdb_auxv_t kav;
        int rc;

        kctl_auxv_init(&kav, cfg, argv, romp);
        KCTL_PROM_LOCK;
        rc = kmdb_init(kctl.kctl_execname, &kav);
        KCTL_PROM_UNLOCK;
        kctl_auxv_fini(&kav);

        if (rc < 0)
                return (EMDB_KNOLOAD);

        (void) kctl_set_state(KCTL_ST_INITIALIZED);

        if (kctl_preactivate_isadep() != 0)
                return (EIO);

        (void) kctl_set_state(KCTL_ST_KCTL_PREACTIVATED);

        return (0);
}

static int
kctl_startup_activate(uint_t flags)
{
        kdi_debugvec_t *dvec;

        KCTL_PROM_LOCK;
        kmdb_activate(&dvec, flags);
        KCTL_PROM_UNLOCK;

        (void) kctl_set_state(KCTL_ST_DBG_ACTIVATED);

        /*
         * fill in a few remaining debugvec entries.
         */
        dvec->dv_kctl_modavail = kctl_startup_modules;
        dvec->dv_kctl_thravail = kctl_startup_thread;
        dvec->dv_kctl_memavail = kctl_memavail;

        kctl_activate_isadep(dvec);

        kdi_dvec = dvec;
        membar_producer();

        boothowto |= RB_DEBUG;

        (void) kctl_set_state(KCTL_ST_ACTIVE);

        return (0);
}

static int
kctl_state_check(uint_t state, uint_t ok_state)
{
        if (state == ok_state)
                return (0);

        if (state == KCTL_ST_INACTIVE)
                return (EMDB_KINACTIVE);
        else if (kctl.kctl_state > KCTL_ST_INACTIVE &&
            kctl.kctl_state < KCTL_ST_ACTIVE)
                return (EMDB_KACTIVATING);
        else if (kctl.kctl_state == KCTL_ST_ACTIVE)
                return (EMDB_KACTIVE);
        else if (kctl.kctl_state == KCTL_ST_DEACTIVATING)
                return (EMDB_KDEACTIVATING);
        else
                return (EINVAL);
}

int
kctl_deactivate(void)
{
        int rc;

        mutex_enter(&kctl.kctl_lock);

        if (kctl.kctl_boot_loaded) {
                rc = EMDB_KNOUNLOAD;
                goto deactivate_done;
        }

        if ((rc = kctl_state_check(kctl.kctl_state, KCTL_ST_ACTIVE)) != 0)
                goto deactivate_done;

        kmdb_kdi_set_unload_request();
        kmdb_kdi_kmdb_enter();

        /*
         * The debugger will pass the request to the work thread, which will
         * stop itself.
         */
        kctl_wr_thr_join();

deactivate_done:
        mutex_exit(&kctl.kctl_lock);

        return (rc);
}

/*
 * Called from krtld, this indicates that the user loaded kmdb at boot.  We
 * track activation states, but we don't attempt to clean up if activation
 * fails, because boot debugger load failures are fatal.
 *
 * Further complicating matters, various kernel routines, such as bcopy and
 * mutex_enter, assume the presence of some basic state.  On SPARC, it's the
 * presence of a valid curthread pointer.  On AMD64, it's a valid curcpu
 * pointer in GSBASE.  We set up temporary versions of these before beginning
 * activation, and tear them down when we're done.
 */
int
kctl_boot_activate(struct bootops *ops, void *romp, size_t memsz,
    const char **argv)
{
        void *old;

#ifdef __lint
        {
        /*
         * krtld does a name-based symbol lookup to find this routine.  It then
         * casts the address it gets, calling the result.  We want to make sure
         * that the call in krtld stays in sync with the prototype for this
         * function, so we define a type (kctl_boot_activate_f) that matches the
         * current prototype.  The following assignment ensures that the type
         * still matches the declaration, with lint as the enforcer.
         */
        kctl_boot_activate_f *kba = kctl_boot_activate;
        if (kba == NULL)        /* Make lint think kba is actually used */
                return (0);
        }
#endif

        old = kctl_boot_tmpinit();      /* Set up temporary state */

        ASSERT(ops != NULL);
        kctl.kctl_boot_ops = ops;       /* must be set before kctl_init */

        if (kctl_init() < 0)
                return (-1);

        kctl.kctl_boot_loaded = 1;

        kctl_dprintf("beginning kmdb initialization");

        if (memsz == 0)
                memsz = KCTL_MEM_GOALSZ;

        kctl.kctl_dseg = kdi_segdebugbase;
        kctl.kctl_dseg_size =
            memsz > kdi_segdebugsize ? kdi_segdebugsize : memsz;
        kctl.kctl_memgoalsz = memsz;

        if (kctl_boot_dseg_alloc(kctl.kctl_dseg, kctl.kctl_dseg_size) < 0) {
                kctl_warn("kmdb: failed to allocate %lu-byte debugger area at "
                    "%p", kctl.kctl_dseg_size, (void *)kctl.kctl_dseg);
                return (-1);
        }

        (void) kctl_set_state(KCTL_ST_DSEG_ALLOCED);

        if (kctl_startup_preactivate(romp, NULL, argv) != 0 ||
            kctl_startup_activate(KMDB_ACT_F_BOOT)) {
                kctl_warn("kmdb: failed to activate");
                return (-1);
        }

        if (kctl_startup_boot() < 0)
                return (-1);

        kctl_dprintf("finished with kmdb initialization");

        kctl_boot_tmpfini(old);

        kctl.kctl_boot_ops = NULL;

        return (0);
}

int
kctl_modload_activate(size_t memsz, const char *cfg, uint_t flags)
{
        int rc;

        mutex_enter(&kctl.kctl_lock);

        if ((rc = kctl_state_check(kctl.kctl_state, KCTL_ST_INACTIVE)) != 0) {
                if ((flags & KMDB_F_AUTO_ENTRY) && rc == EMDB_KACTIVE) {
                        kmdb_kdi_kmdb_enter();
                        rc = 0;
                }

                mutex_exit(&kctl.kctl_lock);
                return (rc);
        }

        kctl.kctl_flags = flags;

        if (memsz == 0)
                memsz = KCTL_MEM_GOALSZ;

        kctl.kctl_dseg = kdi_segdebugbase;
        kctl.kctl_dseg_size =
            memsz > kdi_segdebugsize ? kdi_segdebugsize : memsz;
        kctl.kctl_memgoalsz = memsz;

        if ((rc = kctl_dseg_alloc(kctl.kctl_dseg, kctl.kctl_dseg_size)) != 0)
                goto activate_fail;

        (void) kctl_set_state(KCTL_ST_DSEG_ALLOCED);

        if ((rc = kctl_startup_preactivate(NULL, cfg, NULL)) != 0)
                goto activate_fail;

        kctl_startup_modules();
        kctl_startup_thread();

        if ((rc = kctl_startup_activate(0)) != 0)
                goto activate_fail;

        kctl_memavail();        /* Must be after kdi_dvec is set */

        if (kctl.kctl_flags & KMDB_F_AUTO_ENTRY)
                kmdb_kdi_kmdb_enter();

        mutex_exit(&kctl.kctl_lock);
        return (0);

activate_fail:
        kctl_cleanup();
        mutex_exit(&kctl.kctl_lock);
        return (rc);
}

/*
 * This interface will be called when drv/kmdb loads.  When we get the call, one
 * of two things will have happened:
 *
 *  1. The debugger was loaded at boot.  We've progressed far enough into boot
 *     as to allow drv/kmdb to be loaded as a non-primary.  Invocation of this
 *     interface is the signal to the debugger that it can start allowing things
 *     like dmod loading and automatic CTF decompression - things which require
 *     the system services that have now been started.
 *
 *  2. The debugger was loaded after boot.  mdb opened /dev/kmdb, causing
 *     drv/kmdb to load, followed by misc/kmdb.  Nothing has been set up yet,
 *     so we need to initialize.  Activation will occur separately, so we don't
 *     have to worry about that.
 */
int
kctl_attach(dev_info_t *dip)
{
        kctl.kctl_drv_dip = dip;

        return (0);
}

int
kctl_detach(void)
{
        return (kctl.kctl_state == KCTL_ST_INACTIVE ? 0 : EBUSY);
}

static struct modlmisc modlmisc = {
        &mod_miscops,
        KMDB_VERSION
};

static struct modlinkage modlinkage = {
        MODREV_1,
        (void *)&modlmisc,
        NULL
};

/*
 * Invoked only when debugger is loaded via modload - not invoked when debugger
 * is loaded at boot.  kctl_boot_activate needs to call anything (aside from
 * mod_install) this function does.
 */
int
_init(void)
{
        if (kctl_init() < 0)
                return (EINVAL);

        return (mod_install(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}

int
_fini(void)
{
        kctl_fini();

        return (mod_remove(&modlinkage));
}