/*
 * 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.
 */

/*
 * MD Event Generator (MDEG) Module
 */

#include <sys/machsystm.h>
#include <sys/taskq.h>
#include <sys/disp.h>
#include <sys/cmn_err.h>
#include <sys/note.h>

#include <sys/mdeg.h>
#include <sys/mach_descrip.h>
#include <sys/mdesc.h>

/*
 * A single client registration
 */
typedef struct mdeg_clnt {
        boolean_t               valid;          /* structure is in active use */
        mdeg_node_match_t       *nmatch;        /* node match filter */
        mdeg_node_spec_t        *pspec;         /* parent match filter */
        mdeg_cb_t               cb;             /* the client callback */
        caddr_t                 cb_arg;         /* argument to the callback */
        uint64_t                magic;          /* sanity checking magic */
        mdeg_handle_t           hdl;            /* handle assigned by MDEG */
} mdeg_clnt_t;

/*
 * Global MDEG data
 *
 * Locking Strategy:
 *
 *   mdeg.lock - lock used to synchronize system-wide MD updates. An
 *      MD update must be treated as an atomic event. The lock is
 *      taken when notification that a new MD is available and held
 *      until all clients have been notified.
 *
 *   mdeg.rwlock - lock used to synchronize access to the table of
 *      registered clients. The reader lock must be held when looking
 *      up client information in the table. The writer lock must be
 *      held when modifying any client information.
 */
static struct mdeg {
        taskq_t         *taskq;         /* for internal processing */
        boolean_t       enabled;        /* enable/disable taskq processing */
        kmutex_t        lock;           /* synchronize MD updates */
        md_t            *md_prev;       /* previous MD */
        md_t            *md_curr;       /* current MD */
        mdeg_clnt_t     *tbl;           /* table of registered clients */
        krwlock_t       rwlock;         /* client table lock */
        uint_t          maxclnts;       /* client table size */
        uint_t          nclnts;         /* current number of clients */
} mdeg;

/*
 * Debugging routines
 */
#ifdef DEBUG
uint_t mdeg_debug = 0x0;

static void mdeg_dump_clnt(mdeg_clnt_t *clnt);
static void mdeg_dump_table(void);

#define MDEG_DBG                if (mdeg_debug) printf
#define MDEG_DUMP_CLNT          mdeg_dump_clnt
#define MDEG_DUMP_TABLE         mdeg_dump_table

#else /* DEBUG */

#define MDEG_DBG                _NOTE(CONSTCOND) if (0) printf
#define MDEG_DUMP_CLNT(...)
#define MDEG_DUMP_TABLE(...)

#endif /* DEBUG */

/*
 * Global constants
 */
#define MDEG_MAX_TASKQ_THR      512     /* maximum number of taskq threads */
#define MDEG_MAX_CLNTS_INIT     64      /* initial client table size */

#define MDEG_MAGIC              0x4D4445475F48444Cull   /* 'MDEG_HDL' */

/*
 * A client handle is a 64 bit value with two pieces of
 * information encoded in it. The upper 32 bits are the
 * index into the table of a particular client structure.
 * The lower 32 bits are a counter that is incremented
 * each time a client structure is reused.
 */
#define MDEG_IDX_SHIFT                  32
#define MDEG_COUNT_MASK                 0xfffffffful

#define MDEG_ALLOC_HDL(_idx, _count)    (((uint64_t)_idx << MDEG_IDX_SHIFT) | \
                                        ((uint64_t)(_count + 1) &             \
                                        MDEG_COUNT_MASK))
#define MDEG_HDL2IDX(hdl)               (hdl >> MDEG_IDX_SHIFT)
#define MDEG_HDL2COUNT(hdl)             (hdl & MDEG_COUNT_MASK)

static const char trunc_str[] = " ... }";

/*
 * Utility routines
 */
static mdeg_clnt_t *mdeg_alloc_clnt(void);
static void mdeg_notify_client(void *);
static mde_cookie_t mdeg_find_start_node(md_t *, mdeg_node_spec_t *);
static boolean_t mdeg_node_spec_match(md_t *, mde_cookie_t, mdeg_node_spec_t *);
static void mdeg_get_diff_results(md_diff_cookie_t, mdeg_result_t *);

int
mdeg_init(void)
{
        int     tblsz;

        /*
         * Grab the current MD
         */
        if ((mdeg.md_curr = md_get_handle()) == NULL) {
                cmn_err(CE_WARN, "unable to cache snapshot of MD");
                return (-1);
        }

        /*
         * Initialize table of registered clients
         */
        mdeg.maxclnts = MDEG_MAX_CLNTS_INIT;

        tblsz = mdeg.maxclnts * sizeof (mdeg_clnt_t);
        mdeg.tbl = kmem_zalloc(tblsz, KM_SLEEP);

        rw_init(&mdeg.rwlock, NULL, RW_DRIVER, NULL);

        mdeg.nclnts = 0;

        /*
         * Initialize global lock
         */
        mutex_init(&mdeg.lock, NULL, MUTEX_DRIVER, NULL);

        /*
         * Initialize the task queue
         */
        mdeg.taskq = taskq_create("mdeg_taskq", 1, minclsyspri, 1,
            MDEG_MAX_TASKQ_THR, TASKQ_PREPOPULATE | TASKQ_DYNAMIC);

        /* ready to begin handling clients */
        mdeg.enabled = B_TRUE;

        return (0);
}

void
mdeg_fini(void)
{
        /*
         * Flip the enabled switch off to make sure that
         * no events get dispatched while things are being
         * torn down.
         */
        mdeg.enabled = B_FALSE;

        /* destroy the task queue */
        taskq_destroy(mdeg.taskq);

        /*
         * Deallocate the table of registered clients
         */
        kmem_free(mdeg.tbl, mdeg.maxclnts * sizeof (mdeg_clnt_t));
        rw_destroy(&mdeg.rwlock);

        /*
         * Free up the cached MDs.
         */
        if (mdeg.md_curr)
                (void) md_fini_handle(mdeg.md_curr);

        if (mdeg.md_prev)
                (void) md_fini_handle(mdeg.md_prev);

        mutex_destroy(&mdeg.lock);
}

static mdeg_clnt_t *
mdeg_alloc_clnt(void)
{
        mdeg_clnt_t     *clnt;
        int             idx;
        mdeg_clnt_t     *newtbl;
        uint_t          newmaxclnts;
        uint_t          newtblsz;
        uint_t          oldtblsz;

        ASSERT(RW_WRITE_HELD(&mdeg.rwlock));

        /* search for an unused slot in the table */
        for (idx = 0; idx < mdeg.maxclnts; idx++) {
                clnt = &mdeg.tbl[idx];
                if (!clnt->valid) {
                        break;
                }
        }

        /* found any empty slot */
        if (idx != mdeg.maxclnts) {
                goto found;
        }

        /*
         * There was no free space in the table. Grow
         * the table to double its current size.
         */

        MDEG_DBG("client table full:\n");
        MDEG_DUMP_TABLE();

        newmaxclnts = mdeg.maxclnts * 2;
        newtblsz = newmaxclnts * sizeof (mdeg_clnt_t);

        newtbl = kmem_zalloc(newtblsz, KM_SLEEP);

        /* copy old table data to the new table */
        oldtblsz = mdeg.maxclnts * sizeof (mdeg_clnt_t);
        bcopy(mdeg.tbl, newtbl, oldtblsz);

        /*
         * Since the old table was full, the first free entry
         * will be just past the end of the old table data in
         * the new table.
         */
        clnt = &newtbl[mdeg.maxclnts];

        /* clean up the old table */
        kmem_free(mdeg.tbl, oldtblsz);
        mdeg.tbl = newtbl;
        mdeg.maxclnts = newmaxclnts;

found:
        ASSERT(clnt->valid == 0);

        clnt->hdl = MDEG_ALLOC_HDL(idx, MDEG_HDL2COUNT(clnt->hdl));

        return (clnt);
}

static mdeg_clnt_t *
mdeg_get_client(mdeg_handle_t hdl)
{
        int             idx;
        mdeg_clnt_t     *clnt;

        idx = MDEG_HDL2IDX(hdl);

        /* check if index is out of bounds */
        if ((idx < 0) || (idx >= mdeg.maxclnts)) {
                MDEG_DBG("mdeg_get_client: index out of bounds\n");
                return (NULL);
        }

        clnt = &mdeg.tbl[idx];

        /* check for a valid client */
        if (!clnt->valid) {
                MDEG_DBG("mdeg_get_client: client is not valid\n");
                return (NULL);
        }

        /* make sure the handle is an exact match */
        if (clnt->hdl != hdl) {
                MDEG_DBG("mdeg_get_client: bad handle\n");
                return (NULL);
        }

        if (clnt->magic != MDEG_MAGIC) {
                MDEG_DBG("mdeg_get_client: bad magic\n");
                return (NULL);
        }

        return (clnt);
}

/*
 * Send a notification to a client immediately after it registers.
 * The result_t is a list of all the nodes that match their specified
 * nodes of interest, all returned on the added list. This serves
 * as a base of reference to the client. All future MD updates are
 * relative to this list.
 */
static int
mdeg_notify_client_reg(mdeg_clnt_t *clnt)
{
        md_t                    *mdp = NULL;
        mde_str_cookie_t        nname;
        mde_str_cookie_t        aname;
        mde_cookie_t            startnode;
        int                     nnodes;
        int                     nodechk;
        mde_cookie_t            *listp = NULL;
        mdeg_result_t           *mdeg_res = NULL;
        int                     rv = MDEG_SUCCESS;

        mutex_enter(&mdeg.lock);

        /*
         * Handle the special case where the node specification
         * is NULL. In this case, call the client callback without
         * any results. All processing is left to the client.
         */
        if (clnt->pspec == NULL) {
                /* call the client callback */
                (void) (*clnt->cb)(clnt->cb_arg, NULL);
                goto done;
        }

        if ((mdp = md_get_handle()) == NULL) {
                cmn_err(CE_WARN, "unable to retrieve current MD");
                rv = MDEG_FAILURE;
                goto done;
        }

        startnode = mdeg_find_start_node(mdp, clnt->pspec);
        if (startnode == MDE_INVAL_ELEM_COOKIE) {
                /* not much we can do */
                cmn_err(CE_WARN, "unable to match node specifier");
                rv = MDEG_FAILURE;
                goto done;
        }

        /*
         * Use zalloc to provide correct default values for the
         * unused removed, match_prev, and match_curr lists.
         */
        mdeg_res = kmem_zalloc(sizeof (mdeg_result_t), KM_SLEEP);

        nname = md_find_name(mdp, clnt->nmatch->namep);
        aname = md_find_name(mdp, "fwd");

        nnodes = md_scan_dag(mdp, startnode, nname, aname, NULL);

        if (nnodes == 0) {
                MDEG_DBG("mdeg_notify_client_reg: no nodes of interest\n");
                rv = MDEG_SUCCESS;
                goto done;
        } else if (nnodes == -1) {
                MDEG_DBG("error scanning DAG\n");
                rv = MDEG_FAILURE;
                goto done;
        }

        MDEG_DBG("mdeg_notify_client_reg: %d node%s of interest\n",
            nnodes, (nnodes == 1) ? "" : "s");

        /* get the list of nodes of interest */
        listp = kmem_alloc(sizeof (mde_cookie_t) * nnodes, KM_SLEEP);
        nodechk = md_scan_dag(mdp, startnode, nname, aname, listp);

        ASSERT(nodechk == nnodes);

        mdeg_res->added.mdp = mdp;
        mdeg_res->added.mdep = listp;
        mdeg_res->added.nelem = nnodes;

        /* call the client callback */
        (void) (*clnt->cb)(clnt->cb_arg, mdeg_res);

done:
        mutex_exit(&mdeg.lock);

        if (mdp)
                (void) md_fini_handle(mdp);

        if (listp)
                kmem_free(listp, sizeof (mde_cookie_t) * nnodes);

        if (mdeg_res)
                kmem_free(mdeg_res, sizeof (mdeg_result_t));

        return (rv);
}

/*
 * Register to receive an event notification when the system
 * machine description is updated.
 *
 * Passing NULL for the node specification parameter is valid
 * as long as the match specification is also NULL. In this
 * case, the client will receive a notification when the MD
 * has been updated, but the callback will not include any
 * information. The client is then responsible for obtaining
 * its own copy of the system MD and performing any processing
 * manually.
 */
int
mdeg_register(mdeg_node_spec_t *pspecp, mdeg_node_match_t *nmatchp,
    mdeg_cb_t cb, void *cb_arg, mdeg_handle_t *hdlp)
{
        mdeg_clnt_t     *clnt;

        /* should never be called from a callback */
        ASSERT(!taskq_member(mdeg.taskq, curthread));

        /* node spec and node match must both be valid, or both NULL */
        if (((pspecp != NULL) && (nmatchp == NULL)) ||
            ((pspecp == NULL) && (nmatchp != NULL))) {
                MDEG_DBG("mdeg_register: invalid parameters\n");
                return (MDEG_FAILURE);
        }

        rw_enter(&mdeg.rwlock, RW_WRITER);

        clnt = mdeg_alloc_clnt();

        ASSERT(clnt);

        /*
         * Fill in the rest of the data
         */
        clnt->nmatch = nmatchp;
        clnt->pspec = pspecp;
        clnt->cb = cb;
        clnt->cb_arg = cb_arg;
        clnt->magic = MDEG_MAGIC;

        /* do this last */
        clnt->valid = B_TRUE;

        MDEG_DBG("client registered (0x%lx):\n", clnt->hdl);
        MDEG_DUMP_CLNT(clnt);

        mdeg.nclnts++;

        if (mdeg_notify_client_reg(clnt) != MDEG_SUCCESS) {
                bzero(clnt, sizeof (mdeg_clnt_t));
                rw_exit(&mdeg.rwlock);
                return (MDEG_FAILURE);
        }

        rw_exit(&mdeg.rwlock);

        *hdlp = clnt->hdl;

        return (MDEG_SUCCESS);
}

int
mdeg_unregister(mdeg_handle_t hdl)
{
        mdeg_clnt_t     *clnt;
        mdeg_handle_t   mdh;

        /* should never be called from a callback */
        ASSERT(!taskq_member(mdeg.taskq, curthread));

        rw_enter(&mdeg.rwlock, RW_WRITER);

        /* lookup the client */
        if ((clnt = mdeg_get_client(hdl)) == NULL) {
                rw_exit(&mdeg.rwlock);
                return (MDEG_FAILURE);
        }

        MDEG_DBG("client unregistered (0x%lx):\n", hdl);
        MDEG_DUMP_CLNT(clnt);

        /* save the handle to prevent reuse */
        mdh = clnt->hdl;
        bzero(clnt, sizeof (mdeg_clnt_t));

        clnt->hdl = mdh;

        mdeg.nclnts--;

        rw_exit(&mdeg.rwlock);

        return (MDEG_SUCCESS);
}

/*
 * Simple algorithm for now, grab the global lock and let all
 * the clients update themselves in parallel. There is a lot of
 * room for improvement here. We could eliminate some scans of
 * the DAG by incrementally scanning at lower levels of the DAG
 * rather than having each client start its own scan from the root.
 */
void
mdeg_notify_clients(void)
{
        md_t            *md_new;
        mdeg_clnt_t     *clnt;
        int             idx;
        int             nclnt;

        rw_enter(&mdeg.rwlock, RW_READER);
        mutex_enter(&mdeg.lock);

        /*
         * Rotate the MDs
         */
        if ((md_new = md_get_handle()) == NULL) {
                cmn_err(CE_WARN, "unable to retrieve new MD");
                goto done;
        }

        if (mdeg.md_prev) {
                (void) md_fini_handle(mdeg.md_prev);
        }

        mdeg.md_prev = mdeg.md_curr;
        mdeg.md_curr = md_new;

        if (mdeg.nclnts == 0) {
                MDEG_DBG("mdeg_notify_clients: no clients registered\n");
                goto done;
        }

        /* dispatch the update notification to all clients */
        for (idx = 0, nclnt = 0; idx < mdeg.maxclnts; idx++) {
                clnt = &mdeg.tbl[idx];

                if (!clnt->valid)
                        continue;

                MDEG_DBG("notifying client 0x%lx (%d/%d)\n", clnt->hdl,
                    ++nclnt, mdeg.nclnts);

                (void) taskq_dispatch(mdeg.taskq, mdeg_notify_client,
                    (void *)clnt, TQ_SLEEP);
        }

        /*
         * Wait for all mdeg_notify_client notifications to
         * finish while we are still holding mdeg.rwlock.
         */
        taskq_wait(mdeg.taskq);

done:
        mutex_exit(&mdeg.lock);
        rw_exit(&mdeg.rwlock);
}

static void
mdeg_notify_client(void *arg)
{
        mdeg_clnt_t             *clnt = (mdeg_clnt_t *)arg;
        md_diff_cookie_t        mdd = MD_INVAL_DIFF_COOKIE;
        mdeg_result_t           mdeg_res;
        mde_cookie_t            md_prev_start;
        mde_cookie_t            md_curr_start;

        /*
         * mdeg.rwlock must be held as a reader while this function
         * executes. However, we do not need to acquire the lock as a
         * reader here because it is held as a reader by the thread
         * executing mdeg_notify_clients which triggers the execution
         * of this function from a taskq. Since mdeg_notify_clients
         * holds the lock as a reader until the taskq callbacks have
         * completed, it will be held for the life of this function call.
         * Furthermore, we must not attempt to acquire the lock as a
         * reader with rw_enter because if there is a pending writer,
         * we will block, creating a circular deadlock with this function,
         * the writer, and mdeg_notify_clients. Since we do not need
         * to acquire the lock, just assert that it is held.
         */
        ASSERT(RW_READ_HELD(&mdeg.rwlock));

        if (!mdeg.enabled) {
                /* trying to shutdown */
                MDEG_DBG("mdeg_notify_client: mdeg disabled, aborting\n");
                goto cleanup;
        }

        /*
         * Handle the special case where the node specification
         * is NULL. In this case, call the client callback without
         * any results. All processing is left to the client.
         */
        if (clnt->pspec == NULL) {
                /* call the client callback */
                (void) (*clnt->cb)(clnt->cb_arg, NULL);

                MDEG_DBG("MDEG client callback done\n");
                goto cleanup;
        }

        /* find our start nodes */
        md_prev_start = mdeg_find_start_node(mdeg.md_prev, clnt->pspec);
        if (md_prev_start == MDE_INVAL_ELEM_COOKIE) {
                goto cleanup;
        }

        md_curr_start = mdeg_find_start_node(mdeg.md_curr, clnt->pspec);
        if (md_curr_start == MDE_INVAL_ELEM_COOKIE) {
                goto cleanup;
        }

        /* diff the MDs */
        mdd = md_diff_init(mdeg.md_prev, md_prev_start, mdeg.md_curr,
            md_curr_start, clnt->nmatch->namep, clnt->nmatch->matchp);

        if (mdd == MD_INVAL_DIFF_COOKIE) {
                MDEG_DBG("unable to diff MDs\n");
                goto cleanup;
        }

        /*
         * Cache the results of the diff
         */
        mdeg_get_diff_results(mdd, &mdeg_res);

        /* call the client callback */
        (void) (*clnt->cb)(clnt->cb_arg, &mdeg_res);

        MDEG_DBG("MDEG client callback done\n");

cleanup:
        if (mdd != MD_INVAL_DIFF_COOKIE)
                (void) md_diff_fini(mdd);
}

static mde_cookie_t
mdeg_find_start_node(md_t *md, mdeg_node_spec_t *nspec)
{
        mde_cookie_t            *nodesp;
        mde_str_cookie_t        nname;
        mde_str_cookie_t        aname;
        int                     nnodes;
        int                     idx;

        if ((md == NULL) || (nspec == NULL))
                return (MDE_INVAL_ELEM_COOKIE);

        nname = md_find_name(md, nspec->namep);
        aname = md_find_name(md, "fwd");

        nnodes = md_scan_dag(md, 0, nname, aname, NULL);
        if (nnodes == 0)
                return (MDE_INVAL_ELEM_COOKIE);

        nodesp = kmem_alloc(sizeof (mde_cookie_t) * nnodes, KM_SLEEP);

        (void) md_scan_dag(md, 0, nname, aname, nodesp);

        for (idx = 0; idx < nnodes; idx++) {

                if (mdeg_node_spec_match(md, nodesp[idx], nspec)) {
                        mde_cookie_t res = nodesp[idx];

                        kmem_free(nodesp, sizeof (mde_cookie_t) * nnodes);
                        return (res);
                }
        }

        kmem_free(nodesp, sizeof (mde_cookie_t) * nnodes);
        return (MDE_INVAL_ELEM_COOKIE);
}

static boolean_t
mdeg_node_spec_match(md_t *md, mde_cookie_t node, mdeg_node_spec_t *nspec)
{
        mdeg_prop_spec_t        *prop;

        ASSERT(md && nspec);
        ASSERT(node != MDE_INVAL_ELEM_COOKIE);

        prop = nspec->specp;

        while (prop->type != MDET_LIST_END) {

                switch (prop->type) {
                case MDET_PROP_VAL: {
                        uint64_t val;

                        if (md_get_prop_val(md, node, prop->namep, &val) != 0)
                                return (B_FALSE);

                        if (prop->ps_val != val)
                                return (B_FALSE);

                        break;
                }
                case MDET_PROP_STR: {
                        char    *str;

                        if (md_get_prop_str(md, node, prop->namep, &str) != 0)
                                return (B_FALSE);

                        if (strcmp(prop->ps_str, str) != 0)
                                return (B_FALSE);

                        break;
                }

                default:
                        return (B_FALSE);
                }

                prop++;
        }

        return (B_TRUE);
}

static void
mdeg_get_diff_results(md_diff_cookie_t mdd, mdeg_result_t *res)
{
        /*
         * Cache added nodes.
         */
        res->added.mdp = mdeg.md_curr;
        res->added.nelem = md_diff_added(mdd, &(res->added.mdep));

        if (res->added.nelem == -1) {
                bzero(&(res->added), sizeof (mdeg_diff_t));
        }

        /*
         * Cache removed nodes.
         */
        res->removed.mdp = mdeg.md_prev;
        res->removed.nelem = md_diff_removed(mdd, &(res->removed.mdep));

        if (res->removed.nelem == -1) {
                bzero(&(res->removed), sizeof (mdeg_diff_t));
        }

        /*
         * Cache matching node pairs.
         */
        res->match_curr.mdp = mdeg.md_curr;
        res->match_prev.mdp = mdeg.md_prev;
        res->match_curr.nelem = md_diff_matched(mdd, &(res->match_prev.mdep),
            &(res->match_curr.mdep));
        res->match_prev.nelem = res->match_curr.nelem;

        if (res->match_prev.nelem == -1) {
                bzero(&(res->match_prev), sizeof (mdeg_diff_t));
                bzero(&(res->match_curr), sizeof (mdeg_diff_t));
        }
}

#ifdef DEBUG
/*
 * Generate a string that represents the node specifier
 * structure. Clamp the string length if the specifier
 * structure contains too much information.
 *
 *      General form:
 *
 *              <nodename>:{<propname>=<propval>,...}
 *      e.g.
 *              vdevice:{name=vsw,reg=0x0}
 */
static void
mdeg_spec_str(mdeg_node_spec_t *spec, char *buf, int len)
{
        mdeg_prop_spec_t        *prop;
        int                     offset;
        boolean_t               first = B_TRUE;
        char                    *end = buf + len;

        offset = snprintf(buf, len, "%s:{", spec->namep);

        buf += offset;
        len -= offset;
        if (len <= 0)
                goto trunc;

        prop = spec->specp;

        while (prop->type != MDET_LIST_END) {

                switch (prop->type) {
                case MDET_PROP_VAL:
                        offset = snprintf(buf, len, "%s%s=0x%lx",
                            (first) ? "" : ",", prop->namep, prop->ps_val);
                        buf += offset;
                        len -= offset;
                        if (len <= 0)
                                goto trunc;
                        break;

                case MDET_PROP_STR:
                        offset = snprintf(buf, len, "%s%s=%s",
                            (first) ? "" : ",", prop->namep, prop->ps_str);
                        buf += offset;
                        len -= offset;
                        if (len <= 0)
                                goto trunc;
                        break;

                default:
                        (void) snprintf(buf, len, "}");
                        return;
                }

                if (first)
                        first = B_FALSE;
                prop++;
        }

        (void) snprintf(buf, len, "}");
        return;

trunc:
        /* string too long, truncate it */
        buf = end - (strlen(trunc_str) + 1);
        (void) sprintf(buf, trunc_str);
}

/*
 * Generate a string that represents the match structure.
 * Clamp the string length if the match structure contains
 * too much information.
 *
 *      General form:
 *
 *              <nodename>:{<propname>,...}
 *      e.g.
 *              nmatch=vport:{reg}
 */
static void
mdeg_match_str(mdeg_node_match_t *match, char *buf, int len)
{
        md_prop_match_t *prop;
        int             offset;
        boolean_t       first = B_TRUE;
        char            *end = buf + len;

        offset = snprintf(buf, len, "%s:{", match->namep);

        buf += offset;
        len -= offset;
        if (len <= 0)
                goto trunc;

        prop = match->matchp;

        while (prop->type != MDET_LIST_END) {
                offset = snprintf(buf, len, "%s%s", (first) ? "" : ",",
                    prop->namep);
                buf += offset;
                len -= offset;
                if (len <= 0)
                        goto trunc;

                if (first)
                        first = B_FALSE;
                prop++;
        }

        (void) snprintf(buf, len, "}");
        return;

trunc:
        /* string too long, truncate it */
        buf = end - (strlen(trunc_str) + 1);
        (void) sprintf(buf, trunc_str);
}

#define MAX_FIELD_STR   80

static void
mdeg_dump_clnt(mdeg_clnt_t *clnt)
{
        char    str[MAX_FIELD_STR] = "";

        if (!clnt->valid) {
                MDEG_DBG("  valid=B_FALSE\n");
                return;
        }

        if (clnt->pspec) {
                mdeg_spec_str(clnt->pspec, str, MAX_FIELD_STR);
                MDEG_DBG("  pspecp=%s\n", str);
        }

        if (clnt->nmatch) {
                mdeg_match_str(clnt->nmatch, str, MAX_FIELD_STR);
                MDEG_DBG("  nmatch=%s\n", str);
        }
}

static void
mdeg_dump_table(void)
{
        int             idx;
        mdeg_clnt_t     *clnt;

        for (idx = 0; idx < mdeg.maxclnts; idx++) {
                clnt = &(mdeg.tbl[idx]);

                MDEG_DBG("client %d (0x%lx):\n", idx, clnt->hdl);
                mdeg_dump_clnt(clnt);
        }
}
#endif /* DEBUG */