xref: /onnv-gate/usr/src/cmd/mdb/sparc/modules/intr/intr.c (revision 11513:b68f438a1f7f)

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

#include <sys/mdb_modapi.h>
#include <mdb/mdb_ks.h>
#include <sys/async.h>		/* ecc_flt for pci_ecc.h */
#include <sys/ddi_subrdefs.h>
#include <sys/pci/pci_obj.h>
#include "niumx_var.h"
#include "px_obj.h"

static int intr_pci_walk_step(mdb_walk_state_t *);
static int intr_px_walk_step(mdb_walk_state_t *);
static int intr_niumx_walk_step(mdb_walk_state_t *);
static void intr_pci_print_items(mdb_walk_state_t *);
static void intr_px_print_items(mdb_walk_state_t *);
static char *intr_get_intr_type(uint16_t type);
static void intr_print_banner(void);

typedef struct intr_info {
	uint32_t	cpuid;
	uint32_t	inum;
	uint32_t	num;
	uint32_t	pil;
	uint16_t	intr_type;
	uint16_t	mondo;
	uint8_t		ino_ino;
	uint_t		intr_state;
	int		instance;
	int		shared;
	char		driver_name[12];
	char		pathname[MAXNAMELEN];
}
intr_info_t;

#define	PX_MAX_ENTRIES		32

static void intr_print_elements(intr_info_t);
static int detailed = 0; /* Print detailed view */


static int
intr_walk_init(mdb_walk_state_t *wsp)
{
	wsp->walk_addr = NULL;

	return (WALK_NEXT);
}

static int
intr_walk_step(mdb_walk_state_t *wsp)
{
	pci_t		*pci_per_p;
	px_t		*px_state_p;
	niumx_devstate_t *niumx_state_p;

	/* read globally declared structures in the pci driver */
	if (mdb_readvar(&pci_per_p, "per_pci_state") != -1) {
		wsp->walk_addr = (uintptr_t)pci_per_p;
		intr_pci_walk_step(wsp);
	}

	/* read globally declared structures in the px driver */
	if (mdb_readvar(&px_state_p, "px_state_p") != -1) {
		wsp->walk_addr = (uintptr_t)px_state_p;
		intr_px_walk_step(wsp);
	}

	/* read globally declared structures in the niumx driver */
	if (mdb_readvar(&niumx_state_p, "niumx_state") != -1) {
		wsp->walk_addr = (uintptr_t)niumx_state_p;
		intr_niumx_walk_step(wsp);
	}

	return (WALK_DONE);
}

static int
intr_pci_walk_step(mdb_walk_state_t *wsp)
{
	pci_t		*pci_per_p;
	pci_t		pci_per;
	uintptr_t	start_addr;

	/* Read start of state structure array */
	if (mdb_vread(&pci_per_p, sizeof (uintptr_t),
	    (uintptr_t)wsp->walk_addr) == -1) {
		mdb_warn("intr: failed to read the initial pci_per_p "
		    "structure\n");
		return (WALK_ERR);
	}

	/* Figure out how many items are here */
	start_addr = (uintptr_t)pci_per_p;

	intr_print_banner();

	while (mdb_vread(&pci_per_p, sizeof (uintptr_t),
	    (uintptr_t)start_addr) != -1) {
		/* Read until nothing is left */
		if (mdb_vread(&pci_per, sizeof (pci_t),
		    (uintptr_t)pci_per_p) == -1) {
			return (WALK_DONE);
		}

		wsp->walk_addr = (uintptr_t)pci_per.pci_ib_p;
		intr_pci_print_items(wsp);

		start_addr += sizeof (uintptr_t);
	}

	return (WALK_DONE);
}

static int
intr_px_walk_step(mdb_walk_state_t *wsp)
{
	px_t		*px_state_p;
	px_t		px_state;
	uintptr_t	start_addr;
	int		x;

	/* Read start of state structure array */
	if (mdb_vread(&px_state_p, sizeof (uintptr_t),
	    (uintptr_t)wsp->walk_addr) == -1) {
		mdb_warn("intr: failed to read the initial px_per_p "
		    "structure\n");
		return (WALK_ERR);
	}

	/* Figure out how many items are here */
	start_addr = (uintptr_t)px_state_p;

	intr_print_banner();

	for (x = 0; x < PX_MAX_ENTRIES; x++) {
		(void) mdb_vread(&px_state_p, sizeof (uintptr_t),
		    (uintptr_t)start_addr);

		start_addr += sizeof (uintptr_t);

		/* Read if anything is there */
		if (mdb_vread(&px_state, sizeof (px_t),
		    (uintptr_t)px_state_p) == -1) {
			continue;
		}

		wsp->walk_addr = (uintptr_t)px_state.px_ib_p;
		intr_px_print_items(wsp);
	}

	return (WALK_DONE);
}

static int
intr_niumx_walk_step(mdb_walk_state_t *wsp)
{
	niumx_devstate_t *niumx_state_p;
	niumx_devstate_t niumx_state;
	uintptr_t	start_addr;
	char		name[MODMAXNAMELEN + 1];
	struct dev_info	dev;
	intr_info_t	info;
	int		i;

	/* Read start of state structure array */
	if (mdb_vread(&niumx_state_p, sizeof (uintptr_t),
	    (uintptr_t)wsp->walk_addr) == -1) {
		mdb_warn("intr: failed to read the initial niumx_state_p "
		    "structure\n");
		return (WALK_ERR);
	}

	/* Figure out how many items are here */
	start_addr = (uintptr_t)niumx_state_p;

	while (mdb_vread(&niumx_state_p, sizeof (uintptr_t),
	    (uintptr_t)start_addr) >= 0) {

		start_addr += sizeof (uintptr_t);

		/* Read if anything is there */
		if (mdb_vread(&niumx_state, sizeof (niumx_devstate_t),
		    (uintptr_t)niumx_state_p) == -1) {
			return (WALK_DONE);
		}

		for (i = 0; i < NIUMX_MAX_INTRS; i++) {
			if (niumx_state.niumx_ihtable[i].ih_sysino == 0)
				continue;

			if (niumx_state.niumx_ihtable[i].ih_dip == 0)
				continue;

			bzero((void *)&info, sizeof (intr_info_t));

			info.shared = 0;

			(void) mdb_devinfo2driver(
			    (uintptr_t)niumx_state.niumx_ihtable[i].ih_dip,
			    name, sizeof (name));

			(void) mdb_ddi_pathname(
			    (uintptr_t)niumx_state.niumx_ihtable[i].ih_dip,
			    info.pathname, sizeof (info.pathname));

			/* Get instance */
			if (mdb_vread(&dev, sizeof (struct dev_info),
			    (uintptr_t)niumx_state.niumx_ihtable[i].ih_dip) ==
			    -1) {
				mdb_warn("intr: failed to read DIP "
				    "structure\n");

				return (WALK_DONE);
			}

			/* Make sure the name doesn't over run */
			(void) mdb_snprintf(info.driver_name,
			    sizeof (info.driver_name), "%s", name);

			info.instance = dev.devi_instance;
			info.inum = niumx_state.niumx_ihtable[i].ih_inum;
			info.intr_type = DDI_INTR_TYPE_FIXED;
			info.num = 0;
			info.intr_state = niumx_state.niumx_ihtable[i].ih_state;
			info.ino_ino = i;
			info.mondo = niumx_state.niumx_ihtable[i].ih_sysino;
			info.pil = niumx_state.niumx_ihtable[i].ih_pri;
			info.cpuid = niumx_state.niumx_ihtable[i].ih_cpuid;

			intr_print_elements(info);
		}
	}

	return (WALK_DONE);
}

static void
intr_pci_print_items(mdb_walk_state_t *wsp)
{
	ib_t			ib;
	ib_ino_info_t		ino;
	ib_ino_pil_t		ipil;
	ih_t			ih;
	int			count;
	char			name[MODMAXNAMELEN + 1];
	struct dev_info		dev;
	intr_info_t		info;

	if (mdb_vread(&ib, sizeof (ib_t),
	    (uintptr_t)wsp->walk_addr) == -1) {
		mdb_warn("intr: failed to read pci interrupt block "
		    "structure\n");
		return;
	}

	/* Read in ib_ino_info_t structure at address */
	if (mdb_vread(&ino, sizeof (ib_ino_info_t),
	    (uintptr_t)ib.ib_ino_lst) == -1) {
		/* Nothing here to read from */
		return;
	}

	do {
		if (mdb_vread(&ipil, sizeof (ib_ino_pil_t),
		    (uintptr_t)ino.ino_ipil_p) == -1) {
			mdb_warn("intr: failed to read pci interrupt "
			    "ib_ino_pil_t structure\n");
			return;
		}

		do {
			if (mdb_vread(&ih, sizeof (ih_t),
			    (uintptr_t)ipil.ipil_ih_start) == -1) {
				mdb_warn("intr: failed to read pci interrupt "
				    "ih_t structure\n");
				return;
			}

			count = 0;

			do {
				bzero((void *)&info, sizeof (intr_info_t));

				if ((ino.ino_ipil_size > 1) ||
				    (ipil.ipil_ih_size > 1)) {
					info.shared = 1;
				}

				(void) mdb_devinfo2driver((uintptr_t)ih.ih_dip,
				    name, sizeof (name));

				(void) mdb_ddi_pathname((uintptr_t)ih.ih_dip,
				    info.pathname, sizeof (info.pathname));

				/* Get instance */
				if (mdb_vread(&dev, sizeof (struct dev_info),
				    (uintptr_t)ih.ih_dip) == -1) {
					mdb_warn("intr: failed to read DIP "
					    "structure\n");
					return;
				}

				/* Make sure the name doesn't over run */
				(void) mdb_snprintf(info.driver_name,
				    sizeof (info.driver_name), "%s", name);

				info.instance = dev.devi_instance;
				info.inum = ih.ih_inum;
				info.intr_type = DDI_INTR_TYPE_FIXED;
				info.num = 0;
				info.intr_state = ih.ih_intr_state;
				info.ino_ino = ino.ino_ino;
				info.mondo = ino.ino_mondo;
				info.pil = ipil.ipil_pil;
				info.cpuid = ino.ino_cpuid;

				intr_print_elements(info);
				count++;

				(void) mdb_vread(&ih, sizeof (ih_t),
				    (uintptr_t)ih.ih_next);

			} while (count < ipil.ipil_ih_size);

		} while (mdb_vread(&ipil, sizeof (ib_ino_pil_t),
		    (uintptr_t)ipil.ipil_next_p) != -1);

	} while (mdb_vread(&ino, sizeof (ib_ino_info_t),
	    (uintptr_t)ino.ino_next_p) != -1);
}

static void
intr_px_print_items(mdb_walk_state_t *wsp)
{
	px_ib_t		ib;
	px_ino_t	ino;
	px_ino_pil_t	ipil;
	px_ih_t		ih;
	int		count;
	char		name[MODMAXNAMELEN + 1];
	struct dev_info	dev;
	intr_info_t	info;
	devinfo_intr_t	intr_p;

	if (mdb_vread(&ib, sizeof (px_ib_t), wsp->walk_addr) == -1) {
		return;
	}

	/* Read in px_ino_t structure at address */
	if (mdb_vread(&ino, sizeof (px_ino_t),
	    (uintptr_t)ib.ib_ino_lst) == -1) {
		/* Nothing here to read from */
		return;
	}

	do { /* ino_next_p loop */
		if (mdb_vread(&ipil, sizeof (px_ino_pil_t),
		    (uintptr_t)ino.ino_ipil_p) == -1) {
			continue;
		}

		do { /* ipil_next_p loop */
			if (mdb_vread(&ih, sizeof (px_ih_t),
			    (uintptr_t)ipil.ipil_ih_start) == -1) {
				continue;
			}

			count = 0;

			do { /* ipil_ih_size loop */
				bzero((void *)&info, sizeof (intr_info_t));

				(void) mdb_devinfo2driver((uintptr_t)ih.ih_dip,
				    name, sizeof (name));

				(void) mdb_ddi_pathname((uintptr_t)ih.ih_dip,
				    info.pathname, sizeof (info.pathname));

				/* Get instance */
				if (mdb_vread(&dev, sizeof (struct dev_info),
				    (uintptr_t)ih.ih_dip) == -1) {
					mdb_warn("intr: failed to read DIP "
					    "structure\n");
					return;
				}

				/* Make sure the name doesn't over run */
				(void) mdb_snprintf(info.driver_name,
				    sizeof (info.driver_name), "%s", name);

				info.instance = dev.devi_instance;
				info.inum = ih.ih_inum;

				/*
				 * Read the type used, keep PCIe messages
				 * separate.
				 */
				(void) mdb_vread(&intr_p,
				    sizeof (devinfo_intr_t),
				    (uintptr_t)dev.devi_intr_p);

				if (ih.ih_rec_type != MSG_REC) {
					info.intr_type =
					    intr_p.devi_intr_curr_type;
				}

				if ((ino.ino_ipil_size > 1) ||
				    (ipil.ipil_ih_size > 1)) {
					info.shared = 1;
				}

				info.num = ih.ih_msg_code;
				info.intr_state = ih.ih_intr_state;
				info.ino_ino = ino.ino_ino;
				info.mondo = ino.ino_sysino;
				info.pil = ipil.ipil_pil;
				info.cpuid = ino.ino_cpuid;

				intr_print_elements(info);
				count++;

				(void) mdb_vread(&ih, sizeof (px_ih_t),
				    (uintptr_t)ih.ih_next);

			} while (count < ipil.ipil_ih_size);

		} while ((ipil.ipil_next_p != NULL) &&
		    (mdb_vread(&ipil, sizeof (px_ino_pil_t),
		    (uintptr_t)ipil.ipil_next_p) != -1));

	} while ((ino.ino_next_p != NULL) && (mdb_vread(&ino, sizeof (px_ino_t),
	    (uintptr_t)ino.ino_next_p) != -1));
}

static char *
intr_get_intr_type(uint16_t type)
{
	switch (type) {
		case	DDI_INTR_TYPE_FIXED:
			return ("Fixed");
		case	DDI_INTR_TYPE_MSI:
			return ("MSI");
		case	DDI_INTR_TYPE_MSIX:
			return ("MSI-X");
		default:
			return ("PCIe");
	}
}

static void
intr_print_banner(void)
{
	if (!detailed) {
		mdb_printf("\n%<u>\tDevice\t"
		    " Type\t"
		    " MSG #\t"
		    " State\t"
		    " INO\t"
		    " Mondo\t"
		    " Shared\t"
		    "  Pil\t"
		    " CPU   %</u>"
		    "\n");
	}
}

static void
intr_print_elements(intr_info_t info)
{
	if (!detailed) {
		mdb_printf(" %11s#%d\t", info.driver_name, info.instance);
		mdb_printf(" %s\t", intr_get_intr_type(info.intr_type));
		if (info.intr_type == DDI_INTR_TYPE_FIXED) {
			mdb_printf("  --- \t");
		} else {
			mdb_printf(" %4d\t", info.num);
		}
		mdb_printf(" %2s\t",
		    info.intr_state ? "enbl" : "disbl");
		mdb_printf(" 0x%x\t", info.ino_ino);
		mdb_printf(" 0x%x\t", info.mondo);
		mdb_printf(" %5s\t",
		    info.shared ? "yes" : "no");
		mdb_printf(" %4d\t", info.pil);
		mdb_printf(" %3d \n", info.cpuid);
	} else {
		mdb_printf("\n-------------------------------------------\n");
		mdb_printf("Device:\t\t%s\n", info.driver_name);
		mdb_printf("Instance:\t%d\n", info.instance);
		mdb_printf("Path:\t\t%s\n", info.pathname);
		mdb_printf("Inum:\t\t%d\n", info.inum);
		mdb_printf("Interrupt Type:\t%s\n",
		    intr_get_intr_type(info.intr_type));
		if (info.intr_type == DDI_INTR_TYPE_MSI) {
			mdb_printf("MSI Number:\t%d\n", info.num);
		} else if (info.intr_type == DDI_INTR_TYPE_MSIX) {
			mdb_printf("MSI-X Number:\t%d\n", info.num);
		} else if (!info.intr_type) {
			mdb_printf("PCIe Message #:\t%d\n", info.num);
		}

		mdb_printf("Shared Intr:\t%s\n",
		    info.shared ? "yes" : "no");
		mdb_printf("State:\t\t%d (%s)\n", info.intr_state,
		    info.intr_state ? "Enabled" : "Disabled");
		mdb_printf("INO:\t\t0x%x\n", info.ino_ino);
		mdb_printf("Mondo:\t\t0x%x\n", info.mondo);
		mdb_printf("Pil:\t\t%d\n", info.pil);
		mdb_printf("CPU:\t\t%d\n", info.cpuid);
	}
}

/*ARGSUSED*/
static void
intr_walk_fini(mdb_walk_state_t *wsp)
{
	/* Nothing to do here */
}

/*ARGSUSED*/
static int
intr_intr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	detailed = 0;

	if (mdb_getopts(argc, argv, 'd', MDB_OPT_SETBITS, TRUE, &detailed,
	    NULL) != argc)
		return (DCMD_USAGE);

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("interrupts", "interrupts", argc, argv)
		    == -1) {
			mdb_warn("can't walk pci/px buffer entries\n");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	return (DCMD_OK);
}

/*
 * MDB module linkage information:
 */

static const mdb_dcmd_t dcmds[] = {
	{ "interrupts", "[-d]", "display the interrupt info registered with "
	    "the PCI/PX nexus drivers", intr_intr },
	{ NULL }
};

static const mdb_walker_t walkers[] = {
	{ "interrupts", "walk PCI/PX interrupt structures",
		intr_walk_init, intr_walk_step, intr_walk_fini },
	{ NULL }
};

static const mdb_modinfo_t modinfo = {
	MDB_API_VERSION, dcmds, walkers
};

const mdb_modinfo_t *
_mdb_init(void)
{
	return (&modinfo);
}