xref: /titanic_50/usr/src/uts/common/io/dedump.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"	/* SVr3.2H 	*/

/*
 * Dump STREAMS module.  Could be used anywhere on a stream to
 * print all message headers and data on to the console.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/errno.h>
#include <sys/cmn_err.h>
#include <sys/ddi.h>
#include <sys/strsun.h>

#include <sys/conf.h>
#include <sys/modctl.h>

static char	hdr[100];	/* current message header */
static char  	hdrpad[100];	/* pad of same length as hdr[] */

/*
 * Raw buffer dumping routine.  Displays the contents of the first message in
 * message chain `mp', using the "traditional" dump format.
 *
 * For instance, "Hello STREAMS, panicked lately?" would be displayed as:
 *
 * RD 30001dbb240 M_DATA 48656C6C 6F205354 5245414D 532C2070  Hello STREAMS, p
 *                       616E6963 6B656420 6C617465 6C793F    anicked lately?
 *
 * If the character being displayed is not printable, a '.' is shown.
 */

#define	DEDUMP_HEXPERBLK	4
#define	DEDUMP_HEXLEN		(sizeof ("11223344") * 4)
#define	DEDUMP_ASCLEN		(sizeof ("0123456789ABCDEF") - 1)

static void
dedump_raw(mblk_t *mp)
{
	char	hex[DEDUMP_HEXLEN + 1], asc[DEDUMP_ASCLEN + 1];
	int	hexi = 0, asci = 0, i = 0;
	uchar_t	c;
	char	*hdrp = hdr;

	hex[DEDUMP_HEXLEN] = '\0';

	for (;;) {
		if (i == MBLKL(mp) || (i != 0 && (i % DEDUMP_ASCLEN) == 0)) {
			/*
			 * We're either out of data or we've filled a complete
			 * line.  In either case, print out what we've got --
			 * but first NUL-terminate asc[] and pad out hex[]
			 * with spaces.
			 */
			asc[asci] = '\0';
			(void) memset(hex + hexi, ' ', DEDUMP_HEXLEN - hexi);
			(void) printf("%s %s %s\n", hdrp, hex, asc);

			/*
			 * If we're out of data, bail.  Otherwise, reset asci
			 * and hexi for another lap around.  Also, set hdrp to
			 * the pad since we only want to show the header once.
			 */
			if (i == MBLKL(mp))
				break;
			asci = 0;
			hexi = 0;
			hdrp = hdrpad;
		}

		c = mp->b_rptr[i++];

		hexi += snprintf(hex + hexi, 3, "%02X", c);
		if ((i % DEDUMP_HEXPERBLK) == 0)
			hex[hexi++] = ' ';
		asc[asci++] = (c >= 32 && c <= 126) ? c : '.';
	}
}

static void
dedump_char(mblk_t *mp)
{
	(void) printf("%s 0x%x\n", hdr, *(uchar_t *)mp->b_rptr);
}

static void
dedump_int(mblk_t *mp)
{
	(void) printf("%s %d\n", hdr, *(int *)mp->b_rptr);
}

static void
dedump_ssize(mblk_t *mp)
{
	(void) printf("%s %ld\n", hdr, *(ssize_t *)mp->b_rptr);
}

static void
dedump_iocblk(mblk_t *mp)
{
	struct iocblk *ic = (struct iocblk *)mp->b_rptr;

	(void) printf("%s cmd %x cred %p id %u flag %x count %ld rval %d "
	    "err %d\n", hdr, ic->ioc_cmd, (void *)ic->ioc_cr, ic->ioc_id,
	    ic->ioc_flag, ic->ioc_count, ic->ioc_rval, ic->ioc_error);
}

static void
dedump_stroptions(mblk_t *mp)
{
	struct stroptions *so = (struct stroptions *)mp->b_rptr;

	(void) printf("%s flag %x readopt %d wroff %u\n", hdr,
	    so->so_flags, so->so_readopt, so->so_wroff);

	(void) printf("%s minpsz %ld maxpsz %ld hiwat %lu lowat %lu\n", hdrpad,
	    so->so_minpsz, so->so_maxpsz, so->so_hiwat, so->so_lowat);

	(void) printf("%s band %u erropt %u maxblk %ld copyopt %u\n", hdrpad,
	    so->so_band, so->so_erropt, so->so_maxblk, so->so_copyopt);
}

static void
dedump_copyreq(mblk_t *mp)
{
	struct copyreq *cq = (struct copyreq *)mp->b_rptr;

	(void) printf("%s cmd %x cred %p id %u flag %x priv %p addr %p size "
	    "%lu\n", hdr, cq->cq_cmd, (void *)cq->cq_cr, cq->cq_id, cq->cq_flag,
	    (void *)cq->cq_private, (void *)cq->cq_addr, cq->cq_size);
}

static void
dedump_copyresp(mblk_t *mp)
{
	struct copyresp *cp = (struct copyresp *)mp->b_rptr;

	(void) printf("%s cmd %x cred %p id %u flag %x priv %p rval %p\n", hdr,
	    cp->cp_cmd, (void *)cp->cp_cr, cp->cp_id, cp->cp_flag,
	    (void *)cp->cp_private, (void *)cp->cp_rval);
}

typedef struct msgfmt {
	uchar_t	m_type;
	char	m_desc[15];
	void	(*m_print)(mblk_t *);
} msgfmt_t;

static msgfmt_t msgfmt[256] = {
	{	M_DATA,		"M_DATA    ", 	dedump_raw		},
	{	M_PROTO,	"M_PROTO   ", 	dedump_raw		},
	{	M_BREAK,	"M_BREAK   ", 	dedump_raw		},
	{	M_PASSFP,	"M_PASSFP  ", 	dedump_raw		},
	{	M_EVENT,	"M_EVENT   ", 	dedump_raw		},
	{	M_SIG,		"M_SIG     ", 	dedump_char		},
	{	M_DELAY,	"M_DELAY   ", 	dedump_int		},
	{	M_CTL,		"M_CTL     ", 	dedump_raw		},
	{	M_IOCTL,	"M_IOCTL   ", 	dedump_iocblk		},
	{	M_SETOPTS,	"M_SETOPTS ", 	dedump_stroptions	},
	{	M_RSE,		"M_RSE     ", 	dedump_raw		},
	{	M_IOCACK,	"M_IOCACK  ", 	dedump_iocblk		},
	{	M_IOCNAK,	"M_IOCNAK  ", 	dedump_iocblk		},
	{	M_PCPROTO,	"M_PCPROTO ", 	dedump_raw		},
	{	M_PCSIG,	"M_PCSIG   ", 	dedump_char		},
	{	M_READ,		"M_READ    ", 	dedump_ssize		},
	{	M_FLUSH,	"M_FLUSH   ", 	dedump_char		},
	{	M_STOP,		"M_STOP    ", 	dedump_raw		},
	{	M_START,	"M_START   ", 	dedump_raw		},
	{	M_HANGUP,	"M_HANGUP  ", 	dedump_raw		},
	{	M_ERROR,	"M_ERROR   ", 	dedump_char		},
	{	M_COPYIN,	"M_COPYIN  ", 	dedump_copyreq		},
	{	M_COPYOUT,	"M_COPYOUT ", 	dedump_copyreq		},
	{	M_IOCDATA,	"M_IOCDATA ", 	dedump_copyresp		},
	{	M_PCRSE,	"M_PCRSE   ", 	dedump_raw		},
	{	M_STOPI,	"M_STOPI   ", 	dedump_raw		},
	{	M_STARTI,	"M_STARTI  ", 	dedump_raw		},
	{	M_PCEVENT,	"M_PCEVENT ", 	dedump_raw		},
	{	M_UNHANGUP,	"M_UNHANGUP", 	dedump_raw		},
};

/*ARGSUSED1*/
static int
dedumpopen(queue_t *q, dev_t *devp, int oflag, int sflag, cred_t *crp)
{
	if (!sflag)
		return (ENXIO);

	if (q->q_ptr)
		return (0);		/* already attached */

	qprocson(q);
	return (0);
}

/*ARGSUSED1*/
static int
dedumpclose(queue_t *q, int flag, cred_t *crp)
{
	qprocsoff(q);
	return (0);
}

/*
 * Common put procedure for upstream and downstream.
 */
static int
dedumpput(queue_t *q, mblk_t *mp)
{
	unsigned char type = DB_TYPE(mp);
	ssize_t hdrlen;

	hdrlen = snprintf(hdr, sizeof (hdr), "%s %p %10s ",
	    (q->q_flag & QREADR) ? "RD" : "WR", (void *)q, msgfmt[type].m_desc);

	hdrpad[hdrlen] = '\0';
	msgfmt[type].m_print(mp);
	hdrpad[hdrlen] = ' ';

	putnext(q, mp);
	return (0);
}

struct module_info dedump_minfo = {
	0xaaa, "dedump", 0, INFPSZ, 0, 0
};

struct qinit dedumprinit = {
	dedumpput, NULL, dedumpopen, dedumpclose, NULL, &dedump_minfo, NULL
};

struct qinit dedumpwinit = {
	dedumpput, NULL, NULL, NULL, NULL, &dedump_minfo, NULL
};

struct streamtab dedumpinfo = {
	&dedumprinit, &dedumpwinit, NULL, NULL,
};

static struct fmodsw fsw = {
	"dedump",
	&dedumpinfo,
	D_MP | D_MTPERMOD	/* just to serialize printfs */
};

static struct modlstrmod modlstrmod = {
	&mod_strmodops, "dump streams module", &fsw
};

static struct modlinkage modlinkage = {
	MODREV_1, &modlstrmod, NULL
};

int
_init(void)
{
	int i;
	msgfmt_t mf;

	/*
	 * Sort msgfmt[] so that msgfmt[n] describes message type n.
	 */
	for (i = 255; i != 0; i--) {
		mf = msgfmt[i];
		msgfmt[i].m_type = i;
		(void) sprintf(msgfmt[i].m_desc, "M_BOGUS_0x%x", i);
		msgfmt[i].m_print = dedump_raw;
		if (mf.m_desc[0] != 0)
			msgfmt[mf.m_type] = mf;
	}

	/*
	 * Fill hdrpad[] with as many spaces as will fit.
	 */
	(void) memset(hdrpad, ' ', sizeof (hdrpad) - 1);
	hdrpad[sizeof (hdrpad) - 1] = '\0';

	return (mod_install(&modlinkage));
}

int
_fini(void)
{
	return (mod_remove(&modlinkage));
}

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