modules/genunix/mmd.c

	mmd.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * Multidata dcmds and walkers, part of the genunix mdb module,
 * and operate on core Multidata structures.
 */

#include <mdb/mdb_modapi.h>
#include <mdb/mdb_ks.h>

#include <sys/types.h>
#include <sys/strsubr.h>
#include <sys/strsun.h>
#include <sys/stream.h>
#include <sys/modctl.h>
#include <sys/strft.h>
#include <sys/sysmacros.h>

#include <sys/multidata.h>
#include <sys/multidata_impl.h>
#include <sys/pattr.h>

#include "mmd.h"

/*
 * Structure for passing internal variables.
 */
typedef struct mmd_data_s {
    uint_t  flags;      /* see flags values below */
    uint_t  counter;    /* scratch counter */
} mmd_data_t;

#define MMD_VERBOSE 0x1 /* multidata: provide more info */
#define MMD_STATS   0x2 /* multidata: provide statistics */
#define PD_HDR      0x4 /* pdesc: count header region */
#define PD_PLD      0x8 /* pdesc: count payload region(s) */
#define PD_ATTR     0x10    /* pdesc: count local attributes */
#define PD_REM_NOCNT    0x20    /* pdesc: do not count removed pdesc */

/*
 * Structure to support circular, doubly-linked list (ql_t) walker.
 */
typedef struct q_walk_s {
    char *qw_name;      /* name of opaque list structure */
    uintptr_t qw_head;  /* address of list head */
    void *qw_data;      /* opaque data structure */
    uint_t qw_sz;       /* size of opaque data structure */
    uint_t qw_off;      /* ql_t offset in opaque data structure */
    uint_t qw_step;     /* walk_step has been called */
    uint_t qw_iprint;   /* initial print */
} q_walk_t;

static int pdesc_slab_print(uintptr_t, q_walk_t *, mmd_data_t *);
static int pdesc_print(uintptr_t, q_walk_t *, mmd_data_t *);
static int pdesc_count(uintptr_t, q_walk_t *, mmd_data_t *);
static int pattr_print(uintptr_t, q_walk_t *, mmd_data_t *);
static int pattr_count(uintptr_t, q_walk_t *, mmd_data_t *);
static int multidata_stats(uintptr_t addr, multidata_t *);

#define VA_OFF(x, o)    (((uchar_t *)(x) + (o)))

/*
 * A dcmd which prints a summary of a multidata_t structure.
 */
/* ARGSUSED */
int
multidata(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    mmd_data_t data;
    multidata_t mmd;
    char str[32] = "-";
    int i = 0;

    bzero(&data, sizeof (data));
    if (!(flags & DCMD_ADDRSPEC) || mdb_getopts(argc, argv,
        'v', MDB_OPT_SETBITS, MMD_VERBOSE, &data.flags,
        's', MDB_OPT_SETBITS, MMD_STATS, &data.flags, NULL) != argc)
        return (DCMD_USAGE);

    if (mdb_vread(&mmd, sizeof (mmd), addr) == -1) {
        mdb_warn("failed to read multidata_t structure at %p", addr);
        return (DCMD_ERR);
    }

    if (mmd.mmd_magic != MULTIDATA_MAGIC)
        mdb_printf("Incorrect Multidata magic number at %p\n",
            VA_OFF(addr, offsetof(multidata_t, mmd_magic)));

    mdb_printf("\n");
    if (data.flags & MMD_STATS) {
        if ((i = multidata_stats(addr, &mmd)) != DCMD_OK)
            return (i);
    }

    mdb_printf("%<b>%-5s %-?s %-4s %-?s %-4s %-4s %-4s %-?s%</b>",
        "PDESC", "PATTBL", "HBUF", "HBUF", "PBUF", "PBUF", "PBUF", "PBUF");
    mdb_printf("\n");
    mdb_printf("%<b>%<u>%-5s %-?s %-4s %-?s %-4s %-4s %-4s %-?s%</u>%</b>",
        "CNT", "ADDRESS", "REF", "ADDRESS", "REF", "CNT", "IDX",
        "ADDRESS(ES)");
    mdb_printf("\n");

    if (mmd.mmd_pattbl != 0)
        mdb_snprintf(str, sizeof (str), "%016p", mmd.mmd_pattbl);

    i = 0;
    mdb_printf("%-5d %-16s %-4d %016p %-4d %-4d %-4d %016p\n",
        mmd.mmd_pd_cnt, str, mmd.mmd_hbuf_ref, mmd.mmd_hbuf,
        mmd.mmd_pbuf_ref, mmd.mmd_pbuf_cnt, i, mmd.mmd_pbuf[i]);

    for (++i; i < mmd.mmd_pbuf_cnt; i++)
        mdb_printf("%-54s %-4d %016p\n", "", i, mmd.mmd_pbuf[i]);

    if (!(data.flags & MMD_VERBOSE))
        return (DCMD_OK);

    /* Walk packet descriptor slab list */
    if (mdb_pwalk("pdesc_slab", (mdb_walk_cb_t)pdesc_slab_print,
        &data, (uintptr_t)VA_OFF(addr, offsetof(multidata_t,
        mmd_pd_slab_q))) == -1) {
        mdb_warn("couldn't walk pdesc_slab_t list");
        return (DCMD_ERR);
    }

    /* Walk packet descriptor list */
    data.counter = 0;
    if (mdb_pwalk("pdesc", (mdb_walk_cb_t)pdesc_print,
        &data, (uintptr_t)VA_OFF(addr, offsetof(multidata_t,
        mmd_pd_q))) == -1) {
        mdb_warn("couldn't walk pdesc_t list");
        return (DCMD_ERR);
    }

    return (DCMD_OK);
}

/*
 * Print additional Multidata statistics
 */
static int
multidata_stats(uintptr_t addr, multidata_t *mmd)
{
    mblk_t mp;
    uint_t i = 0, j = 0, k = 0, sz = 0;
    mmd_data_t data;
    uintptr_t patbkt;

    bzero(&data, sizeof (data));

    if (mmd->mmd_hbuf != 0) {
        if (mdb_vread(&mp, sizeof (mp),
            (uintptr_t)mmd->mmd_hbuf) == -1) {
            mdb_warn("couldn't read mblk_t at %p", mmd->mmd_hbuf);
            return (DCMD_ERR);
        }

        i++;
        sz = MBLKL(&mp);
    }

    k += sz;    /* total bytes */
    j += i;     /* total buffers */

    mdb_printf("%<b>%<u>BUFFER STATS%</b>%</u>\n");
    mdb_printf("Header:\t\t\t%-4d% buffer,\t%-12d bytes\n", i, sz);

    for (i = 0, sz = 0; i < mmd->mmd_pbuf_cnt; i++) {
        if (mdb_vread(&mp, sizeof (mp),
            (uintptr_t)mmd->mmd_pbuf[i]) == -1) {
            mdb_warn("couldn't read mblk_t at %p",
                mmd->mmd_pbuf[i]);
            return (DCMD_ERR);
        }
        sz += MBLKL(&mp);
    }

    k += sz;    /* total bytes */
    j += i;     /* total buffers */

    mdb_printf("%<u>Payload:\t\t%-4d buffers,\t%-12d bytes%</u>\n", i, sz);
    mdb_printf("Total:\t\t\t%-4d buffers,\t%-12d bytes\n\n", j, k);

    mdb_printf("%<b>%<u>PACKET DESCRIPTOR STATS%</u>%</b>\n");

    /*
     * Total claimed packet descriptors
     */
    data.flags = 0;
    data.counter = 0;
    if (mdb_pwalk("pdesc", (mdb_walk_cb_t)pdesc_count, &data,
        (uintptr_t)VA_OFF(addr, offsetof(multidata_t, mmd_pd_q))) == -1) {
        mdb_warn("couldn't walk pdesc_t list");
        return (DCMD_ERR);
    }
    i = data.counter;   /* claimed */
    mdb_printf("Total claimed:\t\t%-4d", i);

    /*
     * Total active header references
     */
    data.flags = (PD_HDR | PD_REM_NOCNT);
    data.counter = 0;
    if (mdb_pwalk("pdesc", (mdb_walk_cb_t)pdesc_count, &data,
        (uintptr_t)VA_OFF(addr, offsetof(multidata_t, mmd_pd_q))) == -1) {
        mdb_warn("couldn't walk pdesc_t list");
        return (DCMD_ERR);
    }
    mdb_printf("\tActive header refs:\t%-12d bytes\n", data.counter);

    /*
     * Total active packet descriptors
     */
    data.flags = PD_REM_NOCNT;
    data.counter = 0;
    if (mdb_pwalk("pdesc", (mdb_walk_cb_t)pdesc_count, &data,
        (uintptr_t)VA_OFF(addr, offsetof(multidata_t, mmd_pd_q))) == -1) {
        mdb_warn("couldn't walk pdesc_t list");
        return (DCMD_ERR);
    }
    k = data.counter;   /* active */
    mdb_printf("Active:\t\t\t%-4d", data.counter);

    /*
     * Total active payload references
     */
    data.flags = (PD_PLD | PD_REM_NOCNT);
    data.counter = 0;
    if (mdb_pwalk("pdesc", (mdb_walk_cb_t)pdesc_count, &data,
        (uintptr_t)VA_OFF(addr, offsetof(multidata_t, mmd_pd_q))) == -1) {
        mdb_warn("couldn't walk pdesc_t list");
        return (DCMD_ERR);
    }
    mdb_printf("\t%<u>Active payload refs:\t%-12d bytes%</u>\n",
        data.counter);

    /*
     * Number of removed packet descriptors (claimed - active)
     */
    mdb_printf("Removed:\t\t%-4d", i - k);

    /*
     * Total active header and payload references
     */
    data.flags = (PD_PLD | PD_HDR | PD_REM_NOCNT);
    data.counter = 0;
    if (mdb_pwalk("pdesc", (mdb_walk_cb_t)pdesc_count, &data,
        (uintptr_t)VA_OFF(addr, offsetof(multidata_t, mmd_pd_q))) == -1) {
        mdb_warn("couldn't walk pdesc_t list");
        return (DCMD_ERR);
    }
    mdb_printf("\tTotal:\t\t\t%-12d bytes\n\n", data.counter);

    mdb_printf("%<b>%<u>ACTIVE ATTRIBUTE STATS%</u>%</b>\n");

    /*
     * Count local attributes
     */
    data.flags = (PD_ATTR | PD_REM_NOCNT);
    data.counter = 0;
    if (mdb_pwalk("pdesc", (mdb_walk_cb_t)pdesc_count, &data,
        (uintptr_t)VA_OFF(addr, offsetof(multidata_t, mmd_pd_q))) == -1) {
        mdb_warn("couldn't walk pdesc_t list");
        return (DCMD_ERR);
    }
    mdb_printf("Local:\t\t\t%-4d", data.counter);

    /*
     * Count global attributes
     */
    data.counter = 0;
    patbkt = (uintptr_t)mmd->mmd_pattbl;
    if (patbkt != 0) {
        uint_t pattbl_sz;

        /* Figure out the size of hash table */
        mdb_readvar(&pattbl_sz, "pattbl_sz");

        /* Walk each bucket and count its contents */
        for (i = 0; i < (pattbl_sz * sizeof (patbkt_t));
            i += sizeof (patbkt_t)) {
            if (mdb_pwalk("pattr",
                (mdb_walk_cb_t)pattr_count, &data,
                patbkt + i + offsetof(patbkt_t,
                pbkt_pattr_q)) == -1) {
                mdb_warn("couldn't walk pattr_t list");
                return (DCMD_ERR);
            }
        }
    }
    mdb_printf("\tGlobal:\t\t\t%-4d\n", data.counter);
    mdb_printf("\n");

    return (DCMD_OK);
}

/*
 * Print the contents of a packet descriptor slab (pdesc_slab_t) structure.
 */
/* ARGSUSED */
static int
pdesc_slab_print(uintptr_t addr, q_walk_t *qwp, mmd_data_t *data)
{
    pdesc_slab_t *slab;
    uint_t pdslab_sz, slab_sz;

    /* Figure out how many descriptors in a slab */
    mdb_readvar(&pdslab_sz, "pdslab_sz");

    /* This shouldn't be true, unless something awful has happened */
    if (pdslab_sz < 1) {
        mdb_warn("incorrect pdslab_sz (0)");
        pdslab_sz = 1;
    }

    /* Read in the entire slab chunk; may be of use one day */
    slab_sz = PDESC_SLAB_SIZE(pdslab_sz);
    slab = mdb_alloc(slab_sz, UM_SLEEP);

    if (mdb_vread(slab, slab_sz, addr) == -1) {
        mdb_free(slab, slab_sz);
        mdb_warn("failed to read pdesc_slab_t at %p", addr);
        return (WALK_ERR);
    }

    if (!qwp->qw_step)
        mdb_printf("\n%<b>%<u>%-?s %7s %7s%</u>%</b>\n",
            "PDESC SLAB ADDR", "SIZE", "CLAIMED");

    mdb_printf("%016p %7d %7d\n", addr, slab->pds_sz, slab->pds_used);

    mdb_free(slab, slab_sz);

    return (WALK_NEXT);
}

/*
 * Generic packet descriptor (pdesc_t) counting routine.
 */
/* ARGSUSED */
static int
pdesc_count(uintptr_t addr, q_walk_t *qwp, mmd_data_t *data)
{
    pdesc_t pd;
    int i;
    uint_t f = data->flags;

    if (mdb_vread(&pd, sizeof (pd), addr) == -1) {
        mdb_warn("failed to read pdesc_t at %p", addr);
        return (WALK_ERR);
    }

    if (pd.pd_magic != PDESC_MAGIC)
        mdb_printf("Incorrect pdesc magic number at %p\n",
            VA_OFF(addr, offsetof(pdesc_t, pd_magic)));

    if (f == 0) {
        /* No flags set, count all pdescs */
        data->counter++;
    } else if (f == PD_REM_NOCNT && !(pd.pd_pdi.flags & PDESC_REM_DEFER)) {
        /* Count only active (skip removed) pdescs */
        data->counter++;
    } else if (f & PD_ATTR) {
        uint_t pattbl_sz;
        uintptr_t patbkt = (uintptr_t)pd.pd_pattbl;
        mmd_data_t attr_data;

        /* Count local attributes */
        if ((!(f & PD_REM_NOCNT) || ((f & PD_REM_NOCNT) &&
            !(pd.pd_pdi.flags & PDESC_REM_DEFER))) && patbkt != 0) {

            /* Figure out the size of hash table */
            mdb_readvar(&pattbl_sz, "pattbl_sz");

            attr_data.counter = 0;
            /* Walk each bucket and count its contents */
            for (i = 0; i < (pattbl_sz * sizeof (patbkt_t));
                i += sizeof (patbkt_t)) {
                if (mdb_pwalk("pattr",
                    (mdb_walk_cb_t)pattr_count, &attr_data,
                    patbkt + i + offsetof(patbkt_t,
                    pbkt_pattr_q)) == -1) {
                    mdb_warn("couldn't walk pattr_t list");
                    return (WALK_ERR);
                }
            }
            data->counter += attr_data.counter;
        }
    } else {
        if (f & PD_HDR) {
            /* Count header span referenced by pdesc */
            if (!(f & PD_REM_NOCNT) || ((f & PD_REM_NOCNT) &&
                !(pd.pd_pdi.flags & PDESC_REM_DEFER)))
                data->counter += PDESC_HDRL(&pd.pd_pdi);
        }

        if (f & PD_PLD) {
            /* Count payload span referenced by pdesc */
            if (!(f & PD_REM_NOCNT) || ((f & PD_REM_NOCNT) &&
                !(pd.pd_pdi.flags & PDESC_REM_DEFER))) {
                for (i = 0; i < pd.pd_pdi.pld_cnt; i++)
                    data->counter += PDESC_PLD_SPAN_SIZE(
                        &pd.pd_pdi, i);
            }
        }
    }

    return (WALK_NEXT);
}

/*
 * Print the contents of a packet descriptor (pdesc_t) structure.
 */
/* ARGSUSED */
static int
pdesc_print(uintptr_t addr, q_walk_t *qwp, mmd_data_t *data)
{
    pdesc_t pd;
    int i = 0;
    char str[32] = "-";
    static const mdb_bitmask_t pd_flags_bits[] = {
        { "H", PDESC_HBUF_REF, PDESC_HBUF_REF },
        { "P", PDESC_PBUF_REF, PDESC_PBUF_REF },
        { "R", PDESC_REM_DEFER, PDESC_REM_DEFER },
        { NULL, 0, 0 }
    };

    if (mdb_vread(&pd, sizeof (pd), addr) == -1) {
        mdb_warn("failed to read pdesc_t at %p", addr);
        return (WALK_ERR);
    }

    if (pd.pd_magic != PDESC_MAGIC)
        mdb_printf("Incorrect pdesc magic number at %p\n",
            VA_OFF(addr, offsetof(pdesc_t, pd_magic)));

    if (!qwp->qw_step) {
        mdb_printf("\n");
        mdb_printf("%<b>%-3s %-16s %-16s %-4s %-4s %-4s %-4s %-4s %-4s "
            "%-4s %-6s%</b>",
            "", "PDESC", "PATTBL", "HDR", "HDR",
            "HDR", "HDR", "PLD", "PBUF", "PLD", "");
        mdb_printf("\n");
        mdb_printf(
            "%<b>%<u>%-3s %-16s %-16s %-4s %-4s %-4s %-4s %-4s %-4s "
            "%-4s %-6s%</u>%</b>",
            "NO.", "ADDRESS", "ADDRESS", "SIZE", "HEAD",
            "LEN", "TAIL", "CNT", "IDX", "SIZE", "FLAGS");
        mdb_printf("\n");
    }

    if (pd.pd_pattbl != 0)
        mdb_snprintf(str, sizeof (str), "%016p", pd.pd_pattbl);

    mdb_printf("%-3d %016p %-16s %-4d %-4d %-4d %-4d %-4d %-4d %-4d %-6b\n",
        ++data->counter, addr, str,
        PDESC_HDRSIZE(&pd.pd_pdi), PDESC_HDRHEAD(&pd.pd_pdi),
        PDESC_HDRL(&pd.pd_pdi), PDESC_HDRTAIL(&pd.pd_pdi),
        pd.pd_pdi.pld_cnt, pd.pd_pdi.pld_ary[i].pld_pbuf_idx,
        PDESC_PLD_SPAN_SIZE(&pd.pd_pdi, i), pd.pd_pdi.flags, pd_flags_bits);

    for (++i; i < pd.pd_pdi.pld_cnt; i++)
        mdb_printf("%-62s %-4d %-4d\n",
            "", pd.pd_pdi.pld_ary[i].pld_pbuf_idx,
            PDESC_PLD_SPAN_SIZE(&pd.pd_pdi, i));

    return (WALK_NEXT);
}

/*
 * General purpose ql_t walk_init routine.
 */
static int
mmdq_walk_init(mdb_walk_state_t *wsp, char *name, uintptr_t qh,
    uint_t sz, uint_t ql_off)
{
    q_walk_t *qwp;
    ql_t ql;

    /* Caller must have supplied an address */
    if (wsp->walk_addr == NULL)
        return (WALK_ERR);

    qwp = mdb_alloc(sizeof (*qwp), UM_SLEEP);
    qwp->qw_name = name;
    qwp->qw_head = qh;
    qwp->qw_data = sz > 0 ? mdb_alloc(sz, UM_SLEEP) : NULL;
    qwp->qw_sz = sz;
    qwp->qw_off = ql_off;
    qwp->qw_step = FALSE;
    qwp->qw_iprint = TRUE;

    wsp->walk_data = qwp;

    if (mdb_vread(qwp->qw_data, qwp->qw_sz, wsp->walk_addr) == -1) {
        mdb_warn("failed to read %s at %p", qwp->qw_name,
            wsp->walk_addr);
        mmdq_walk_fini(wsp);
        return (WALK_ERR);
    }

    bcopy((uchar_t *)qwp->qw_data + qwp->qw_off, &ql, sizeof (ql));
    if (qh == (uintptr_t)ql.ql_next) {
        mmdq_walk_fini(wsp);
        return (WALK_DONE);
    }

    wsp->walk_addr = (uintptr_t)ql.ql_next;

    return (WALK_NEXT);
}

/*
 * General purpose ql_t walk_step routine.
 */
int
mmdq_walk_step(mdb_walk_state_t *wsp)
{
    q_walk_t *qwp = (q_walk_t *)wsp->walk_data;
    int status = WALK_NEXT;
    ql_t ql;

    /* We've wrapped around the circular list */
    if (qwp->qw_step && wsp->walk_addr == qwp->qw_head)
        return (WALK_DONE);

    status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
        wsp->walk_cbdata);

    if (mdb_vread(qwp->qw_data, qwp->qw_sz, wsp->walk_addr) == -1) {
        mdb_warn("failed to read %s at %p", qwp->qw_name,
            wsp->walk_addr);
        return (WALK_ERR);
    }

    /* Go forward to the next one */
    bcopy((uchar_t *)qwp->qw_data + qwp->qw_off, &ql, sizeof (ql));
    wsp->walk_addr = (uintptr_t)ql.ql_next;

    /* We've done the first walk */
    qwp->qw_step = TRUE;

    return (status);
}

/*
 * General purpose ql_t walk_fini routine.
 */
void
mmdq_walk_fini(mdb_walk_state_t *wsp)
{
    q_walk_t *qwp = (q_walk_t *)wsp->walk_data;

    if (qwp->qw_data != NULL)
        mdb_free(qwp->qw_data, qwp->qw_sz);

    mdb_free(qwp, sizeof (*qwp));
}

/*
 * Packet descriptor slab (pdesc_slab_t) walker initialization routine.
 */
int
pdesc_slab_walk_init(mdb_walk_state_t *wsp)
{
    uintptr_t q_head;

    if (wsp->walk_addr == NULL)
        return (WALK_DONE);

    /*
     * If we're called from multidata dcmd, then we're passed in
     * the address of ql_t head; otherwise we'd have to get the
     * address ourselves.
     */
    if (wsp->walk_cbdata == NULL) {
        pdesc_slab_t slab;

        /* Read in pdesc_slab_t */
        if (mdb_vread(&slab, sizeof (slab), wsp->walk_addr) == -1) {
            mdb_warn("failed to read pdesc_slab_t at %p",
                wsp->walk_addr);
            return (WALK_ERR);
        }

        /* pdesc_slab_t head is inside multidata_t */
        q_head = (uintptr_t)VA_OFF(slab.pds_mmd,
            offsetof(multidata_t, mmd_pd_slab_q));
    } else
        q_head = wsp->walk_addr;

    /* Pass it on to our generic ql_t walker init */
    return (mmdq_walk_init(wsp, "pdesc_slab_t", q_head,
        sizeof (pdesc_slab_t), offsetof(pdesc_slab_t, pds_next)));
}

/*
 * A dcmd which returns a multidata_t pointer from a pdesc_slab_t structure.
 */
/* ARGSUSED */
int
slab2multidata(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    pdesc_slab_t slab;

    if (!(flags & DCMD_ADDRSPEC) || argc != 0)
        return (DCMD_USAGE);

    if (mdb_vread(&slab, sizeof (slab), addr) == -1) {
        mdb_warn("couldn't read pdesc_slab_t at %p", addr);
        return (DCMD_ERR);
    }

    mdb_printf("%p\n", slab.pds_mmd);

    return (DCMD_OK);
}

/*
 * Packet descriptor (pdesc_t) walker initialization routine.
 */
int
pdesc_walk_init(mdb_walk_state_t *wsp)
{
    uintptr_t q_head;

    if (wsp->walk_addr == NULL)
        return (WALK_DONE);

    /*
     * If we're called from multidata dcmd, then we're passed in
     * the address of ql_t head; otherwise we'd have to get the
     * address ourselves.
     */
    if (wsp->walk_cbdata == NULL) {
        pdesc_t pd;
        pdesc_slab_t slab;

        /* First we get pdsec_t */
        if (mdb_vread(&pd, sizeof (pd), wsp->walk_addr) == -1) {
            mdb_warn("failed to read pdesc_t at %p",
                wsp->walk_addr);
            return (WALK_ERR);
        }

        /* And then the pdesc_slab_t */
        if (mdb_vread(&slab, sizeof (slab),
            (uintptr_t)pd.pd_slab) == -1) {
            mdb_warn("failed to read pdesc_slab_t at %p",
                (uintptr_t)pd.pd_slab);
            return (WALK_ERR);
        }

        /* pdesc_t head is inside multidata_t */
        q_head = (uintptr_t)VA_OFF(slab.pds_mmd,
            offsetof(multidata_t, mmd_pd_q));
    } else
        q_head = wsp->walk_addr;

    /* Pass it on to our generic ql_t walker init */
    return (mmdq_walk_init(wsp, "pdesc_t", q_head,
        sizeof (pdesc_t), offsetof(pdesc_t, pd_next)));
}

/*
 * A dcmd which prints the attribute hash table.
 */
/* ARGSUSED */
int
pattbl(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    mmd_data_t data;
    uint_t pattbl_sz;
    int i, j;

    bzero(&data, sizeof (data));
    if (!(flags & DCMD_ADDRSPEC) || argc != 0)
        return (DCMD_USAGE);

    /* Figure out the size of hash table */
    mdb_readvar(&pattbl_sz, "pattbl_sz");

    mdb_printf("\n");
    mdb_printf("%<b>%<u>%-3s %-16s %-16s %-12s %-3s %-16s %-5s%</u>%</b>\n",
        "BKT", "PATBKT ADDR", "PATTR ADDR", "TYPE", "LEN", "BUF ADDR",
        "FLAGS");

    /* Walk each bucket and print its contents */
    for (i = 0, j = 0; i < (pattbl_sz * sizeof (patbkt_t));
        i += sizeof (patbkt_t)) {

        mdb_printf("%-3d %016p ", j++, addr + i);

        if (mdb_pwalk("pattr", (mdb_walk_cb_t)pattr_print, &data,
            addr + i + offsetof(patbkt_t, pbkt_pattr_q)) == -1) {
            mdb_warn("couldn't walk pattr_t list");
            return (DCMD_ERR);
        }
        mdb_printf("\n");
    }
    mdb_printf("\n");

    return (DCMD_OK);
}

typedef struct pattr_type_s {
    char *name; /* attribute name */
    uint_t type;    /* attribute type value */
} pattr_type_t;

/*
 * Generic packet attribute (pattr_t) counting routine.
 */
/* ARGSUSED */
static int
pattr_count(uintptr_t addr, q_walk_t *qwp, mmd_data_t *data)
{
    pattr_t pattr;

    if (mdb_vread(&pattr, sizeof (pattr), addr) == -1) {
        mdb_warn("failed to read pattr_t at %p", addr);
        return (WALK_ERR);
    }

    if (pattr.pat_magic != PATTR_MAGIC)
        mdb_printf("Incorrect pattr magic number at %p\n",
            VA_OFF(addr, offsetof(pattr_t, pat_magic)));

    data->counter++;

    return (WALK_NEXT);
}

/*
 * Print the contents of a packet attribute (pattr_t) structure.
 */
/* ARGSUSED */
static int
pattr_print(uintptr_t addr, q_walk_t *qwp, mmd_data_t *data)
{
    pattr_t pattr;
    int i;
    char *pa_name = "UNKNOWN";
    static const pattr_type_t pa_type[] = {
        { "DSTADDRSAP", PATTR_DSTADDRSAP },
        { "SRCADDRSAP", PATTR_SRCADDRSAP },
        { "HCKSUM", PATTR_HCKSUM }
    };
    static const mdb_bitmask_t pa_flags_bits[] = {
        { "R", PATTR_REM_DEFER, PATTR_REM_DEFER },
        { "P", PATTR_PERSIST, PATTR_PERSIST },
        { NULL, 0, 0 }
    };

    if (mdb_vread(&pattr, sizeof (pattr), addr) == -1) {
        mdb_warn("failed to read pattr_t at %p", addr);
        return (WALK_ERR);
    }

    if (pattr.pat_magic != PATTR_MAGIC)
        mdb_printf("Incorrect pattr magic number at %p\n",
            VA_OFF(addr, offsetof(pattr_t, pat_magic)));

    /* Find a matching string */
    for (i = 0; i < (sizeof (pa_type) / sizeof (*pa_type)); i++) {
        if (pa_type[i].type == pattr.pat_type)
            pa_name = pa_type[i].name;
    }

    if (!qwp->qw_iprint) {
        mdb_printf("\n");
        mdb_inc_indent(21);
    }

    mdb_printf("%016p %x:%-10s %-3d %016p %-5b", addr, pattr.pat_type,
        pa_name, pattr.pat_buflen - sizeof (pattr), addr + sizeof (pattr),
        pattr.pat_flags, pa_flags_bits);

    if (!qwp->qw_iprint)
        mdb_dec_indent(21);
    else
        qwp->qw_iprint = FALSE;

    return (WALK_NEXT);
}

/*
 * Packet attribute (pattr_t) walker initialization routine.
 */
int
pattr_walk_init(mdb_walk_state_t *wsp)
{
    uintptr_t q_head;

    if (wsp->walk_addr == NULL)
        return (WALK_DONE);

    /*
     * If we're called from pattbl dcmd, then we're passed in
     * the address of ql_t head; otherwise we'd have to get the
     * address ourselves.
     */
    if (wsp->walk_cbdata == NULL) {
        pattr_t pattr;

        if (mdb_vread(&pattr, sizeof (pattr), wsp->walk_addr) == -1) {
            mdb_warn("failed to read pattr_t at %p",
                wsp->walk_addr);
            return (WALK_ERR);
        }

        q_head = (uintptr_t)VA_OFF(pattr.pat_lock,
            -offsetof(patbkt_t, pbkt_lock)) +
            offsetof(patbkt_t, pbkt_pattr_q);
    } else
        q_head = wsp->walk_addr;

    /* Pass it on to our generic ql_t walker init */
    return (mmdq_walk_init(wsp, "pattr_t", q_head,
        sizeof (pattr_t), offsetof(pattr_t, pat_next)));
}

/*
 * A dcmd which returns a multidata_t pointer from a pattr_t.
 */
/* ARGSUSED */
int
pattr2multidata(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    pattr_t pattr;

    if (!(flags & DCMD_ADDRSPEC) || argc != 0)
        return (DCMD_USAGE);

    if (mdb_vread(&pattr, sizeof (pattr), addr) == -1) {
        mdb_warn("couldn't read pattr_t at %p", addr);
        return (DCMD_ERR);
    }

    if (pattr.pat_magic != PATTR_MAGIC) {
        mdb_warn("Incorrect pattr magic number at %p",
            VA_OFF(addr, offsetof(pattr_t, pat_magic)));
        return (DCMD_ERR);
    }

    mdb_printf("%p\n", pattr.pat_mmd);

    return (DCMD_OK);
}

/*
 * A dcmd which returns a pdesc_slab_t from a pdesc_t.
 */
/* ARGSUSED */
int
pdesc2slab(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    pdesc_t pd;

    if (!(flags & DCMD_ADDRSPEC) || argc != 0)
        return (DCMD_USAGE);

    if (mdb_vread(&pd, sizeof (pd), addr) == -1) {
        mdb_warn("couldn't read pdesc_t at %p", addr);
        return (DCMD_ERR);
    }

    if (pd.pd_magic != PDESC_MAGIC) {
        mdb_warn("Incorrect pdesc magic number at %p",
            VA_OFF(addr, offsetof(pdesc_t, pd_magic)));
        return (DCMD_ERR);
    }

    mdb_printf("%p\n", pd.pd_slab);

    return (DCMD_OK);
}

/*
 * A dcmd which verifies the integrity of a pdesc_t.
 */
/* ARGSUSED */
int
pdesc_verify(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    multidata_t mmd;
    pdesc_t pd;
    pdescinfo_t *pdi = &pd.pd_pdi;
    pdesc_slab_t slab;
    mblk_t hbuf, pbuf[MULTIDATA_MAX_PBUFS];
    uint_t i, idx;
    boolean_t valid = B_TRUE;
    struct pld_ary_s *pa;

    if (!(flags & DCMD_ADDRSPEC) || argc != 0)
        return (DCMD_USAGE);

    if (mdb_vread(&pd, sizeof (pd), addr) == -1) {
        mdb_warn("couldn't read pdesc_t at %p", addr);
        return (DCMD_ERR);
    }

    if (pd.pd_magic != PDESC_MAGIC) {
        mdb_warn("Incorrect pdesc magic number at %p\n",
            VA_OFF(addr, offsetof(pdesc_t, pd_magic)));
        return (DCMD_ERR);
    }

    if (mdb_vread(&slab, sizeof (slab), (uintptr_t)pd.pd_slab) == -1) {
        mdb_warn("couldn't read pdesc_slab_t at %p", pd.pd_slab);
        return (DCMD_ERR);
    }

    if (mdb_vread(&mmd, sizeof (mmd), (uintptr_t)slab.pds_mmd) == -1) {
        mdb_warn("couldn't read multidata_t at %p", slab.pds_mmd);
        return (DCMD_ERR);
    }

    if (mmd.mmd_magic != MULTIDATA_MAGIC)
        mdb_printf("Incorrect Multidata magic number at %p\n",
            VA_OFF(slab.pds_mmd, offsetof(multidata_t, mmd_magic)));

    if (mmd.mmd_hbuf != 0 &&
        mdb_vread(&hbuf, sizeof (hbuf), (uintptr_t)mmd.mmd_hbuf) == -1) {
        mdb_warn("couldn't read mblk_t at %p", mmd.mmd_hbuf);
        return (DCMD_ERR);
    }

    if (mmd.mmd_pbuf_cnt > MULTIDATA_MAX_PBUFS) {
        mdb_warn("Multidata pbuf count exceeds %d\n",
            MULTIDATA_MAX_PBUFS);
        return (DCMD_ERR);
    } else if (pdi->pld_cnt > mmd.mmd_pbuf_cnt) {
        mdb_warn("descriptor pbuf count exceeds Multidata "
            "pbuf count %d\n", mmd.mmd_pbuf_cnt);
        return (DCMD_ERR);
    }

    if (mmd.mmd_pbuf_cnt > 0) {
        for (i = 0; i < mmd.mmd_pbuf_cnt; i++) {
            if (mdb_vread(&pbuf[i], sizeof (mblk_t),
                (uintptr_t)mmd.mmd_pbuf[i]) == -1) {
                mdb_warn("couldn't read mblk_t at %p",
                    mmd.mmd_pbuf[i]);
                return (DCMD_ERR);
            }
        }
    }

    /* It should have at least one buffer reference */
    if (!(pdi->flags & PDESC_HAS_REF)) {
        mdb_warn("descriptor has no buffer reference indicator "
            "in flags (0x%x)\n", pdi->flags);
        return (DCMD_ERR);
    } else if (!(pdi->flags & PDESC_PBUF_REF) && pdi->pld_cnt > 0) {
        mdb_warn("descriptor has no pbuf reference indicator in "
            "flags (0x%x); but pld_cnt is %d\n", pdi->flags,
            pdi->pld_cnt);
        return (DCMD_ERR);
    }

    /* Bounds check the header fragment, if any */
    if (!((pdi->flags & PDESC_HBUF_REF) && pdi->hdr_rptr != 0 &&
        pdi->hdr_wptr != 0 && pdi->hdr_base != 0 &&
        pdi->hdr_lim != 0 && pdi->hdr_lim >= pdi->hdr_base &&
        pdi->hdr_wptr >= pdi->hdr_rptr && pdi->hdr_base <= pdi->hdr_rptr &&
        pdi->hdr_lim >= pdi->hdr_wptr && pdi->hdr_base >= hbuf.b_rptr &&
        MBLKIN(&hbuf, (pdi->hdr_base - hbuf.b_rptr),
        PDESC_HDRSIZE(pdi)))) {
        mdb_warn("descriptor has invalid header fragment\n");
        return (DCMD_ERR);
    }

    i = 0;
    pa = &pdi->pld_ary[0];
    /* Bounds check the payload fragment, if any */
    while (valid && i < pdi->pld_cnt) {
        valid = (((idx = pa->pld_pbuf_idx) < mmd.mmd_pbuf_cnt) &&
            pa->pld_rptr != NULL && pa->pld_wptr != NULL &&
            pa->pld_wptr >= pa->pld_rptr &&
            pa->pld_rptr >= pbuf[idx].b_rptr &&
            MBLKIN(&pbuf[idx], (pa->pld_rptr - pbuf[idx].b_rptr),
            PDESC_PLD_SPAN_SIZE(pdi, i)));

        if (!valid) {
            mdb_warn("descriptor has invalid payload fragment\n");
            return (DCMD_ERR);
        }

        /* advance to next entry */
        i++;
        pa++;
    }

    return (DCMD_OK);
}