ng_uni.c

Go to the documentation of this file.

/*-
 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
 *
 * Copyright (c) 2001-2003
 *      Fraunhofer Institute for Open Communication Systems (FhG Fokus).
 *      All rights reserved.
 *
 * Author: Hartmut Brandt <harti@freebsd.org>
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 *
 * Netgraph module for ATM-Forum UNI 4.0 signalling
 */
 
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
 
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/errno.h>
#include <sys/syslog.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/callout.h>
#include <sys/sbuf.h>
#include <machine/stdarg.h>
 
#include <netgraph/ng_message.h>
#include <netgraph/netgraph.h>
#include <netgraph/ng_parse.h>
#include <netnatm/unimsg.h>
#include <netnatm/msg/unistruct.h>
#include <netgraph/atm/ngatmbase.h>
#include <netnatm/saal/sscopdef.h>
#include <netnatm/saal/sscfudef.h>
#include <netgraph/atm/uni/ng_uni_cust.h>
#include <netnatm/sig/uni.h>
#include <netnatm/sig/unisig.h>
#include <netgraph/atm/ng_sscop.h>
#include <netgraph/atm/ng_sscfu.h>
#include <netgraph/atm/ng_uni.h>
 
static MALLOC_DEFINE(M_NG_UNI, "netgraph_uni_node", "netgraph uni node");
static MALLOC_DEFINE(M_UNI, "netgraph_uni_data", "uni protocol data");
 
MODULE_DEPEND(ng_uni, ngatmbase, 1, 1, 1);
 
/*
 * Private node data
 */
struct priv {
        hook_p  upper;
        hook_p  lower;
        struct uni *uni;
        int     enabled;
};
 
/* UNI CONFIG MASK */
static const struct ng_parse_struct_field ng_uni_config_mask_type_info[] =
        NGM_UNI_CONFIG_MASK_INFO;
static const struct ng_parse_type ng_uni_config_mask_type = {
        &ng_parse_struct_type,
        ng_uni_config_mask_type_info
};
 
/* UNI_CONFIG */
static const struct ng_parse_struct_field ng_uni_config_type_info[] =
        NGM_UNI_CONFIG_INFO;
static const struct ng_parse_type ng_uni_config_type = {
        &ng_parse_struct_type,
        ng_uni_config_type_info
};
 
/* SET CONFIG */
static const struct ng_parse_struct_field ng_uni_set_config_type_info[] =
        NGM_UNI_SET_CONFIG_INFO;
static const struct ng_parse_type ng_uni_set_config_type = {
        &ng_parse_struct_type,
        ng_uni_set_config_type_info
};
 
/*
 * Parse DEBUG
 */
static const struct ng_parse_fixedarray_info ng_uni_debuglevel_type_info =
    NGM_UNI_DEBUGLEVEL_INFO;
static const struct ng_parse_type ng_uni_debuglevel_type = {
        &ng_parse_fixedarray_type,
        &ng_uni_debuglevel_type_info
};
static const struct ng_parse_struct_field ng_uni_debug_type_info[] =
    NGM_UNI_DEBUG_INFO;
static const struct ng_parse_type ng_uni_debug_type = {
        &ng_parse_struct_type,
        ng_uni_debug_type_info
};
 
/*
 * Command list
 */
static const struct ng_cmdlist ng_uni_cmdlist[] = {
        {
          NGM_UNI_COOKIE,
          NGM_UNI_GETDEBUG,
          "getdebug",
          NULL,
          &ng_uni_debug_type
        },
        {
          NGM_UNI_COOKIE,
          NGM_UNI_SETDEBUG,
          "setdebug",
          &ng_uni_debug_type,
          NULL
        },
        {
          NGM_UNI_COOKIE,
          NGM_UNI_GET_CONFIG,
          "get_config",
          NULL,
          &ng_uni_config_type
        },
        {
          NGM_UNI_COOKIE,
          NGM_UNI_SET_CONFIG,
          "set_config",
          &ng_uni_set_config_type,
          &ng_uni_config_mask_type,
        },
        {
          NGM_UNI_COOKIE,
          NGM_UNI_ENABLE,
          "enable",
          NULL,
          NULL,
        },
        {
          NGM_UNI_COOKIE,
          NGM_UNI_DISABLE,
          "disable",
          NULL,
          NULL,
        },
        {
          NGM_UNI_COOKIE,
          NGM_UNI_GETSTATE,
          "getstate",
          NULL,
          &ng_parse_uint32_type
        },
        { 0 }
};
 
/*
 * Netgraph module data
 */
static ng_constructor_t ng_uni_constructor;
static ng_shutdown_t    ng_uni_shutdown;
static ng_rcvmsg_t      ng_uni_rcvmsg;
static ng_newhook_t     ng_uni_newhook;
static ng_disconnect_t  ng_uni_disconnect;
static ng_rcvdata_t     ng_uni_rcvlower;
static ng_rcvdata_t     ng_uni_rcvupper;
 
static int ng_uni_mod_event(module_t, int, void *);
 
static struct ng_type ng_uni_typestruct = {
        .version =      NG_ABI_VERSION,
        .name =         NG_UNI_NODE_TYPE,
        .mod_event =    ng_uni_mod_event,
        .constructor =  ng_uni_constructor,
        .rcvmsg =       ng_uni_rcvmsg,
        .shutdown =     ng_uni_shutdown,
        .newhook =      ng_uni_newhook,
        .rcvdata =      ng_uni_rcvlower,
        .disconnect =   ng_uni_disconnect,
        .cmdlist =      ng_uni_cmdlist,
};
NETGRAPH_INIT(uni, &ng_uni_typestruct);
 
static void uni_uni_output(struct uni *, void *, enum uni_sig, u_int32_t,
    struct uni_msg *);
static void uni_saal_output(struct uni *, void *, enum saal_sig,
    struct uni_msg *);
static void uni_verbose(struct uni *, void *, u_int, const char *, ...)
    __printflike(4, 5);
static void uni_do_status(struct uni *, void *, void *, const char *, ...)
    __printflike(4, 5);
 
static const struct uni_funcs uni_funcs = {
        uni_uni_output,
        uni_saal_output,
        uni_verbose,
        uni_do_status
};
 
/************************************************************/
/*
 * NODE MANAGEMENT
 */
static int
ng_uni_constructor(node_p node)
{
        struct priv *priv;
 
        priv = malloc(sizeof(*priv), M_NG_UNI, M_WAITOK | M_ZERO);
 
        if ((priv->uni = uni_create(node, &uni_funcs)) == NULL) {
                free(priv, M_NG_UNI);
                return (ENOMEM);
        }
 
        NG_NODE_SET_PRIVATE(node, priv);
        NG_NODE_FORCE_WRITER(node);
 
        return (0);
}
 
static int
ng_uni_shutdown(node_p node)
{
        struct priv *priv = NG_NODE_PRIVATE(node);
 
        uni_destroy(priv->uni);
 
        free(priv, M_NG_UNI);
        NG_NODE_SET_PRIVATE(node, NULL);
 
        NG_NODE_UNREF(node);
 
        return (0);
}
 
/************************************************************/
/*
 * CONTROL MESSAGES
 */
static void
uni_do_status(struct uni *uni, void *uarg, void *sbuf, const char *fmt, ...)
{
        va_list ap;
 
        va_start(ap, fmt);
        sbuf_printf(sbuf, fmt, ap);
        va_end(ap);
}
 
static int
text_status(node_p node, struct priv *priv, char *buf, u_int len)
{
        struct sbuf sbuf;
        u_int f;
 
        sbuf_new(&sbuf, buf, len, 0);
 
        if (priv->lower != NULL)
                sbuf_printf(&sbuf, "lower hook: connected to %s:%s\n",
                    NG_NODE_NAME(NG_HOOK_NODE(NG_HOOK_PEER(priv->lower))),
                    NG_HOOK_NAME(NG_HOOK_PEER(priv->lower)));
        else
                sbuf_printf(&sbuf, "lower hook: <not connected>\n");
 
        if (priv->upper != NULL)
                sbuf_printf(&sbuf, "upper hook: connected to %s:%s\n",
                    NG_NODE_NAME(NG_HOOK_NODE(NG_HOOK_PEER(priv->upper))),
                    NG_HOOK_NAME(NG_HOOK_PEER(priv->upper)));
        else
                sbuf_printf(&sbuf, "upper hook: <not connected>\n");
 
        sbuf_printf(&sbuf, "debugging:");
        for (f = 0; f < UNI_MAXFACILITY; f++)
                if (uni_get_debug(priv->uni, f) != 0)
                        sbuf_printf(&sbuf, " %s=%u", uni_facname(f),
                            uni_get_debug(priv->uni, f));
        sbuf_printf(&sbuf, "\n");
 
        if (priv->uni)
                uni_status(priv->uni, &sbuf);
 
        sbuf_finish(&sbuf);
        return (sbuf_len(&sbuf));
}
 
static int
ng_uni_rcvmsg(node_p node, item_p item, hook_p lasthook)
{
        struct priv *priv = NG_NODE_PRIVATE(node);
        struct ng_mesg *resp = NULL;
        struct ng_mesg *msg;
        int error = 0;
        u_int i;
 
        NGI_GET_MSG(item, msg);
 
        switch (msg->header.typecookie) {
          case NGM_GENERIC_COOKIE:
                switch (msg->header.cmd) {
                  case NGM_TEXT_STATUS:
                        NG_MKRESPONSE(resp, msg, NG_TEXTRESPONSE, M_NOWAIT);
                        if (resp == NULL) {
                                error = ENOMEM;
                                break;
                        }
 
                        resp->header.arglen = text_status(node, priv,
                            (char *)resp->data, resp->header.arglen) + 1;
                        break;
 
                  default:
                        error = EINVAL;
                        break;
                }
                break;
 
          case NGM_UNI_COOKIE:
                switch (msg->header.cmd) {
                  case NGM_UNI_SETDEBUG:
                    {
                        struct ngm_uni_debug *arg;
 
                        if (msg->header.arglen > sizeof(*arg)) {
                                error = EINVAL;
                                break;
                        }
                        arg = (struct ngm_uni_debug *)msg->data;
                        for (i = 0; i < UNI_MAXFACILITY; i++)
                                uni_set_debug(priv->uni, i, arg->level[i]);
                        break;
                    }
 
                  case NGM_UNI_GETDEBUG:
                    {
                        struct ngm_uni_debug *arg;
 
                        NG_MKRESPONSE(resp, msg, sizeof(*arg), M_NOWAIT);
                        if(resp == NULL) {
                                error = ENOMEM;
                                break;
                        }
                        arg = (struct ngm_uni_debug *)resp->data;
                        for (i = 0; i < UNI_MAXFACILITY; i++)
                                arg->level[i] = uni_get_debug(priv->uni, i);
                        break;
                    }
 
                  case NGM_UNI_GET_CONFIG:
                    {
                        struct uni_config *config;
 
                        if (msg->header.arglen != 0) {
                                error = EINVAL;
                                break;
                        }
                        NG_MKRESPONSE(resp, msg, sizeof(*config), M_NOWAIT);
                        if (resp == NULL) {
                                error = ENOMEM;
                                break;
                        }
                        config = (struct uni_config *)resp->data;
                        uni_get_config(priv->uni, config);
 
                        break;
                    }
 
                  case NGM_UNI_SET_CONFIG:
                    {
                        struct ngm_uni_set_config *arg;
                        struct ngm_uni_config_mask *mask;
 
                        if (msg->header.arglen != sizeof(*arg)) {
                                error = EINVAL;
                                break;
                        }
                        arg = (struct ngm_uni_set_config *)msg->data;
 
                        NG_MKRESPONSE(resp, msg, sizeof(*mask), M_NOWAIT);
                        if (resp == NULL) {
                                error = ENOMEM;
                                break;
                        }
                        mask = (struct ngm_uni_config_mask *)resp->data;
 
                        *mask = arg->mask;
 
                        uni_set_config(priv->uni, &arg->config,
                            &mask->mask, &mask->popt_mask, &mask->option_mask);
 
                        break;
                    }
 
                  case NGM_UNI_ENABLE:
                        if (msg->header.arglen != 0) {
                                error = EINVAL;
                                break;
                        }
                        if (priv->enabled) {
                                error = EISCONN;
                                break;
                        }
                        priv->enabled = 1;
                        break;
 
                  case NGM_UNI_DISABLE:
                        if (msg->header.arglen != 0) {
                                error = EINVAL;
                                break;
                        }
                        if (!priv->enabled) {
                                error = ENOTCONN;
                                break;
                        }
                        priv->enabled = 0;
                        uni_reset(priv->uni);
                        break;
 
                  case NGM_UNI_GETSTATE:
                        if (msg->header.arglen != 0) {
                                error = EINVAL;
                                break;
                        }
                        NG_MKRESPONSE(resp, msg, sizeof(u_int32_t), M_NOWAIT);
                        if(resp == NULL) {
                                error = ENOMEM;
                                break;
                        }
                        *(u_int32_t *)resp->data =
                            priv->enabled ? (uni_getcustate(priv->uni) + 1)
                                          : 0;
                        break;
 
                  default:
                        error = EINVAL;
                        break;
                }
                break;
 
          default:
                error = EINVAL;
                break;
        }
 
        NG_RESPOND_MSG(error, node, item, resp);
        NG_FREE_MSG(msg);
        return (error);
}
 
/************************************************************/
/*
 * HOOK MANAGEMENT
 */
static int
ng_uni_newhook(node_p node, hook_p hook, const char *name)
{
        struct priv *priv = NG_NODE_PRIVATE(node);
 
        if (strcmp(name, "lower") == 0) {
                priv->lower = hook;
        } else if(strcmp(name, "upper") == 0) {
                priv->upper = hook;
                NG_HOOK_SET_RCVDATA(hook, ng_uni_rcvupper);
        } else
                return EINVAL;
 
        return 0;
}
 
static int
ng_uni_disconnect(hook_p hook)
{
        node_p node = NG_HOOK_NODE(hook);
        struct priv *priv = NG_NODE_PRIVATE(node);
 
        if(hook == priv->lower)
                priv->lower = NULL;
        else if(hook == priv->upper)
                priv->upper = NULL;
        else
                printf("%s: bogus hook %s\n", __func__, NG_HOOK_NAME(hook));
 
        if (NG_NODE_NUMHOOKS(node) == 0) {
                if (NG_NODE_IS_VALID(node))
                        ng_rmnode_self(node);
        }
 
        return (0);
}
 
/************************************************************/
/*
 * DATA
 */
/*
 * Receive signal from USER.
 *
 * Repackage the data into one large buffer.
 */
static int
ng_uni_rcvupper(hook_p hook, item_p item)
{
        node_p node = NG_HOOK_NODE(hook);
        struct priv *priv = NG_NODE_PRIVATE(node);
        struct mbuf *m;
        struct uni_arg arg;
        struct uni_msg *msg;
        int error;
 
        if (!priv->enabled) {
                NG_FREE_ITEM(item);
                return (ENOTCONN);
        }
 
        NGI_GET_M(item, m);
        NG_FREE_ITEM(item);
 
        if ((error = uni_msg_unpack_mbuf(m, &msg)) != 0) {
                m_freem(m);
                return (error);
        }
        m_freem(m);
 
        if (uni_msg_len(msg) < sizeof(arg)) {
                printf("%s: packet too short\n", __func__);
                uni_msg_destroy(msg);
                return (EINVAL);
        }
 
        bcopy(msg->b_rptr, &arg, sizeof(arg));
        msg->b_rptr += sizeof(arg);
 
        if (arg.sig >= UNIAPI_MAXSIG) {
                printf("%s: bogus signal\n", __func__);
                uni_msg_destroy(msg);
                return (EINVAL);
        }
        uni_uni_input(priv->uni, arg.sig, arg.cookie, msg);
        uni_work(priv->uni);
 
        return (0);
}
 
/*
 * Upper layer signal from UNI
 */
static void
uni_uni_output(struct uni *uni, void *varg, enum uni_sig sig, u_int32_t cookie,
    struct uni_msg *msg)
{
        node_p node = (node_p)varg;
        struct priv *priv = NG_NODE_PRIVATE(node);
        struct mbuf *m;
        struct uni_arg arg;
        int error;
 
        if (priv->upper == NULL) {
                if (msg != NULL)
                        uni_msg_destroy(msg);
                return;
        }
        arg.sig = sig;
        arg.cookie = cookie;
 
        m = uni_msg_pack_mbuf(msg, &arg, sizeof(arg));
        if (msg != NULL)
                uni_msg_destroy(msg);
        if (m == NULL)
                return;
 
        NG_SEND_DATA_ONLY(error, priv->upper, m);
}
 
static void
dump_uni_msg(struct uni_msg *msg)
{
        u_int pos;
 
        for (pos = 0; pos < uni_msg_len(msg); pos++) {
                if (pos % 16 == 0)
                        printf("%06o ", pos);
                if (pos % 16 == 8)
                        printf("  ");
                printf(" %02x", msg->b_rptr[pos]);
                if (pos % 16 == 15)
                        printf("\n");
        }
        if (pos % 16 != 0)
                printf("\n");
}
 
/*
 * Dump a SAAL signal in either direction
 */
static void
dump_saal_signal(node_p node, enum saal_sig sig, struct uni_msg *msg, int to)
{
        struct priv *priv = NG_NODE_PRIVATE(node);
 
        printf("signal %s SAAL: ", to ? "to" : "from");
 
        switch (sig) {
#define D(S) case S: printf("%s", #S); break
 
        D(SAAL_ESTABLISH_request);
        D(SAAL_ESTABLISH_indication);
        D(SAAL_ESTABLISH_confirm);
        D(SAAL_RELEASE_request);
        D(SAAL_RELEASE_confirm);
        D(SAAL_RELEASE_indication);
        D(SAAL_DATA_request);
        D(SAAL_DATA_indication);
        D(SAAL_UDATA_request);
        D(SAAL_UDATA_indication);
 
#undef D
          default:
                printf("sig=%d", sig); break;
        }
        if (msg != NULL) {
                printf(" data=%zu\n", uni_msg_len(msg));
                if (uni_get_debug(priv->uni, UNI_FAC_SAAL) > 1)
                        dump_uni_msg(msg);
        } else
                printf("\n");
}
 
/*
 * Receive signal from SSCOP.
 *
 * If this is a data signal, repackage the data into one large buffer.
 * UNI shouldn't be the bottleneck in a system and this greatly simplifies
 * parsing in UNI.
 */
static int
ng_uni_rcvlower(hook_p hook __unused, item_p item)
{
        node_p node = NG_HOOK_NODE(hook);
        struct priv *priv = NG_NODE_PRIVATE(node);
        struct mbuf *m;
        struct sscfu_arg arg;
        struct uni_msg *msg;
        int error;
 
        if (!priv->enabled) {
                NG_FREE_ITEM(item);
                return (ENOTCONN);
        }
 
        NGI_GET_M(item, m);
        NG_FREE_ITEM(item);
 
        if ((error = uni_msg_unpack_mbuf(m, &msg)) != 0) {
                m_freem(m);
                return (error);
        }
        m_freem(m);
 
        if (uni_msg_len(msg) < sizeof(arg)) {
                uni_msg_destroy(msg);
                printf("%s: packet too short\n", __func__);
                return (EINVAL);
        }
        bcopy(msg->b_rptr, &arg, sizeof(arg));
        msg->b_rptr += sizeof(arg);
 
        if (arg.sig > SAAL_UDATA_indication) {
                uni_msg_destroy(msg);
                printf("%s: bogus signal\n", __func__);
                return (EINVAL);
        }
 
        if (uni_get_debug(priv->uni, UNI_FAC_SAAL) > 0)
                dump_saal_signal(node, arg.sig, msg, 0);
 
        uni_saal_input(priv->uni, arg.sig, msg);
        uni_work(priv->uni);
 
        return (0);
}
 
/*
 * Send signal to sscop.
 * Pack the message into an mbuf chain.
 */
static void
uni_saal_output(struct uni *uni, void *varg, enum saal_sig sig, struct uni_msg *msg)
{
        node_p node = (node_p)varg;
        struct priv *priv = NG_NODE_PRIVATE(node);
        struct mbuf *m;
        struct sscfu_arg arg;
        int error;
 
        if (uni_get_debug(priv->uni, UNI_FAC_SAAL) > 0)
                dump_saal_signal(node, sig, msg, 1);
 
        if (priv->lower == NULL) {
                if (msg != NULL)
                        uni_msg_destroy(msg);
                return;
        }
 
        arg.sig = sig;
 
        m = uni_msg_pack_mbuf(msg, &arg, sizeof(arg));
        if (msg != NULL)
                uni_msg_destroy(msg);
        if (m == NULL)
                return;
 
        NG_SEND_DATA_ONLY(error, priv->lower, m);
}
 
static void
uni_verbose(struct uni *uni, void *varg, u_int fac, const char *fmt, ...)
{
        va_list ap;
 
        static char *facnames[] = {
#define UNI_DEBUG_DEFINE(D) [UNI_FAC_##D] = #D,
                UNI_DEBUG_FACILITIES
#undef UNI_DEBUG_DEFINE
        };
 
        printf("%s: ", facnames[fac]);
 
        va_start(ap, fmt);
        vprintf(fmt, ap);
        va_end(ap);
 
        printf("\n");
}
 
/************************************************************/
/*
 * Memory debugging
 */
struct unimem_debug {
        const char      *file;
        u_int           lno;
        LIST_ENTRY(unimem_debug) link;
        char            data[0];
};
LIST_HEAD(unimem_debug_list, unimem_debug);
 
static struct unimem_debug_list nguni_freemem[UNIMEM_TYPES] = {
    LIST_HEAD_INITIALIZER(nguni_freemem[0]),
    LIST_HEAD_INITIALIZER(nguni_freemem[1]),
    LIST_HEAD_INITIALIZER(nguni_freemem[2]),
    LIST_HEAD_INITIALIZER(nguni_freemem[3]),
    LIST_HEAD_INITIALIZER(nguni_freemem[4]),
};
static struct unimem_debug_list nguni_usedmem[UNIMEM_TYPES] = {
    LIST_HEAD_INITIALIZER(nguni_usedmem[0]),
    LIST_HEAD_INITIALIZER(nguni_usedmem[1]),
    LIST_HEAD_INITIALIZER(nguni_usedmem[2]),
    LIST_HEAD_INITIALIZER(nguni_usedmem[3]),
    LIST_HEAD_INITIALIZER(nguni_usedmem[4]),
};
 
static struct mtx nguni_unilist_mtx;
 
static const char *unimem_names[UNIMEM_TYPES] = {
        "instance",
        "all",
        "signal",
        "call",
        "party"
};
 
static void
uni_init(void)
{
        mtx_init(&nguni_unilist_mtx, "netgraph UNI structure lists", NULL,
            MTX_DEF);
}
 
static void
uni_fini(void)
{
        u_int type;
        struct unimem_debug *h;
 
        for (type = 0; type < UNIMEM_TYPES; type++) {
                while ((h = LIST_FIRST(&nguni_freemem[type])) != NULL) {
                        LIST_REMOVE(h, link);
                        free(h, M_UNI);
                }
 
                while ((h = LIST_FIRST(&nguni_usedmem[type])) != NULL) {
                        LIST_REMOVE(h, link);
                        printf("ng_uni: %s in use: %p (%s,%u)\n",
                            unimem_names[type], (caddr_t)h->data,
                            h->file, h->lno);
                        free(h, M_UNI);
                }
        }
 
        mtx_destroy(&nguni_unilist_mtx);
}
 
/*
 * Allocate a chunk of memory from a given type.
 */
void *
ng_uni_malloc(enum unimem type, const char *file, u_int lno)
{
        struct unimem_debug *d;
        size_t full;
 
        /*
         * Try to allocate
         */
        mtx_lock(&nguni_unilist_mtx);
        if ((d = LIST_FIRST(&nguni_freemem[type])) != NULL)
                LIST_REMOVE(d, link);
        mtx_unlock(&nguni_unilist_mtx);
 
        if (d == NULL) {
                /*
                 * allocate
                 */
                full = unimem_sizes[type] + offsetof(struct unimem_debug, data);
                if ((d = malloc(full, M_UNI, M_NOWAIT | M_ZERO)) == NULL)
                        return (NULL);
        } else {
                bzero(d->data, unimem_sizes[type]);
        }
        d->file = file;
        d->lno = lno;
 
        mtx_lock(&nguni_unilist_mtx);
        LIST_INSERT_HEAD(&nguni_usedmem[type], d, link);
        mtx_unlock(&nguni_unilist_mtx);
        return (d->data);
}
 
void
ng_uni_free(enum unimem type, void *ptr, const char *file, u_int lno)
{
        struct unimem_debug *d, *h;
 
        d = (struct unimem_debug *)
            ((char *)ptr - offsetof(struct unimem_debug, data));
 
        mtx_lock(&nguni_unilist_mtx);
 
        LIST_FOREACH(h, &nguni_usedmem[type], link)
                if (d == h)
                        break;
 
        if (h != NULL) {
                LIST_REMOVE(d, link);
                LIST_INSERT_HEAD(&nguni_freemem[type], d, link);
        } else {
                /*
                 * Not on used list - try free list.
                 */
                LIST_FOREACH(h, &nguni_freemem[type], link)
                        if (d == h)
                                break;
                if (h == NULL)
                        printf("ng_uni: %s,%u: %p(%s) was never allocated\n",
                            file, lno, ptr, unimem_names[type]);
                else
                        printf("ng_uni: %s,%u: %p(%s) was already destroyed "
                            "in %s,%u\n",
                            file, lno, ptr, unimem_names[type],
                            h->file, h->lno);
        }
        mtx_unlock(&nguni_unilist_mtx);
}
/************************************************************/
/*
 * INITIALISATION
 */
 
/*
 * Loading and unloading of node type
 */
static int
ng_uni_mod_event(module_t mod, int event, void *data)
{
        int error = 0;
 
        switch(event) {
          case MOD_LOAD:
                uni_init();
                break;
 
          case MOD_UNLOAD:
                uni_fini();
                break;
 
          default:
                error = EOPNOTSUPP;
                break;
        }
        return (error);
}