Esempio n. 1
0
/*
 * dcmd ::ksidlist - display a ksidlist_t
 */
int
cmd_ksidlist(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	ksidlist_t ksl;
	ksid_t ks;
	uint_t i, opts = FALSE;
	int rv = DCMD_OK;

	if (mdb_getopts(argc, argv,
	    'v', MDB_OPT_SETBITS, OPT_VERBOSE, &opts, NULL) != argc)
		return (DCMD_USAGE);

	if (!(flags & DCMD_ADDRSPEC)) {
		return (DCMD_USAGE);
	}

	if (mdb_vread(&ksl, sizeof (ksl), addr) == -1) {
		mdb_warn("error reading ksidlist_t at %p", addr);
		return (DCMD_ERR);
	}

	if (opts & OPT_VERBOSE) {
		mdb_printf("ksl_ref = 0x%x\n", ksl.ksl_ref);
		mdb_printf("ksl_nsid = 0x%x\n", ksl.ksl_nsid);
		mdb_printf("ksl_neid = 0x%x\n", ksl.ksl_neid);
	}

	mdb_printf("ksl_sids = [\n");
	addr += OFFSETOF(ksidlist_t, ksl_sids);
	mdb_inc_indent(4);
	for (i = 0; i < ksl.ksl_nsid; i++, addr += sizeof (ksid_t)) {
		if (mdb_vread(&ks, sizeof (ks), addr) == -1) {
			mdb_warn("error reading ksid_t at %p", addr);
			rv = DCMD_ERR;
			break;
		}
		print_ksid(&ks);
	}
	mdb_dec_indent(4);
	mdb_printf("]\n");

	return (rv);
}
Esempio n. 2
0
/* ARGSUSED */
static int
sv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	clock_t clock;
	int maj, min, mic, baseline, i;

	if (argc != 0)
		return (DCMD_USAGE);

	if (mdb_readvar(&maj, "sv_major_rev") == -1) {
		mdb_warn("unable to read 'sv_major_rev'");
		return (DCMD_ERR);
	}

	if (mdb_readvar(&min, "sv_minor_rev") == -1) {
		mdb_warn("unable to read 'sv_minor_rev'");
		return (DCMD_ERR);
	}

	if (mdb_readvar(&mic, "sv_micro_rev") == -1) {
		mdb_warn("unable to read 'sv_micro_rev'");
		return (DCMD_ERR);
	}

	if (mdb_readvar(&baseline, "sv_baseline_rev") == -1) {
		mdb_warn("unable to read 'sv_baseline_rev'");
		return (DCMD_ERR);
	}

	mdb_printf("SV module version: kernel %d.%d.%d.%d; mdb %d.%d.%d.%d\n",
	    maj, min, mic, baseline,
	    ISS_VERSION_MAJ, ISS_VERSION_MIN, ISS_VERSION_MIC, ISS_VERSION_NUM);
	mdb_inc_indent(4);

	sv_get_print(sv_config_time, "last config time", "0x%lx", clock);
	sv_get_print(sv_stats_on, "stats on", "%d", i);
	sv_get_print(sv_debug, "debug", "%d", i);
	sv_get_print(sv_max_devices, "max sv devices", "%d", i);

	mdb_dec_indent(4);
	return (DCMD_OK);
}
Esempio n. 3
0
/*
 * dcmd ::credgrp - display cred_t groups
 */
int
cmd_credgrp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	credgrp_t grps;
	gid_t gid;
	uint_t i, opts = FALSE;
	int rv = DCMD_OK;

	if (mdb_getopts(argc, argv,
	    'v', MDB_OPT_SETBITS, OPT_VERBOSE, &opts, NULL) != argc)
		return (DCMD_USAGE);

	if (!(flags & DCMD_ADDRSPEC)) {
		return (DCMD_USAGE);
	}

	if (mdb_vread(&grps, sizeof (grps), addr) == -1) {
		mdb_warn("error reading credgrp_t at %p", addr);
		return (DCMD_ERR);
	}

	if (opts & OPT_VERBOSE) {
		mdb_printf("crg_ref = 0x%x\n", grps.crg_ref);
		mdb_printf("crg_ngroups = 0x%x\n", grps.crg_ngroups);
	}
	mdb_printf("crg_groups = [\n");

	addr += OFFSETOF(credgrp_t, crg_groups);
	mdb_inc_indent(4);
	for (i = 0; i < grps.crg_ngroups; i++, addr += sizeof (gid_t)) {
		if (mdb_vread(&gid, sizeof (gid), addr) == -1) {
			mdb_warn("error reading gid_t at %p", addr);
			rv = DCMD_ERR;
			break;
		}
		mdb_printf("\t%u,", gid);
	}
	mdb_dec_indent(4);
	mdb_printf("\n]\n");

	return (rv);
}
Esempio n. 4
0
/*ARGSUSED*/
static int
ii_fd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    ii_fd_t fd;

    if (!(flags & DCMD_ADDRSPEC))
        return (DCMD_USAGE);

    if (mdb_vread(&fd, sizeof (fd), addr) != sizeof (fd)) {
        mdb_warn("failed to read ii_fd_t at 0x%p", addr);
        return (DCMD_ERR);
    }

    mdb_inc_indent(4);
    mdb_printf("ii_info: 0x%p ii_bmp: %d ii_shd: %d ii_ovr: %d ii_optr: "
               "0x%p\nii_oflags: 0x%x\n", fd.ii_info, fd.ii_bmp, fd.ii_shd,
               fd.ii_ovr, fd.ii_optr, fd.ii_oflags);
    mdb_dec_indent(4);

    return (DCMD_OK);
}
Esempio n. 5
0
/* ARGSUSED */
static int
ii(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    int maj, min, mic, baseline, i;

    if (argc != 0)
        return (DCMD_USAGE);

    if (mdb_readvar(&maj, "dsw_major_rev") == -1) {
        mdb_warn("unable to read 'dsw_major_rev'");
        return (DCMD_ERR);
    }

    if (mdb_readvar(&min, "dsw_minor_rev") == -1) {
        mdb_warn("unable to read 'dsw_minor_rev'");
        return (DCMD_ERR);
    }

    if (mdb_readvar(&mic, "dsw_micro_rev") == -1) {
        mdb_warn("unable to read 'dsw_micro_rev'");
        return (DCMD_ERR);
    }

    if (mdb_readvar(&baseline, "dsw_baseline_rev") == -1) {
        mdb_warn("unable to read 'dsw_baseline_rev'");
        return (DCMD_ERR);
    }

    mdb_printf("Point-in-Time Copy module version: kernel %d.%d.%d.%d; "
               "mdb %d.%d.%d.%d\n", maj, min, mic, baseline,
               ISS_VERSION_MAJ, ISS_VERSION_MIN, ISS_VERSION_MIC, ISS_VERSION_NUM);

    mdb_inc_indent(4);
    ii_get_print(ii_debug, "debug", "%d", i);
    ii_get_print(ii_bitmap, "bitmaps", "%d", i);
    mdb_dec_indent(4);

    return (DCMD_OK);
}
Esempio n. 6
0
static int
fmd_xprt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	uint_t opt_s = FALSE, opt_l = FALSE, opt_r = FALSE, opt_u = FALSE;
	fmd_xprt_impl_t xi;

	if (mdb_getopts(argc, argv,
	    'l', MDB_OPT_SETBITS, TRUE, &opt_l,
	    'r', MDB_OPT_SETBITS, TRUE, &opt_r,
	    's', MDB_OPT_SETBITS, TRUE, &opt_s,
	    'u', MDB_OPT_SETBITS, TRUE, &opt_u, NULL) != argc)
		return (DCMD_USAGE);

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("fmd_xprt", "fmd_xprt", argc, argv) != 0) {
			mdb_warn("failed to walk fmd_xprt");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (mdb_vread(&xi, sizeof (xi), addr) != sizeof (xi)) {
		mdb_warn("failed to read fmd_xprt at %p", addr);
		return (DCMD_ERR);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%<u>%-8s %-4s %-4s %-5s %s%</u>\n",
		    "ADDR", "ID", "VERS", "FLAGS", "STATE");
	}

	mdb_printf("%-8p %-4d %-4u %-5x %a\n",
	    addr, xi.xi_id, xi.xi_version, xi.xi_flags, xi.xi_state);

	if (opt_l | opt_s) {
		(void) mdb_inc_indent(4);
		mdb_printf("Local subscriptions requested by peer:\n");
		mdb_printf("%<u>%-8s %-4s %s%</u>\n", "ADDR", "REFS", "CLASS");
		(void) mdb_pwalk("fmd_xprt_class", fmd_xprt_class, &xi,
		    addr + OFFSETOF(fmd_xprt_impl_t, xi_lsub));
		(void) mdb_dec_indent(4);
	}

	if (opt_r | opt_s) {
		(void) mdb_inc_indent(4);
		mdb_printf("Remote subscriptions requested of peer:\n");
		mdb_printf("%<u>%-8s %-4s %s%</u>\n", "ADDR", "REFS", "CLASS");
		(void) mdb_pwalk("fmd_xprt_class", fmd_xprt_class, &xi,
		    addr + OFFSETOF(fmd_xprt_impl_t, xi_rsub));
		(void) mdb_dec_indent(4);
	}

	if (opt_u | opt_s) {
		(void) mdb_inc_indent(4);
		mdb_printf("Pending unsubscription acknowledgements:\n");
		mdb_printf("%<u>%-8s %-4s %s%</u>\n", "ADDR", "REFS", "CLASS");
		(void) mdb_pwalk("fmd_xprt_class", fmd_xprt_class, &xi,
		    addr + OFFSETOF(fmd_xprt_impl_t, xi_usub));
		(void) mdb_dec_indent(4);
	}

	return (DCMD_OK);
}
Esempio n. 7
0
int
zoneprt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	zone_t zn;
	char name[ZONE_NAMELEN];
	char path[ZONE_PATHLEN];
	int len;
	uint_t vopt_given;
	uint_t ropt_given;

	if (argc > 2)
		return (DCMD_USAGE);

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("zone", "zone", argc, argv) == -1) {
			mdb_warn("can't walk zones");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	/*
	 * Get the optional -r (reference counts) and -v (verbose output)
	 * arguments.
	 */
	vopt_given = FALSE;
	ropt_given = FALSE;
	if (argc > 0 && mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE,
	    &vopt_given, 'r', MDB_OPT_SETBITS, TRUE, &ropt_given, NULL) != argc)
		return (DCMD_USAGE);

	/*
	 * -v can only be specified with -r.
	 */
	if (vopt_given == TRUE && ropt_given == FALSE)
		return (DCMD_USAGE);

	/*
	 * Print a table header, if necessary.
	 */
	if (DCMD_HDRSPEC(flags)) {
		if (ropt_given == FALSE)
			mdb_printf("%<u>%?s %6s %-13s %-20s %-s%</u>\n",
			    "ADDR", "ID", "STATUS", "NAME", "PATH");
		else
			mdb_printf("%<u>%?s %6s %10s %10s %-20s%</u>\n",
			    "ADDR", "ID", "REFS", "CREFS", "NAME");
	}

	/*
	 * Read the zone_t structure at the given address and read its name.
	 */
	if (mdb_vread(&zn, sizeof (zone_t), addr) == -1) {
		mdb_warn("can't read zone_t structure at %p", addr);
		return (DCMD_ERR);
	}
	len = mdb_readstr(name, ZONE_NAMELEN, (uintptr_t)zn.zone_name);
	if (len > 0) {
		if (len == ZONE_NAMELEN)
			(void) strcpy(&name[len - 4], "...");
	} else {
		(void) strcpy(name, "??");
	}

	if (ropt_given == FALSE) {
		char *statusp;

		/*
		 * Default display
		 * Fetch the zone's path and print the results.
		 */
		len = mdb_readstr(path, ZONE_PATHLEN,
		    (uintptr_t)zn.zone_rootpath);
		if (len > 0) {
			if (len == ZONE_PATHLEN)
				(void) strcpy(&path[len - 4], "...");
		} else {
			(void) strcpy(path, "??");
		}
		if (zn.zone_status >= ZONE_IS_UNINITIALIZED && zn.zone_status <=
		    ZONE_IS_DEAD)
			statusp = zone_status_names[zn.zone_status];
		else
			statusp = "???";
		mdb_printf("%0?p %6d %-13s %-20s %s\n", addr, zn.zone_id,
		    statusp, name, path);
	} else {
		/*
		 * Display the zone's reference counts.
		 * Display the zone's subsystem-specific reference counts if
		 * the user specified the '-v' option.
		 */
		mdb_printf("%0?p %6d %10u %10u %-20s\n", addr, zn.zone_id,
		    zn.zone_ref, zn.zone_cred_ref, name);
		if (vopt_given == TRUE) {
			GElf_Sym subsys_names_sym;
			uintptr_t **zone_ref_subsys_names;
			uint_t num_subsys;
			uint_t n;

			/*
			 * Read zone_ref_subsys_names from the kernel image.
			 */
			if (mdb_lookup_by_name("zone_ref_subsys_names",
			    &subsys_names_sym) != 0) {
				mdb_warn("can't find zone_ref_subsys_names");
				return (DCMD_ERR);
			}
			if (subsys_names_sym.st_size != ZONE_REF_NUM_SUBSYS *
			    sizeof (char *)) {
				mdb_warn("number of subsystems in target "
				    "differs from what mdb expects (mismatched"
				    " kernel versions?)");
				if (subsys_names_sym.st_size <
				    ZONE_REF_NUM_SUBSYS * sizeof (char *))
					num_subsys = subsys_names_sym.st_size /
					    sizeof (char *);
				else
					num_subsys = ZONE_REF_NUM_SUBSYS;
			} else {
				num_subsys = ZONE_REF_NUM_SUBSYS;
			}
			if ((zone_ref_subsys_names = mdb_alloc(
			    subsys_names_sym.st_size, UM_GC)) == NULL) {
				mdb_warn("out of memory");
				return (DCMD_ERR);
			}
			if (mdb_readvar(zone_ref_subsys_names,
			    "zone_ref_subsys_names") == -1) {
				mdb_warn("can't find zone_ref_subsys_names");
				return (DCMD_ERR);
			}

			/*
			 * Display each subsystem's reference count if it's
			 * nonzero.
			 */
			mdb_inc_indent(7);
			for (n = 0; n < num_subsys; ++n) {
				char subsys_name[16];

				/*
				 * Skip subsystems lacking outstanding
				 * references.
				 */
				if (zn.zone_subsys_ref[n] == 0)
					continue;

				/*
				 * Each subsystem's name must be read from
				 * the target's image.
				 */
				if (mdb_readstr(subsys_name,
				    sizeof (subsys_name),
				    (uintptr_t)zone_ref_subsys_names[n]) ==
				    -1) {
					mdb_warn("unable to read subsystem name"
					    " from zone_ref_subsys_names[%u]",
					    n);
					return (DCMD_ERR);
				}
				mdb_printf("%15s: %10u\n", subsys_name,
				    zn.zone_subsys_ref[n]);
			}
			mdb_dec_indent(7);
		}
	}
	return (DCMD_OK);
}
Esempio n. 8
0
int
zsd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	zone_t zone;
	const mdb_arg_t *argp;
	int argcindex;
	struct zsd_cb_data cbd;
	char name[ZONE_NAMELEN];
	int len;

	/*
	 * Walk all zones if necessary.
	 */
	if (argc > 2)
		return (DCMD_USAGE);
	if ((flags & DCMD_ADDRSPEC) == 0) {
		if (mdb_walk_dcmd("zone", "zsd", argc, argv) == -1) {
			mdb_warn("failed to walk zone\n");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	/*
	 * Make sure a zone_t can be read from the specified address.
	 */
	if (mdb_vread(&zone, sizeof (zone), addr) == -1) {
		mdb_warn("couldn't read zone_t at %p", (void *)addr);
		return (DCMD_ERR);
	}

	/*
	 * Get the optional arguments (key or -v or both).  Note that
	 * mdb_getopts() will not parse a key argument because it is not
	 * preceded by an option letter.  We'll get around this by requiring
	 * that all options precede the optional key argument.
	 */
	cbd.keygiven = FALSE;
	cbd.voptgiven = FALSE;
	if (argc > 0 && (argcindex = mdb_getopts(argc, argv, 'v',
	    MDB_OPT_SETBITS, TRUE, &cbd.voptgiven, NULL)) != argc) {
		/*
		 * No options may appear after the key.
		 */
		if (argcindex != argc - 1)
			return (DCMD_USAGE);

		/*
		 * The missed argument should be a key.
		 */
		argp = &argv[argcindex];
		if (argp->a_type == MDB_TYPE_IMMEDIATE)
			cbd.key = argp->a_un.a_val;
		else
			cbd.key = mdb_strtoull(argp->a_un.a_str);
		cbd.keygiven = TRUE;
		cbd.found = FALSE;
	}

	/*
	 * Prepare to output the specified zone's ZSD information.
	 */
	if (DCMD_HDRSPEC(flags))
		mdb_printf("%<u>%-20s %?s %?s %8s%</u>\n", "ZONE", "KEY",
		    "VALUE", "FLAGS");
	len = mdb_readstr(name, ZONE_NAMELEN, (uintptr_t)zone.zone_name);
	if (len > 0) {
		if (len == ZONE_NAMELEN)
			(void) strcpy(&name[len - 4], "...");
	} else {
		(void) strcpy(name, "??");
	}
	mdb_printf("%-20s ", name);

	/*
	 * Display the requested ZSD entries.
	 */
	mdb_inc_indent(21);
	if (mdb_pwalk("zsd", zsd_print, &cbd, addr) != 0) {
		mdb_warn("failed to walk zsd\n");
		mdb_dec_indent(21);
		return (DCMD_ERR);
	}
	if (cbd.keygiven == TRUE && cbd.found == FALSE) {
		mdb_printf("no corresponding ZSD entry found\n");
		mdb_dec_indent(21);
		return (DCMD_ERR);
	}
	mdb_dec_indent(21);
	return (DCMD_OK);
}
Esempio n. 9
0
/*ARGSUSED*/
int
nvpair_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	nvpair_t	nvpair_tmp, *nvpair;
	int32_t		i, size, nelem, elem_size = 0;
	char		*data = NULL, *data_end = NULL;
	char		*type_name = NULL;
	data_type_t	type = DATA_TYPE_UNKNOWN;
	int		quiet = FALSE;
	int		recurse = FALSE;

	if (!(flags & DCMD_ADDRSPEC))
		return (DCMD_USAGE);

	if (mdb_getopts(argc, argv,
	    'r', MDB_OPT_SETBITS, TRUE, &recurse,
	    'q', MDB_OPT_SETBITS, TRUE, &quiet,
	    NULL) != argc)
		return (DCMD_USAGE);

	/* read in the nvpair header so we can get the size */
	if (mdb_vread(&nvpair_tmp, sizeof (nvpair), addr) == -1) {
		mdb_warn("failed to read nvpair at %p", addr);
		return (DCMD_ERR);
	}
	size = NVP_SIZE(&nvpair_tmp);
	if (size == 0) {
		mdb_warn("nvpair of size zero at %p", addr);
		return (DCMD_OK);
	}

	/* read in the entire nvpair */
	nvpair = mdb_alloc(size, UM_SLEEP | UM_GC);
	if (mdb_vread(nvpair, size, addr) == -1) {
		mdb_warn("failed to read nvpair and data at %p", addr);
		return (DCMD_ERR);
	}

	/* lookup type decoding information for this nvpair */
	type = NVP_TYPE(nvpair);
	nelem = NVP_NELEM(nvpair);
	for (i = 0; i < NELEM(nvpair_info); i++) {
		if (nvpair_info[i].type == type) {
			elem_size = nvpair_info[i].elem_size;
			type_name = nvpair_info[i].type_name;
			break;
		}
	}

	if (quiet) {
		mdb_printf("%s", NVP_NAME(nvpair));
	} else {
		/* print out the first line of nvpair info */
		mdb_printf("name='%s'", NVP_NAME(nvpair));
		if (type_name != NULL) {
			mdb_printf(" type=%s", type_name);
		} else {
			/*
			 * If the nvpair type is unknown we print the type
			 * number
			 */
			mdb_printf(" type=0x%x", type);
		}
		mdb_printf(" items=%d\n", nelem);
	}

	/* if there is no data and the type is known then we're done */
	if ((nelem == 0) && (type_name != NULL)) {
		if (quiet)
			mdb_printf("(unknown)\n");
		return (DCMD_OK);
	}

	/* get pointers to the data to print out */
	data = (char *)NVP_VALUE(nvpair);
	data_end = (char *)nvpair + NVP_SIZE(nvpair);

	/*
	 * The value of the name-value pair for a single embedded
	 * list is the nvlist_t structure for the embedded list.
	 * So we print that address out (computed as an offset from
	 * the nvpair address we received as addr).
	 *
	 * The value of the name-value pair for an array of embedded
	 * lists is nelem pointers to nvlist_t structures followed
	 * by the structures themselves.  We display the list
	 * of pointers as the pair's value.
	 */
	if (type == DATA_TYPE_NVLIST) {
		char *p = (char *)addr + (data - (char *)nvpair);
		if (recurse) {
			if (quiet)
				mdb_printf("\n");
			mdb_inc_indent(NVPAIR_VALUE_INDENT);
			if (mdb_pwalk_dcmd("nvpair", "nvpair", argc, argv,
			    (uintptr_t)p) != DCMD_OK)
				return (DCMD_ERR);
			mdb_dec_indent(NVPAIR_VALUE_INDENT);
		} else {
			if (!quiet) {
				mdb_inc_indent(NVPAIR_VALUE_INDENT);
				mdb_printf("value", p);
			}
			mdb_printf("=%p\n", p);
			if (!quiet)
				mdb_dec_indent(NVPAIR_VALUE_INDENT);
		}
		return (DCMD_OK);

	} else if (type == DATA_TYPE_NVLIST_ARRAY) {
		if (recurse) {
			for (i = 0; i < nelem; i++,
			    data += sizeof (nvlist_t *)) {
				nvlist_t **nl = (nvlist_t **)(void *)data;
				if (quiet && i != 0)
					mdb_printf("%s", NVP_NAME(nvpair));
				mdb_printf("[%d]\n", i);
				mdb_inc_indent(NVPAIR_VALUE_INDENT);
				if (mdb_pwalk_dcmd("nvpair", "nvpair", argc,
				    argv, (uintptr_t)*nl) != DCMD_OK)
					return (DCMD_ERR);
				mdb_dec_indent(NVPAIR_VALUE_INDENT);
			}
		} else {
			if (!quiet) {
				mdb_inc_indent(NVPAIR_VALUE_INDENT);
				mdb_printf("value");
			}
			mdb_printf("=");
			for (i = 0; i < nelem; i++,
			    data += sizeof (nvlist_t *)) {
				nvlist_t **nl = (nvlist_t **)(void *)data;
				mdb_printf("%c%p", " "[i == 0], *nl);
			}
			mdb_printf("\n");
			if (!quiet)
				mdb_dec_indent(NVPAIR_VALUE_INDENT);
		}
		return (DCMD_OK);
	}

	/* if it's a string array, skip the index pointers */
	if (type == DATA_TYPE_STRING_ARRAY)
		data += (sizeof (int64_t) * nelem);

	/* if the type is unknown, treat the data as a byte array */
	if (type_name == NULL) {
		elem_size = 1;
		nelem = data_end - data;
	}

	/*
	 * if the type is of strings, make sure they are printable
	 * otherwise print them out as byte arrays
	 */
	if (elem_size == 0) {
		int32_t	count = 0;

		i = 0;
		while ((&data[i] < data_end) && (count < nelem)) {
			if (data[i] == '\0')
				count++;
			else if (!isprint(data[i]))
				break;
			i++;
		}
		if (count != nelem) {
			/* there is unprintable data, output as byte array */
			elem_size = 1;
			nelem =  data_end - data;
		}
	}

	if (!quiet) {
		mdb_inc_indent(NVPAIR_VALUE_INDENT);
		mdb_printf("value=");
	} else {
		mdb_printf("=");
	}
	nvpair_print_value(data, elem_size, nelem, type);
	if (!quiet)
		mdb_dec_indent(NVPAIR_VALUE_INDENT);

	return (DCMD_OK);
}
Esempio n. 10
0
int
cycinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	cyc_cpu_t cpu;
	cpu_t c;
	cyc_index_t root, i, *heap;
	size_t hsize;
	cyclic_t *cyc;
	uintptr_t caddr;
	uint_t verbose = FALSE, Verbose = FALSE;
	int header = 0;
	cyc_level_t lev;

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("cyccpu", "cycinfo", argc, argv) == -1) {
			mdb_warn("can't walk 'cyccpu'");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (mdb_getopts(argc, argv,
	    'v', MDB_OPT_SETBITS, TRUE, &verbose,
	    'V', MDB_OPT_SETBITS, TRUE, &Verbose, NULL) != argc)
		return (DCMD_USAGE);

	if (!DCMD_HDRSPEC(flags) && (verbose || Verbose))
		mdb_printf("\n\n");

	if (DCMD_HDRSPEC(flags) || verbose || Verbose)
		mdb_printf("%3s %*s %7s %6s %*s %15s %s\n", "CPU",
		    CYC_ADDR_WIDTH, "CYC_CPU", "STATE", "NELEMS",
		    CYC_ADDR_WIDTH, "ROOT", "FIRE", "HANDLER");

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

	if (mdb_vread(&c, sizeof (c), (uintptr_t)cpu.cyp_cpu) == -1) {
		mdb_warn("couldn't read cpu at %p", cpu.cyp_cpu);
		return (DCMD_ERR);
	}

	cyc = mdb_alloc(sizeof (cyclic_t) * cpu.cyp_size, UM_SLEEP | UM_GC);
	caddr = (uintptr_t)cpu.cyp_cyclics;

	if (mdb_vread(cyc, sizeof (cyclic_t) * cpu.cyp_size, caddr) == -1) {
		mdb_warn("couldn't read cyclic at %p", caddr);
		return (DCMD_ERR);
	}

	hsize = sizeof (cyc_index_t) * cpu.cyp_size;
	heap = mdb_alloc(hsize, UM_SLEEP | UM_GC);

	if (mdb_vread(heap, hsize, (uintptr_t)cpu.cyp_heap) == -1) {
		mdb_warn("couldn't read heap at %p", cpu.cyp_heap);
		return (DCMD_ERR);
	}

	root = heap[0];

	mdb_printf("%3d %0*p %7s %6d ", c.cpu_id, CYC_ADDR_WIDTH, addr,
	    cpu.cyp_state == CYS_ONLINE ? "online" :
	    cpu.cyp_state == CYS_OFFLINE ? "offline" :
	    cpu.cyp_state == CYS_EXPANDING ? "expand" :
	    cpu.cyp_state == CYS_REMOVING ? "remove" :
	    cpu.cyp_state == CYS_SUSPENDED ? "suspend" : "????",
	    cpu.cyp_nelems);

	if (cpu.cyp_nelems > 0)
		mdb_printf("%0*p %15llx %a\n", CYC_ADDR_WIDTH,
		    caddr, cyc[root].cy_expire, cyc[root].cy_handler);
	else
		mdb_printf("%*s %15s %s\n", CYC_ADDR_WIDTH, "-", "-", "-");

	if (!verbose && !Verbose)
		return (DCMD_OK);

	mdb_printf("\n");

	cyclic_pretty_dump(&cpu);

	mdb_inc_indent(2);

	for (i = 0; i < cpu.cyp_size; i++) {
		int j;

		for (j = 0; j < cpu.cyp_size; j++) {
			if (heap[j] == i)
				break;
		}

		if (!Verbose && j >= cpu.cyp_nelems)
			continue;

		if (!header) {
			header = 1;
			mdb_printf("\n%*s %3s %4s %4s %5s %15s %7s %s\n",
			    CYC_ADDR_WIDTH, "ADDR", "NDX", "HEAP", "LEVL",
			    "PEND", "FIRE", "USECINT", "HANDLER");
		}

		mdb_printf("%0*p %3d ", CYC_ADDR_WIDTH,
		    caddr + i * sizeof (cyclic_t), i);

		mdb_printf("%4d ", j);

		if (j >= cpu.cyp_nelems) {
			mdb_printf("%4s %5s %15s %7s %s\n", "-", "-",
			    "-", "-", "-");
			continue;
		}

		mdb_printf("%4s %5d %15llx ",
		    cyc[i].cy_level == CY_HIGH_LEVEL ? "high" :
		    cyc[i].cy_level == CY_LOCK_LEVEL ? "lock" :
		    cyc[i].cy_level == CY_LOW_LEVEL ? "low" : "????",
		    cyc[i].cy_pend, cyc[i].cy_expire);

		if (cyc[i].cy_interval + cyc[i].cy_expire != INT64_MAX)
			mdb_printf("%7lld ", cyc[i].cy_interval /
			    (uint64_t)(NANOSEC / MICROSEC));
		else
			mdb_printf("%7s ", "-");

		mdb_printf("%a\n", cyc[i].cy_handler);
	}


	if (!Verbose)
		goto out;

	for (lev = CY_LOW_LEVEL; lev < CY_LOW_LEVEL + CY_SOFT_LEVELS; lev++) {
		cyc_softbuf_t *softbuf = &cpu.cyp_softbuf[lev];
		char which = softbuf->cys_hard, shared = 1;
		cyc_pcbuffer_t *pc;
		size_t bufsiz;
		cyc_index_t *buf;

		if (softbuf->cys_hard != softbuf->cys_soft)
			shared = 0;

again:
		pc = &softbuf->cys_buf[which];
		bufsiz = (pc->cypc_sizemask + 1) * sizeof (cyc_index_t);
		buf = mdb_alloc(bufsiz, UM_SLEEP | UM_GC);

		if (mdb_vread(buf, bufsiz, (uintptr_t)pc->cypc_buf) == -1) {
			mdb_warn("couldn't read cypc_buf at %p", pc->cypc_buf);
			continue;
		}

		mdb_printf("\n%3s %4s %4s %4s %*s %4s %*s\n", "CPU",
		    "LEVL", "USER", "NDX", CYC_ADDR_WIDTH, "ADDR", "CYC",
		    CYC_ADDR_WIDTH, "CYC_ADDR", "PEND");

		for (i = 0; i <= pc->cypc_sizemask &&
		    i <= pc->cypc_prodndx; i++) {
			uintptr_t cyc_addr = caddr + buf[i] * sizeof (cyclic_t);

			mdb_printf("%3d %4s %4s ", c.cpu_id,
			    lev == CY_HIGH_LEVEL ? "high" :
			    lev == CY_LOCK_LEVEL ? "lock" :
			    lev == CY_LOW_LEVEL ? "low" : "????",
			    shared ? "shrd" : which == softbuf->cys_hard ?
			    "hard" : "soft");

			mdb_printf("%4d %0*p ", i, CYC_ADDR_WIDTH,
			    (uintptr_t)&buf[i] - (uintptr_t)&buf[0] +
			    (uintptr_t)pc->cypc_buf, buf[i],
			    caddr + buf[i] * sizeof (cyclic_t));

			if (i >= pc->cypc_prodndx)
				mdb_printf("%4s %*s %5s  ",
				    "-", CYC_ADDR_WIDTH, "-", "-");
			else {
				cyclic_t c;

				if (mdb_vread(&c, sizeof (c), cyc_addr) == -1) {
					mdb_warn("\ncouldn't read cyclic at "
					    "%p", cyc_addr);
					continue;
				}

				mdb_printf("%4d %0*p %5d  ", buf[i],
				    CYC_ADDR_WIDTH, cyc_addr, c.cy_pend);
			}

			if (i == (pc->cypc_consndx & pc->cypc_sizemask)) {
				mdb_printf("<-- consndx");
				if (i == (pc->cypc_prodndx & pc->cypc_sizemask))
					mdb_printf(",prodndx");
				mdb_printf("\n");
				continue;
			}

			if (i == (pc->cypc_prodndx & pc->cypc_sizemask)) {
				mdb_printf("<-- prodndx\n");
				continue;
			}
			mdb_printf("\n");

			if (i >= pc->cypc_prodndx)
				break;
		}

		if (!shared && which == softbuf->cys_hard) {
			which = softbuf->cys_soft;
			goto again;
		}
	}

out:
	mdb_dec_indent(2);
	return (DCMD_OK);
}
Esempio n. 11
0
static int
dof_sect_provider(dof_hdr_t *dofh, uintptr_t addr, dof_sec_t *sec,
    dof_sec_t *dofs)
{
	dof_provider_t pv;
	dof_probe_t *pb;
	char *strtab, *p;
	uint32_t *offs, *enoffs;
	uint8_t *args = NULL;
	size_t sz;
	int i, j;
	dof_stridx_t narg, xarg;

	sz = MIN(sec->dofs_size, sizeof (dof_provider_t));
	if (mdb_vread(&pv, sz, addr + sec->dofs_offset) != sz) {
		mdb_warn("failed to read DOF provider");
		return (-1);
	}

	sz = dofs[pv.dofpv_strtab].dofs_size;
	strtab = mdb_alloc(sz, UM_SLEEP | UM_GC);
	if (mdb_vread(strtab, sz, addr +
	    dofs[pv.dofpv_strtab].dofs_offset) != sz) {
		mdb_warn("failed to read string table");
		return (-1);
	}

	mdb_printf("%lx provider %s {\n", (ulong_t)(addr + sec->dofs_offset),
	    strtab + pv.dofpv_name);

	sz = dofs[pv.dofpv_prargs].dofs_size;
	if (sz != 0) {
		args = mdb_alloc(sz, UM_SLEEP | UM_GC);
		if (mdb_vread(args, sz, addr +
		    dofs[pv.dofpv_prargs].dofs_offset) != sz) {
			mdb_warn("failed to read args");
			return (-1);
		}
	}

	sz = dofs[pv.dofpv_proffs].dofs_size;
	offs = mdb_alloc(sz, UM_SLEEP | UM_GC);
	if (mdb_vread(offs, sz, addr + dofs[pv.dofpv_proffs].dofs_offset)
	    != sz) {
		mdb_warn("failed to read offsets");
		return (-1);
	}

	enoffs = NULL;
	if (dofh->dofh_ident[DOF_ID_VERSION] != DOF_VERSION_1 ||
	    pv.dofpv_prenoffs == 0) {
		sz = dofs[pv.dofpv_prenoffs].dofs_size;
		enoffs = mdb_alloc(sz, UM_SLEEP | UM_GC);
		if (mdb_vread(enoffs, sz, addr +
		    dofs[pv.dofpv_prenoffs].dofs_offset) != sz) {
			mdb_warn("failed to read is-enabled offsets");
			return (-1);
		}
	}

	sz = dofs[pv.dofpv_probes].dofs_size;
	p = mdb_alloc(sz, UM_SLEEP | UM_GC);
	if (mdb_vread(p, sz, addr + dofs[pv.dofpv_probes].dofs_offset) != sz) {
		mdb_warn("failed to read probes");
		return (-1);
	}

	(void) mdb_inc_indent(2);

	for (i = 0; i < sz / dofs[pv.dofpv_probes].dofs_entsize; i++) {
		pb = (dof_probe_t *)(uintptr_t)(p +
		    i * dofs[pv.dofpv_probes].dofs_entsize);

		mdb_printf("%lx probe %s:%s {\n", (ulong_t)(addr +
		    dofs[pv.dofpv_probes].dofs_offset +
		    i * dofs[pv.dofpv_probes].dofs_entsize),
		    strtab + pb->dofpr_func,
		    strtab + pb->dofpr_name);

		(void) mdb_inc_indent(2);
		mdb_printf("addr: %p\n", (ulong_t)pb->dofpr_addr);
		mdb_printf("offs: ");
		for (j = 0; j < pb->dofpr_noffs; j++) {
			mdb_printf("%s %x", "," + (j == 0),
			    offs[pb->dofpr_offidx + j]);
		}
		mdb_printf("\n");

		if (dofh->dofh_ident[DOF_ID_VERSION] != DOF_VERSION_1) {
			mdb_printf("enoffs: ");
			if (enoffs == NULL) {
				if (pb->dofpr_nenoffs != 0)
					mdb_printf("<error>");
			} else {
				for (j = 0; j < pb->dofpr_nenoffs; j++) {
					mdb_printf("%s %x", "," + (j == 0),
					    enoffs[pb->dofpr_enoffidx + j]);
				}
			}
			mdb_printf("\n");
		}

		mdb_printf("nargs:");
		narg = pb->dofpr_nargv;
		for (j = 0; j < pb->dofpr_nargc; j++) {
			mdb_printf("%s %s", "," + (j == 0), strtab + narg);
			narg += strlen(strtab + narg) + 1;
		}
		mdb_printf("\n");
		mdb_printf("xargs:");
		xarg = pb->dofpr_xargv;
		for (j = 0; j < pb->dofpr_xargc; j++) {
			mdb_printf("%s %s", "," + (j == 0), strtab + xarg);
			xarg += strlen(strtab + xarg) + 1;
		}
		mdb_printf("\n");
		mdb_printf("map:  ");
		for (j = 0; j < pb->dofpr_xargc; j++) {
			mdb_printf("%s %d->%d", "," + (j == 0),
			    args[pb->dofpr_argidx + j], j);
		}

		(void) mdb_dec_indent(2);
		mdb_printf("\n}\n");
	}

	(void) mdb_dec_indent(2);
	mdb_printf("}\n");

	return (0);
}
Esempio n. 12
0
/*
 * dcmd ::cred - display a credential (cred_t)
 */
int
cmd_cred(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	credgrp_t cr_grps;
	cred_t	*cr;
	mdb_arg_t cmdarg;
	uint_t opts = FALSE;

	if (mdb_getopts(argc, argv,
	    'v', MDB_OPT_SETBITS, OPT_VERBOSE, &opts, NULL) != argc)
		return (DCMD_USAGE);

	if (!(flags & DCMD_ADDRSPEC)) {
		return (DCMD_USAGE);
	}

	cr = mdb_alloc(sizeof (*cr), UM_SLEEP | UM_GC);
	if (mdb_vread(cr, sizeof (*cr), addr) == -1) {
		mdb_warn("error reading cred_t at %p", addr);
		return (DCMD_ERR);
	}

	if (cr->cr_grps == NULL) {
		bzero(&cr_grps, sizeof (cr_grps));
	} else {
		if (mdb_vread(&cr_grps, sizeof (cr_grps),
		    (uintptr_t)cr->cr_grps) == -1) {
			mdb_warn("error reading credgrp_t at %p",
			    cr->cr_grps);
			return (DCMD_ERR);
		}
	}

	if (opts & OPT_VERBOSE) {
		cmdarg.a_type = MDB_TYPE_STRING;
		cmdarg.a_un.a_str = "cred_t";
		(void) mdb_call_dcmd("print", addr, flags, 1, &cmdarg);
		cmdarg.a_un.a_str = "-v";

		mdb_printf("%<u>cr_grps:%</u>\n");
		mdb_inc_indent(4);
		if (cr->cr_grps == NULL) {
			mdb_printf("(null)\n");
		} else {
			(void) mdb_call_dcmd("credgrp",
			    (uintptr_t)cr->cr_grps, flags, 1, &cmdarg);
		}
		mdb_dec_indent(4);

		mdb_printf("%<u>cr_ksid:%</u>\n");
		mdb_inc_indent(4);
		if (cr->cr_ksid == NULL) {
			mdb_printf("(null)\n");
		} else {
			(void) mdb_call_dcmd("credsid",
			    (uintptr_t)cr->cr_ksid, flags, 1, &cmdarg);
		}
		mdb_dec_indent(4);

		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags))
		mdb_printf("%<u>%?s %8s %8s %8s %8s% %8s%</u>\n",
		    "ADDR", "UID", "GID", "RUID", "RGID", "#GRP(+SIDS)");

	mdb_printf("%0?p %8u %8u %8u %8u %4u%s\n", addr,
	    cr->cr_uid,  cr->cr_gid,
	    cr->cr_ruid, cr->cr_rgid,
	    cr_grps.crg_ngroups,
	    (cr->cr_ksid == NULL) ? "" : "+");

	return (DCMD_OK);
}
Esempio n. 13
0
static int
sv_dev(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	sv_dev_t *svp;
	int a_opt, v_opt;
	int dev_t_chars;

	a_opt = v_opt = FALSE;
	dev_t_chars = sizeof (dev_t) * 2;	/* # chars to display dev_t */

	if (mdb_getopts(argc, argv,
	    'a', MDB_OPT_SETBITS, TRUE, &a_opt,
	    'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
		return (DCMD_USAGE);

	svp = mdb_zalloc(sizeof (*svp), UM_GC);

	if (!(flags & DCMD_ADDRSPEC)) {
		/*
		 * paranoid mode on: qualify walker name with module name
		 * using '`' syntax.
		 */
		if (mdb_walk_dcmd("sv`sv_dev", "sv`sv_dev", argc, argv) == -1) {
			mdb_warn("failed to walk 'sv_dev'");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8T%-*s  %8T%s\n", "ADDR",
		    dev_t_chars, "DEV", "STATE");
	}

	if (mdb_vread(svp, sizeof (*svp), addr) != sizeof (*svp)) {
		mdb_warn("failed to read sv_dev at %p", addr);
		return (DCMD_ERR);
	}

	if (!a_opt && svp->sv_state == SV_DISABLE)
		return (DCMD_OK);

	mdb_printf("%?p  %8T%0*lx  %8T", addr, dev_t_chars, svp->sv_dev);

	if (svp->sv_state == SV_DISABLE)
		mdb_printf("disabled");
	else if (svp->sv_state == SV_PENDING)
		mdb_printf("pending");
	else if (svp->sv_state == SV_ENABLE)
		mdb_printf("enabled");

	mdb_printf("\n");

	if (!v_opt)
		return (DCMD_OK);

	/*
	 * verbose - print the rest of the structure as well.
	 */

	mdb_inc_indent(4);
	mdb_printf("\n");

	mdb_printf("hash chain: 0x%p  %8Tlock: 0x%p  %8Tolock: 0x%p\n",
	    svp->sv_hash,
	    addr + OFFSETOF(sv_dev_t, sv_lock),
	    addr + OFFSETOF(sv_dev_t, sv_olock));

	mdb_printf("fd: 0x%p  %8T\n", svp->sv_fd);

	mdb_printf("maxfbas: %d  %8Tnblocks: %d  %8Tstate: %d\n",
	    svp->sv_maxfbas, svp->sv_nblocks, svp->sv_state);

	mdb_printf("gclients: 0x%llx  %8Tgkernel: 0x%llx\n",
	    svp->sv_gclients, svp->sv_gkernel);

	mdb_printf("openlcnt: %d  %8Ttimestamp: 0x%lx\n",
	    svp->sv_openlcnt, svp->sv_timestamp);

	mdb_printf("flags: 0x%08x <%b>\n",
	    svp->sv_flag, svp->sv_flag, sv_flag_bits);

	mdb_printf("lh: 0x%p  %8Tpending: 0x%p\n",
	    svp->sv_lh, svp->sv_pending);

	mdb_dec_indent(4);
	return (DCMD_OK);
}
Esempio n. 14
0
/*
 * Display a single sv_maj_t structure.
 * If called with no address, performs a global walk of all sv_majs.
 * -a : all (i.e. display all devices, even if disabled
 * -v : verbose
 */
static int
sv_maj(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	sv_maj_t *maj;
	int a_opt, v_opt;
	int i;

	a_opt = v_opt = FALSE;

	if (mdb_getopts(argc, argv,
	    'a', MDB_OPT_SETBITS, TRUE, &a_opt,
	    'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
		return (DCMD_USAGE);

	if (!(flags & DCMD_ADDRSPEC)) {
		/*
		 * paranoid mode on: qualify walker name with module name
		 * using '`' syntax.
		 */
		if (mdb_walk_dcmd("sv`sv_maj", "sv`sv_maj", argc, argv) == -1) {
			mdb_warn("failed to walk 'sv_maj'");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8T%s\n", "ADDR", "INUSE");
	}

	maj = mdb_zalloc(sizeof (*maj), UM_GC);
	if (mdb_vread(maj, sizeof (*maj), addr) != sizeof (*maj)) {
		mdb_warn("failed to read sv_maj at %p", addr);
		return (DCMD_ERR);
	}

	if (!a_opt && maj->sm_inuse == 0)
		return (DCMD_OK);

	mdb_printf("%?p  %8T%d\n", addr, maj->sm_inuse);

	if (!v_opt)
		return (DCMD_OK);

	/*
	 * verbose - print the rest of the structure as well.
	 */

	mdb_inc_indent(4);
	mdb_printf("\n");

	mdb_printf("dev_ops: %a (%p)\n", maj->sm_dev_ops, maj->sm_dev_ops);
	mdb_printf("flag: %08x %8Tsequence: %d %8Tmajor: %d\n",
		maj->sm_flag, maj->sm_seq, maj->sm_major);

	mdb_printf("function pointers:\n");
	mdb_inc_indent(4);
	mdb_printf("%-20a%-20a%\n%-20a%-20a%\n%-20a%-20a%\n%-20a%-20a%\n",
		maj->sm_open, maj->sm_close,
		maj->sm_read, maj->sm_write,
		maj->sm_aread, maj->sm_awrite,
		maj->sm_strategy, maj->sm_ioctl);
	mdb_dec_indent(4);


	mdb_printf("hash chain:\n");
	mdb_inc_indent(4);
	for (i = 0; i < SV_MINOR_HASH_CNT; i++) {
		mdb_printf("%?p", maj->sm_hash[i]);
		mdb_printf(((i % 4) == 3) ? "\n" : " %8T");
	}
	mdb_printf("\n\n");
	mdb_dec_indent(4);
	mdb_dec_indent(4);
	return (DCMD_OK);
}
Esempio n. 15
0
/*
 * Print the core fields in an NCA node_t.  With the "-r" argument,
 * provide additional information about the request; with "-v",
 * provide more verbose output.
 */
static int
nca_node(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	unsigned int	i, max;
	unsigned int	verbose = FALSE;
	unsigned int	request = FALSE;
	const int	NODE_REFDELT = NCA_ADDR_WIDTH + 4 + 2;
	boolean_t	arm;
	node_t		node;
	char		*buf;
	namedmem_t	hdr[4];

	if (!(flags & DCMD_ADDRSPEC))
		return (DCMD_USAGE);

	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE, &verbose,
		'r', MDB_OPT_SETBITS, TRUE, &request, 'p', NULL) != argc)
		return (DCMD_USAGE);

	if (!DCMD_HDRSPEC(flags) && verbose)
		mdb_printf("\n\n");

	if (DCMD_HDRSPEC(flags) || verbose) {
		mdb_printf("%<u>%-*s %4s %5s %8s %-*s %-*s %-*s %-*s%</u>\n",
			NCA_ADDR_WIDTH, "ADDR", "REF", "STATE", "DATASIZE",
			NCA_ADDR_WIDTH, "SQUEUE", NCA_ADDR_WIDTH, "REQUEST",
			NCA_ADDR_WIDTH, "PLRUN", NCA_ADDR_WIDTH, "VLRUN");
	}

	if (mdb_vread(&node, sizeof (node_t), addr) == -1) {
		mdb_warn("cannot read node_t at %p", addr);
		return (DCMD_ERR);
	}

	mdb_printf("%0*p %4d %05x %8d %0*p %0*p %0*p %0*p\n",
	    NCA_ADDR_WIDTH, addr, node.cnt, node.ref,
	    node.datasz, NCA_ADDR_WIDTH, node.sqp, NCA_ADDR_WIDTH,
	    node.req, NCA_ADDR_WIDTH, node.plrunn, NCA_ADDR_WIDTH, node.vlrunn);

	if (verbose) {
		arm = B_TRUE;
		for (i = 0; node_refs[i].bit_name != NULL; i++) {
			if ((node.ref & (1 << i)) == 0)
				continue;

			if (arm) {
				mdb_printf("%*s|\n", NODE_REFDELT, "");
				mdb_printf("%*s+-->  ", NODE_REFDELT, "");
				arm = B_FALSE;
			} else
				mdb_printf("%*s      ", NODE_REFDELT, "");

			mdb_printf("%-12s %s\n", node_refs[i].bit_name,
			    node_refs[i].bit_descr);
		}
	}

	if (!request || node.req == NULL)
		return (DCMD_OK);

	mdb_inc_indent(4);
	mdb_printf("\n%u byte HTTP/%u.%u %s request (%u bytes in header, "
	    "%u in content)\n", node.reqsz, node.version >> 16,
	    node.version & 0xff, method2name(node.method), node.reqhdrsz,
	    node.reqcontl);

	hdr[0].nm_name = "URI";
	hdr[0].nm_addr = (uintptr_t)node.path;
	hdr[0].nm_len  = node.pathsz;

	hdr[1].nm_name = "Accept";
	hdr[1].nm_addr = (uintptr_t)node.reqaccept;
	hdr[1].nm_len  = node.reqacceptsz;

	hdr[2].nm_name = "Accept-Language";
	hdr[2].nm_addr = (uintptr_t)node.reqacceptl;
	hdr[2].nm_len  = node.reqacceptlsz;

	hdr[3].nm_name = "Host";
	hdr[3].nm_addr = (uintptr_t)node.reqhost;
	hdr[3].nm_len  = node.reqhostsz;

	/*
	 * A little optimization.  Allocate all of the necessary memory here,
	 * so we don't have to allocate on each loop iteration.
	 */

	max = node.reqhdrsz;
	for (i = 0; i < 4; i++)
		max = MAX(max, hdr[i].nm_len);
	max++;

	buf = mdb_alloc(max, UM_SLEEP);

	mdb_inc_indent(4);
	for (i = 0; i < sizeof (hdr) / sizeof (hdr[0]); i++) {
		if (hdr[i].nm_len <= 0)
			continue;

		if (mdb_vread(buf, hdr[i].nm_len, hdr[i].nm_addr) == -1) {
			mdb_warn("cannot read \"%s\" header field at %p",
			    hdr[i].nm_name, hdr[i].nm_addr);
			continue;
		}
		buf[hdr[i].nm_len] = '\0';

		mdb_printf("%s: ", hdr[i].nm_name);
		mdb_inc_indent(4);
		mdb_printf("%s\n", buf);
		mdb_dec_indent(4);
	}

	if (node.reqhdrsz > 0 && verbose) {
		if (mdb_vread(buf, node.reqhdrsz, (uintptr_t)node.reqhdr) == -1)
			mdb_warn("cannot read header at %p", node.reqhdr);
		else {
			mdb_printf("Raw header: ");
			mdb_inc_indent(4);
			printbuf((uint8_t *)buf, node.reqhdrsz);
			mdb_dec_indent(4);
		}
	}
	mdb_dec_indent(4);
	mdb_dec_indent(4);

	mdb_free(buf, max);

	return (DCMD_OK);
}
Esempio n. 16
0
/*
 * Print the core fields for one or all NCA timers.  If no address is
 * specified, all NCA timers are printed; otherwise the specified timer
 * list is printed.  With the "-e" argument, the "encapsulated" pointer
 * for each te_t in a given tb_t is shown in parentheses.
 */
static int
nca_timer(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	unsigned int	show_encap = FALSE;
	void		*tb_addr, *te_addr;
	clock_t		lbolt, first_exec = 0;
	ti_t		ti;
	tb_t		tb;
	te_t		te;

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("nca_timer", "nca_timer", argc, argv) == -1) {
			mdb_warn("cannot walk timer list");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

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

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%<u>%-*s %-*s %-55s%</u>\n", NCA_ADDR_WIDTH, "TI",
		    NCA_ADDR_WIDTH, "SQUEUE", "FIRELIST +MSEC");
	}

	if (mdb_vread(&ti, sizeof (ti_t), addr) == -1) {
		mdb_warn("cannot read ti_t at %p", addr);
		return (DCMD_ERR);
	}

	if (mdb_readvar(&lbolt, "lbolt") == -1) {
		mdb_warn("cannot read symbol lbolt");
		return (DCMD_ERR);
	}

	mdb_printf("%0*p %0*p", NCA_ADDR_WIDTH, addr, NCA_ADDR_WIDTH, ti.ep);
	mdb_inc_indent(24);
	for (tb_addr = ti.head; tb_addr != NULL; tb_addr = tb.next) {
		if (mdb_vread(&tb, sizeof (tb_t), (uintptr_t)tb_addr) == -1) {
			mdb_warn("cannot read tb_t at %p", tb_addr);
			return (DCMD_ERR);
		}
		if (first_exec == 0) {
			mdb_printf(" %ld", tick2msec(tb.exec - lbolt));
			first_exec = tb.exec;
		} else
			mdb_printf(" %+lld", tick2msec(tb.exec - first_exec));

		if (!show_encap || tb.head == NULL)
			continue;

		mdb_printf("(");
		for (te_addr = tb.head; te_addr != NULL; te_addr = te.next) {
			if (mdb_vread(&te, sizeof (te_t), (uintptr_t)te_addr)
			    == -1) {
				mdb_warn("cannot read te_t at %p", te_addr);
				return (DCMD_ERR);
			}
			mdb_printf("%0p%s", te.ep, te.next == NULL ? "" : " ");
		}
		mdb_printf(")");
	}
	mdb_printf("\n");
	mdb_dec_indent(24);

	return (DCMD_OK);
}
Esempio n. 17
0
/*
 * Print the core fields in an nca_io2_t.  With the "-v" argument,
 * provide more verbose output.  With the "-p" argument, print payload
 * information.
 */
static int
nca_io2(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	unsigned int	i;
	unsigned int	payload_len;
	uint64_t	payload_output_max = 0;
	unsigned int	verbose = FALSE;
	const int	IO2_ADVDELT = NCA_ADDR_WIDTH + 1;
	boolean_t	arm;
	nca_io2_t	io2;
	uint8_t		*buf;
	namedmem_t	area[3];

	if (!(flags & DCMD_ADDRSPEC))
		return (DCMD_USAGE);

	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE, &verbose,
	    'p', MDB_OPT_UINT64, &payload_output_max, NULL) != argc)
		return (DCMD_USAGE);

	if (!DCMD_HDRSPEC(flags) && verbose)
		mdb_printf("\n\n");

	if (DCMD_HDRSPEC(flags) || verbose) {
		mdb_printf("%<u>%-*s %2s %4s %8s %*s %8s %16s %-12s%</u>\n",
		    NCA_ADDR_WIDTH, "ADDR", "AV", "MFNP", "TID",
		    NCA_ADDR_WIDTH, "CONN", "CONN_TAG", "CACHE_TAG",
		    "OPERATION");
	}

	if (mdb_vread(&io2, sizeof (nca_io2_t), addr) == -1) {
		mdb_warn("cannot read nca_io2_t at %p", addr);
		return (DCMD_ERR);
	}

	if (io2.version != NCA_HTTP_VERSION2)
		mdb_warn("nca_io2_t at %p has incorrect version `%u'\n", addr,
		    io2.version);

	mdb_printf("%0*p %02x %c%c%c%c %08x %0*llx %08x %016llx %s\n",
	    NCA_ADDR_WIDTH, addr, io2.advisory, YESNO(io2.more),
	    YESNO(io2.first), YESNO(io2.nocache), YESNO(io2.preempt),
	    (uint32_t)io2.tid, NCA_ADDR_WIDTH, io2.cid, io2.tag, io2.ctag,
	    op2name(io2.op));

	if (verbose) {
		arm = B_TRUE;
		for (i = 0; advise_types[i].bit_name != NULL; i++) {
			if ((io2.advisory & (1 << i)) == 0)
				continue;

			if (arm) {
				mdb_printf("%*s|\n", IO2_ADVDELT, "");
				mdb_printf("%*s+-->  ", IO2_ADVDELT, "");
				arm = B_FALSE;
			} else
				mdb_printf("%*s      ", IO2_ADVDELT, "");

			mdb_printf("%-15s %s\n", advise_types[i].bit_name,
			    advise_types[i].bit_descr);
		}
	}

	payload_len = io2.data_len + io2.direct_len + io2.trailer_len;

	if (payload_output_max == 0 || payload_len == 0)
		return (DCMD_OK);

	mdb_inc_indent(4);
	mdb_printf("\n%u byte payload consists of:\n", payload_len);
	mdb_inc_indent(4);

	buf = mdb_alloc(payload_output_max, UM_SLEEP);

	area[0].nm_name = "data";
	area[0].nm_addr = addr + io2.data;
	area[0].nm_len  = io2.data_len;

	area[1].nm_name = direct2name(io2.direct_type);
	area[1].nm_addr = addr + io2.direct;
	area[1].nm_len  = io2.direct_len;

	area[2].nm_name = "trailer";
	area[2].nm_addr = addr + io2.trailer;
	area[2].nm_len  = io2.trailer_len;

	for (i = 0; i < sizeof (area) / sizeof (area[0]); i++) {
		if (area[i].nm_len <= 0)
			continue;

		mdb_printf("%d byte %s area at %p (", area[i].nm_len,
		    area[i].nm_name, area[i].nm_addr);

		if (area[i].nm_len > payload_output_max) {
			mdb_printf("first");
			area[i].nm_len = (int)payload_output_max;
		} else
			mdb_printf("all");

		mdb_printf(" %u bytes follow):\n", area[i].nm_len);
		if (mdb_vread(buf, area[i].nm_len, area[i].nm_addr) == -1)
			mdb_warn("cannot read %s area at %p", area[i].nm_name,
			    area[i].nm_addr);
		else {
			mdb_inc_indent(4);
			printbuf(buf, area[i].nm_len);
			mdb_dec_indent(4);
		}
	}
	mdb_dec_indent(4);
	mdb_dec_indent(4);

	mdb_free(buf, payload_output_max);

	return (DCMD_OK);
}