ns/solaris/nsc_thread.c

/*
 * 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 <sys/types.h>
#include <sys/debug.h>
#include <sys/ksynch.h>
#include <sys/cmn_err.h>
#include <sys/kmem.h>
#include <sys/ddi.h>
#include <sys/errno.h>
#include "nsc_thread.h"

#ifdef DS_DDICT
#include "../contract.h"
#endif

#include "../nsctl.h"
#include "nskernd.h"
#include <sys/nsctl/nsctl.h>

#include <sys/sdt.h>        /* dtrace is S10 or later */


/*
 * Global data
 */
static nstset_t     *nst_sets;
static nsthread_t   *nst_pending;
static kmutex_t     nst_global_lock;    /* nst_sets, nst_pending */


/*
 * nst_kmem_xalloc
 *
 * Poll for memory.
 */
static void *
nst_kmem_xalloc(size_t size, int sec, void *(*alloc)(size_t, int))
{
    clock_t usec = sec * 1000000;
    void *p = NULL;

    while (usec > 0) {
        if ((p = (*alloc)(size, KM_NOSLEEP)) != NULL)
            return (p);

        delay(drv_usectohz((clock_t)NST_MEMORY_TIMEOUT));
        usec -= NST_MEMORY_TIMEOUT;
    }

    cmn_err(CE_WARN, "!nst_kmem_xalloc: failed to alloc %ld bytes", size);
    return (NULL);
}


#if 0
/* currently unused */
static void *
nst_kmem_alloc(size_t size, int sec)
{
    return (nst_kmem_xalloc(size, sec, kmem_alloc));
}
#endif


static void *
nst_kmem_zalloc(size_t size, int sec)
{
    return (nst_kmem_xalloc(size, sec, kmem_zalloc));
}


/*
 * Queue stuff that should be in the DDI.
 */

/*
 * nst_insque
 *
 * Insert entryp after predp in a doubly linked list.
 */
static void
nst_insque(nst_q_t *entryp, nst_q_t *predp)
{
    entryp->q_back = predp;
    entryp->q_forw = predp->q_forw;
    predp->q_forw = entryp;
    entryp->q_forw->q_back = entryp;
}
#ifndef DS_DDICT
#pragma inline(nst_insque)  /* compiler hint to inline this function */
#endif


/*
 * nst_remque
 *
 * Remove entryp from a doubly linked list.
 */
static void
nst_remque(nst_q_t *entryp)
{
    entryp->q_back->q_forw = entryp->q_forw;
    entryp->q_forw->q_back = entryp->q_back;
    entryp->q_forw = entryp->q_back = NULL;
}
#ifndef DS_DDICT
#pragma inline(nst_remque)  /* compiler hint to inline this function */
#endif


/*
 * nst_thread_init
 *
 * Initialise the dynamic part of a thread
 */
static void
nst_thread_init(nsthread_t *tp)
{
    ASSERT(MUTEX_HELD(&((tp->tp_set)->set_lock)));
    ASSERT(!(tp->tp_flag & NST_TF_INUSE));
    tp->tp_flag = NST_TF_INUSE;
    tp->tp_func = NULL;
    tp->tp_arg = NULL;
}
#ifndef DS_DDICT
#pragma inline(nst_thread_init) /* compiler hint to inline this function */
#endif


/*
 * nst_thread_alloc
 *
 * Return an nsthread from the free pool, NULL if none
 */
static nsthread_t *
nst_thread_alloc(nstset_t *set, const int sleep)
{
    nsthread_t *tp = NULL;

    mutex_enter(&set->set_lock);

    if (set->set_flag & NST_SF_KILL) {
        mutex_exit(&set->set_lock);
        DTRACE_PROBE1(nst_thread_alloc_err_kill, nstset_t *, set);
        return (NULL);
    }

    do {
        tp = (nsthread_t *)set->set_free.q_forw;
        if (tp != (nsthread_t *)&set->set_free)
            nst_remque(&tp->tp_link);
        else {
            tp = NULL;

            if (!sleep)
                break;

            set->set_res_cnt++;

            DTRACE_PROBE2(nst_thread_alloc_sleep, nstset_t *, set,
                int, set->set_res_cnt);

            cv_wait(&set->set_res_cv, &set->set_lock);

            DTRACE_PROBE1(nst_thread_alloc_wake, nstset_t *, set);

            set->set_res_cnt--;

            if (set->set_flag & NST_SF_KILL)
                break;
        }
    } while (tp == NULL);

    /* initialise the thread */

    if (tp != NULL) {
        nst_thread_init(tp);
        set->set_nlive++;
    }

    mutex_exit(&set->set_lock);

    return (tp);
}


/*
 * nst_thread_free
 *
 * Requeue a thread on the free or reuse pools.  Threads are always
 * queued to the tail of the list to prevent rapid recycling.
 *
 * Must be called with set->set_lock held.
 */
static void
nst_thread_free(nsthread_t *tp)
{
    nstset_t *set = tp->tp_set;

    if (!set)
        return;

    ASSERT(MUTEX_HELD(&set->set_lock));

    tp->tp_flag &= ~NST_TF_INUSE;
    if (tp->tp_flag & NST_TF_DESTROY) {
        /* add self to reuse pool */
        nst_insque(&tp->tp_link, set->set_reuse.q_back);
    } else {
        /* add self to free pool */
        nst_insque(&tp->tp_link, set->set_free.q_back);
        if (set->set_res_cnt > 0)
            cv_broadcast(&set->set_res_cv);
    }
}


/*
 * nst_thread_run
 *
 * The first function that a new thread runs on entry from user land.
 * This is the main thread function that handles thread work and death.
 */
static void
nst_thread_run(void *arg)
{
    nsthread_t *tp;
    nstset_t *set;
    int first = 1;

    mutex_enter(&nst_global_lock);

    /* check if this thread is still on the pending list */

    for (tp = nst_pending; tp; tp = tp->tp_chain) {
        if (tp == (nsthread_t *)arg) {
            break;
        }
    }

    if (!tp) {
        mutex_exit(&nst_global_lock);
        return;
    }

    if (!tp->tp_set) {
        mutex_exit(&nst_global_lock);
#ifdef DEBUG
        cmn_err(CE_WARN, "!nst_thread_run(%p): already dead?",
            (void *)tp);
#endif
        return;
    }

    /* check that the set is still on the list of sets */

    for (set = nst_sets; set; set = set->set_next) {
        if (set == tp->tp_set) {
            break;
        }
    }

    if (!set) {
        mutex_exit(&nst_global_lock);
#ifdef DEBUG
        cmn_err(CE_WARN, "!nst_thread_run(%p): no set?", (void *)tp);
#endif
        return;
    }

    mutex_enter(&set->set_lock);

    mutex_exit(&nst_global_lock);

    /*
     * Mark the parent.
     * The parent won't actually run until set->set_lock is dropped.
     */

    tp->tp_flag &= ~NST_TF_PENDING;
    cv_broadcast(&tp->tp_cv);

    /*
     * Main loop.
     */

    while (!(set->set_flag & NST_SF_KILL) &&
        !(tp->tp_flag & NST_TF_KILL)) {
        /*
         * On initial entry the caller will add this thread to
         * the free pool if required, there after the thread
         * must do it for itself.
         */

        if (first) {
            first = 0;
        } else {
            nst_thread_free(tp);
            set->set_nlive--;
        }

        DTRACE_PROBE1(nst_thread_run_sleep, nsthread_t *, tp);

        cv_wait(&tp->tp_cv, &set->set_lock);

        DTRACE_PROBE1(nst_thread_run_wake, nsthread_t *, tp);

        if ((set->set_flag & NST_SF_KILL) ||
            (tp->tp_flag & NST_TF_KILL)) {
            break;
        }

        mutex_exit(&set->set_lock);

        if (tp->tp_func) {
            (*tp->tp_func)(tp->tp_arg);
            tp->tp_func = 0;
            tp->tp_arg = 0;
        }
#ifdef DEBUG
        else {
            cmn_err(CE_WARN,
                "!nst_thread_run(%p): NULL function pointer",
                (void *)tp);
        }
#endif

        mutex_enter(&set->set_lock);
    }

    /* remove self from the free and/or reuse pools */
    if (tp->tp_link.q_forw != NULL || tp->tp_link.q_back != NULL) {
        ASSERT(tp->tp_link.q_forw != NULL &&
            tp->tp_link.q_back != NULL);
        nst_remque(&tp->tp_link);
    }

    set->set_nthread--;
    tp->tp_flag &= ~NST_TF_KILL;

    /* wake the context that is running nst_destroy() or nst_del_thread() */
    cv_broadcast(&set->set_kill_cv);

    mutex_exit(&set->set_lock);

    /* suicide */
}


/*
 * nst_thread_destroy
 *
 * Free up the kernel level resources.  The thread must already be
 * un-chained from the set, and the caller must not be the thread
 * itself.
 */
static void
nst_thread_destroy(nsthread_t *tp)
{
    if (!tp)
        return;

    ASSERT(tp->tp_chain == NULL);

    tp->tp_set = NULL;

    if (tp->tp_flag & NST_TF_INUSE) {
        cmn_err(CE_WARN, "!nst_thread_destroy(%p): still in use!",
            (void *)tp);
        /* leak the thread */
        return;
    }

    cv_destroy(&tp->tp_cv);
    kmem_free(tp, sizeof (*tp));
}


/*
 * nst_thread_create
 *
 * Create and return a new thread from a threadset.
 */
static nsthread_t *
nst_thread_create(nstset_t *set)
{
    nsthread_t *tp, **tpp;
    int rc;

    /* try and reuse a thread first */

    if (set->set_reuse.q_forw != &set->set_reuse) {
        mutex_enter(&set->set_lock);

        tp = (nsthread_t *)set->set_reuse.q_forw;
        if (tp != (nsthread_t *)&set->set_reuse)
            nst_remque(&tp->tp_link);
        else
            tp = NULL;

        mutex_exit(&set->set_lock);

        if (tp) {
            DTRACE_PROBE2(nst_thread_create_end, nstset_t *, set,
                nsthread_t *, tp);
            return (tp);
        }
    }

    /* create a thread using nskernd */

    tp = nst_kmem_zalloc(sizeof (*tp), 2);
    if (!tp) {
        DTRACE_PROBE1(nst_thread_create_err_mem, nstset_t *, set);
        return (NULL);
    }

    cv_init(&tp->tp_cv, NULL, CV_DRIVER, NULL);
    tp->tp_flag = NST_TF_PENDING;
    tp->tp_set = set;

    mutex_enter(&set->set_lock);

    if (set->set_flag & NST_SF_KILL) {
        mutex_exit(&set->set_lock);
        nst_thread_destroy(tp);
#ifdef DEBUG
        cmn_err(CE_WARN, "!nst_thread_create: called during destroy");
#endif
        DTRACE_PROBE2(nst_thread_create_err_kill, nstset_t *, set,
            nsthread_t *, tp);
        return (NULL);
    }

    set->set_pending++;

    mutex_exit(&set->set_lock);

    mutex_enter(&nst_global_lock);

    tp->tp_chain = nst_pending;
    nst_pending = tp;

    mutex_exit(&nst_global_lock);

    DTRACE_PROBE2(nst_dbg_thr_create_proc_start, nstset_t *, set,
        nsthread_t *, tp);

    rc = nsc_create_process(nst_thread_run, tp, 0);

    DTRACE_PROBE2(nst_dbg_thr_create_proc_end, nstset_t *, set,
        nsthread_t *, tp);

    if (!rc) {
        /*
         * wait for child to start and check in.
         */

        mutex_enter(&set->set_lock);

        while (tp->tp_flag & NST_TF_PENDING)
            cv_wait(&tp->tp_cv, &set->set_lock);

        mutex_exit(&set->set_lock);
    }

    /*
     * remove from pending chain.
     */

    mutex_enter(&nst_global_lock);

    for (tpp = &nst_pending; (*tpp); tpp = &((*tpp)->tp_chain)) {
        if (*tpp == tp) {
            *tpp = tp->tp_chain;
            tp->tp_chain = NULL;
            break;
        }
    }

    mutex_exit(&nst_global_lock);

    /*
     * Check for errors and return if required.
     */

    mutex_enter(&set->set_lock);

    set->set_pending--;

    if (rc ||
        (set->set_flag & NST_SF_KILL) ||
        (set->set_nthread + 1) > USHRT_MAX) {
        if (rc == 0) {
            /*
             * Thread is alive, and needs to be woken and killed.
             */
            tp->tp_flag |= NST_TF_KILL;
            cv_broadcast(&tp->tp_cv);

            while (tp->tp_flag & NST_TF_KILL)
                cv_wait(&set->set_kill_cv, &set->set_lock);
        }
        mutex_exit(&set->set_lock);

        nst_thread_destroy(tp);
#ifdef DEBUG
        cmn_err(CE_WARN,
            "!nst_thread_create: error (rc %d, set_flag %x, "
            "set_nthread %d)", rc, set->set_flag, set->set_nthread);
#endif
        DTRACE_PROBE2(nst_thread_create_err_proc, nstset_t *, set,
            nsthread_t *, tp);

        return (NULL);
    }

    /*
     * Move into set proper.
     */

    tp->tp_chain = set->set_chain;
    set->set_chain = tp;
    set->set_nthread++;

    mutex_exit(&set->set_lock);

    return (tp);
}


/*
 * nst_create
 *
 * Start a new thread from a thread set, returning the
 * address of the thread, or NULL on failure.
 *
 * All threads are created detached.
 *
 * Valid flag values:
 *
 *      NST_CREATE      - create a new thread rather than using one
 *                        from the threadset.  Once the thread
 *                        completes it will not be added to the active
 *                        portion of the threadset, but will be cached
 *                        on the reuse chain, and so is available for
 *                        subsequent NST_CREATE or nst_add_thread()
 *            operations.
 *
 *  NST_SLEEP   - wait for a thread to be available instead of
 *            returning NULL.  Has no meaning with NST_CREATE.
 *
 * Returns a pointer to the new thread, or NULL.
 */
nsthread_t *
nst_create(nstset_t *set, void (*func)(), blind_t arg, int flags)
{
    nsthread_t *tp = NULL;

    if (!set)
        return (NULL);

    if (set->set_flag & NST_SF_KILL) {
        DTRACE_PROBE1(nst_create_err_kill, nstset_t *, set);
        return (NULL);
    }

    if (flags & NST_CREATE) {
        /* get new thread */

        if ((tp = nst_thread_create(set)) == NULL)
            return (NULL);

        /* initialise the thread */

        mutex_enter(&set->set_lock);
        nst_thread_init(tp);
        tp->tp_flag |= NST_TF_DESTROY;
        set->set_nlive++;
        mutex_exit(&set->set_lock);
    } else {
        if (!(tp = nst_thread_alloc(set, (flags & NST_SLEEP))))
            return (NULL);
    }

    /* set thread running */

    tp->tp_func = func;
    tp->tp_arg = arg;

    mutex_enter(&set->set_lock);
    cv_broadcast(&tp->tp_cv);
    mutex_exit(&set->set_lock);

    return (tp);
}


/*
 * nst_destroy
 *
 * Destroy a thread set created by nst_init(). It is the
 * caller's responsibility to ensure that all prior thread
 * calls have completed prior to this call and that the
 * caller is not executing from within thread context.
 */
void
nst_destroy(nstset_t *set)
{
    nsthread_t *tp, *ntp;
    nstset_t *sp, **spp;

    if (!set)
        return;

    mutex_enter(&nst_global_lock);

    for (sp = nst_sets; sp; sp = sp->set_next) {
        if (sp == set) {
            break;
        }
    }

    if (!sp) {
        mutex_exit(&nst_global_lock);
#ifdef DEBUG
        cmn_err(CE_WARN, "!nst_destroy(%p): no set?", (void *)set);
#endif
        DTRACE_PROBE1(nst_destroy_err_noset, nstset_t *, set);
        return;
    }

    mutex_enter(&set->set_lock);

    mutex_exit(&nst_global_lock);

    if (set->set_flag & NST_SF_KILL) {
        /*
         * Wait for a pending destroy to complete
         */

#ifdef DEBUG
        cmn_err(CE_WARN,
            "!nst_destroy(%p): duplicate destroy of set", (void *)set);
#endif

        set->set_destroy_cnt++;
        (void) cv_wait_sig(&set->set_destroy_cv, &set->set_lock);
        set->set_destroy_cnt--;

        mutex_exit(&set->set_lock);

        DTRACE_PROBE1(nst_destroy_end, nstset_t *, set);

        return;
    }

    set->set_flag |= NST_SF_KILL;

    /* Wake all threads in nst_create(NST_SLEEP) */
    cv_broadcast(&set->set_res_cv);

    /*
     * Wake all the threads chained in the set.
     */

    for (tp = set->set_chain; tp; tp = tp->tp_chain)
        cv_broadcast(&tp->tp_cv);

    /* Wait for the threads to exit */

    while ((set->set_free.q_forw != &set->set_free) ||
        (set->set_reuse.q_forw != &set->set_reuse))
        cv_wait(&set->set_kill_cv, &set->set_lock);

    /* Unchain and destroy all the threads in the set */

    tp = set->set_chain;
    set->set_chain = 0;

    while (tp) {
        ntp = tp->tp_chain;
        tp->tp_chain = 0;

        nst_thread_destroy(tp);

        tp = ntp;
    }

    mutex_exit(&set->set_lock);

    mutex_enter(&nst_global_lock);

    /* remove the set from the chain */

    for (spp = &nst_sets; *spp; spp = &((*spp)->set_next)) {
        if (*spp == set) {
            *spp = set->set_next;
            set->set_next = NULL;
            break;
        }
    }

    mutex_exit(&nst_global_lock);

    mutex_enter(&set->set_lock);

#ifdef DEBUG
    if (set->set_nthread != 0) {
        cmn_err(CE_WARN, "!nst_destroy(%p): nthread != 0 (%d)",
            (void *)set, set->set_nthread);
    }
#endif

    /* Allow any waiters (above) to continue */

    cv_broadcast(&set->set_destroy_cv);

    while (set->set_destroy_cnt > 0 || set->set_pending > 0 ||
        set->set_res_cnt > 0) {
        mutex_exit(&set->set_lock);
        delay(drv_usectohz((clock_t)NST_KILL_TIMEOUT));
        mutex_enter(&set->set_lock);
    }

    mutex_exit(&set->set_lock);

    if (set->set_nthread != 0) {
        /* leak the set control structure */

        DTRACE_PROBE1(nst_destroy_end, nstset_t *, set);

        return;
    }

    cv_destroy(&set->set_res_cv);
    cv_destroy(&set->set_kill_cv);
    cv_destroy(&set->set_destroy_cv);
    mutex_destroy(&set->set_lock);
    kmem_free(set, sizeof (*set));

}


/*
 * nst_add_thread
 *
 * Add more threads into an existing thread set.
 * Returns the number successfully added.
 */
int
nst_add_thread(nstset_t *set, int nthread)
{
    nsthread_t *tp;
    int i;

    if (!set || nthread < 1) {
#ifdef DEBUG
        cmn_err(CE_WARN,
            "!nst_add_thread(%p, %d) - bad args", (void *)set, nthread);
#endif
        return (0);
    }

    for (i = 0; i < nthread; i++) {
        /* get new thread */

        if ((tp = nst_thread_create(set)) == NULL)
            break;

        /* add to free list */

        mutex_enter(&set->set_lock);
        nst_thread_free(tp);
        mutex_exit(&set->set_lock);
    }

    return (i);
}


/*
 * nst_del_thread
 *
 * Removes threads from an existing thread set.
 * Returns the number successfully removed.
 */
int
nst_del_thread(nstset_t *set, int nthread)
{
    nsthread_t **tpp, *tp;
    int i;

    if (!set || nthread < 1) {
#ifdef DEBUG
        cmn_err(CE_WARN,
            "!nst_del_thread(%p, %d) - bad args", (void *)set, nthread);
#endif
        return (0);
    }

    for (i = 0; i < nthread; i++) {
        /* get thread */

        if (!(tp = nst_thread_alloc(set, FALSE)))
            break;

        mutex_enter(&set->set_lock);

        /* unlink from the set */

        for (tpp = &set->set_chain; *tpp; tpp = &(*tpp)->tp_chain) {
            if (*tpp == tp) {
                *tpp = tp->tp_chain;
                tp->tp_chain = NULL;
                break;
            }
        }

        /* kill the thread */

        tp->tp_flag |= NST_TF_KILL;
        tp->tp_flag &= ~NST_TF_INUSE;
        cv_broadcast(&tp->tp_cv);

        /* wait for thread to exit */

        while (tp->tp_flag & NST_TF_KILL)
            cv_wait(&set->set_kill_cv, &set->set_lock);

        set->set_nlive--;
        mutex_exit(&set->set_lock);

        /* free kernel resources */

        nst_thread_destroy(tp);
    }

    return (i);
}


/*
 * nst_init
 *
 * Initialise a new nsthread set, returning its address or
 * NULL in the event of failure. The set should be destroyed
 * by calling nst_destroy().
 */
nstset_t *
nst_init(char *name, int nthread)
{
    nstset_t *set, *sp;
    int len, i;

    if (nthread < 1) {
#ifdef DEBUG
        cmn_err(CE_WARN, "!nst_init: invalid arg");
#endif
        return (NULL);
    }

    if (nthread > USHRT_MAX) {
#ifdef DEBUG
        cmn_err(CE_WARN, "!nst_init: arg limit exceeded");
#endif
        return (NULL);
    }

    if (!(set = nst_kmem_zalloc(sizeof (*set), 2)))
        return (NULL);

    len = strlen(name);
    if (len >= sizeof (set->set_name))
        len = sizeof (set->set_name) - 1;

    bcopy(name, set->set_name, len);

    mutex_init(&set->set_lock, NULL, MUTEX_DRIVER, NULL);
    cv_init(&set->set_destroy_cv, NULL, CV_DRIVER, NULL);
    cv_init(&set->set_kill_cv, NULL, CV_DRIVER, NULL);
    cv_init(&set->set_res_cv, NULL, CV_DRIVER, NULL);

    set->set_reuse.q_forw = set->set_reuse.q_back = &set->set_reuse;
    set->set_free.q_forw = set->set_free.q_back = &set->set_free;

    mutex_enter(&nst_global_lock);

    /* check for duplicates */

    for (sp = nst_sets; sp; sp = sp->set_next) {
        if (strcmp(sp->set_name, set->set_name) == 0) {
            /* duplicate */
            mutex_exit(&nst_global_lock);
            cv_destroy(&set->set_res_cv);
            cv_destroy(&set->set_kill_cv);
            cv_destroy(&set->set_destroy_cv);
            mutex_destroy(&set->set_lock);
            kmem_free(set, sizeof (*set));
#ifdef DEBUG
            cmn_err(CE_WARN,
                "!nst_init: duplicate set \"%s\"", name);
#endif
            /* add threads if necessary */

            if (nthread > sp->set_nthread) {
                i = nst_add_thread(sp,
                    nthread - sp->set_nthread);
#ifdef DEBUG
                if (i !=  (nthread - sp->set_nthread))
                    cmn_err(CE_WARN,
                        "!nst_init: failed to allocate %d "
                        "threads (got %d)",
                        (nthread - sp->set_nthread), i);
#endif
            }

            /* return pointer to existing set */

            return (sp);
        }
    }

    /* add new set to chain */
    set->set_next = nst_sets;
    nst_sets = set;

    mutex_exit(&nst_global_lock);

    i = nst_add_thread(set, nthread);

    if (i != nthread) {
#ifdef DEBUG
        cmn_err(CE_WARN,
            "!nst_init: failed to allocate %d threads (got %d)",
            nthread, i);
#endif
        nst_destroy(set);
        return (NULL);
    }

    return (set);
}


/*
 * nst_nlive
 *
 * Return the number of live threads in a set.
 */
int
nst_nlive(nstset_t *set)
{
    return (set ? set->set_nlive : 0);
}


/*
 * nst_nthread
 *
 * Return the number of threads in the set.
 */
int
nst_nthread(nstset_t *set)
{
    return (set ? set->set_nthread : 0);
}


/*
 * nst_shutdown
 *
 * Called by nskern to shutdown the nsthread software.
 */
void
nst_shutdown(void)
{
    nstset_t *set;

    mutex_enter(&nst_global_lock);

    while ((set = nst_sets) != NULL) {
        mutex_exit(&nst_global_lock);
        nst_destroy(set);
        mutex_enter(&nst_global_lock);
    }

    mutex_exit(&nst_global_lock);
    mutex_destroy(&nst_global_lock);
}


/*
 * nst_startup
 *
 * Called by nskern to initialise the nsthread software
 */
int
nst_startup(void)
{
    mutex_init(&nst_global_lock, NULL, MUTEX_DRIVER, NULL);
    return (0);
}