Exemple #1
0
int
rctl_val_walk_step(mdb_walk_state_t *wsp)
{
	rctl_val_t val;
	int status;

	if (mdb_vread(&val, sizeof (rctl_val_t), wsp->walk_addr) == -1) {
		mdb_warn("failed to read rctl_val at %p", wsp->walk_addr);
		return (WALK_DONE);
	}

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

	if ((wsp->walk_addr = (uintptr_t)val.rcv_next) == NULL)
		return (WALK_DONE);

	return (status);
}
Exemple #2
0
/*ARGSUSED*/
static int
stmf_remote_port(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
    stmf_remote_port_t rpt;
    int	ret = DCMD_OK;

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

    if (mdb_vread(&rpt, sizeof (stmf_remote_port_t), addr) == -1) {
        mdb_warn("failed to read stmf_remote_port_t at %p\n", addr);
        return (DCMD_ERR);
    }

    ret = print_transport_id((uintptr_t)rpt.rport_tptid,
                             rpt.rport_tptid_sz, "		");
    return (ret);
}
Exemple #3
0
/*ARGSUSED*/
static int
gate_desc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	gate_desc_t gate;

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

	if (mdb_vread(&gate, sizeof (gate_desc_t), addr) !=
	    sizeof (gate_desc_t)) {
		mdb_warn("failed to read gate descriptor at %p\n", addr);
		return (DCMD_ERR);
	}

	gate_desc_dump(&gate, "", DCMD_HDRSPEC(flags));

	return (DCMD_OK);
}
Exemple #4
0
/*ARGSUSED*/
static int
configd_thread(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	thread_info_t t;
	char state[20];
	char oldstate[20];

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

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

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%<u>%-?s %5s %-12s %-12s %-?s %-?s %-?s%</u>\n",
		    "ADDR", "TID", "STATE", "PREV_STATE", "CLIENT", "CLIENTRQ",
		    "MAINREQ");
	}

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

	enum_lookup(state, sizeof (state), thread_state_enum,
	    t.ti_state, "TI_", "");
	make_lower(state, sizeof (state));

	enum_lookup(oldstate, sizeof (oldstate), thread_state_enum,
	    t.ti_prev_state, "TI_", "");
	make_lower(oldstate, sizeof (oldstate));

	mdb_printf("%0?p %5d %-12s %-12s %?p %?p %?p\n",
	    (void *)addr, t.ti_thread, state, oldstate,
	    t.ti_active_client, t.ti_client_request, t.ti_main_door_request);

	return (DCMD_OK);
}
Exemple #5
0
/*
 * dcmd ::credsid - display a credsid_t
 */
int
cmd_credsid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	credsid_t kr;
	uint_t 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(&kr, sizeof (kr), addr) == -1) {
		mdb_warn("error reading credsid_t at %p", addr);
		return (DCMD_ERR);
	}

	if (opts & OPT_VERBOSE)
		mdb_printf("kr_ref = 0x%x\n", kr.kr_ref);

	mdb_printf("kr_sidx[USER]  = ");
	print_ksid(&kr.kr_sidx[KSID_USER]);

	mdb_printf("kr_sidx[GROUP] = ");
	print_ksid(&kr.kr_sidx[KSID_GROUP]);

	mdb_printf("kr_sidx[OWNER] = ");
	print_ksid(&kr.kr_sidx[KSID_OWNER]);

	mdb_printf("kr_sidlist = %p\n", kr.kr_sidlist);
	if (kr.kr_sidlist != NULL && (opts & OPT_VERBOSE) != 0) {
		mdb_printf("*kr_sidlist = {\n");
		mdb_inc_indent(4);
		rv = mdb_call_dcmd("ksidlist",
		    (uintptr_t)kr.kr_sidlist, flags, argc, argv);
		mdb_dec_indent(4);
		mdb_printf("}\n");
	}

	return (rv);
}
Exemple #6
0
/* ARGSUSED */
static int
srpt_print_ioc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	srpt_ioc_t	ioc;
	char		mask[9];
	int		i;

	if (addr == NULL) {
		mdb_warn("address of srpt_ioc should be specified\n");
		return (DCMD_ERR);
	}

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

	mdb_printf("IOC %p\n", addr);
	mdb_printf("    guid: %x\n", ioc.ioc_guid);
	mdb_printf("    target port: %p\n", ioc.ioc_tgt_port);
	mdb_printf("    srq handle: %p\n", ioc.ioc_srq_hdl);
	mdb_printf("    current srq size: %u\n", ioc.ioc_num_iu_entries);
	mdb_printf("	max srq size: %d\n", ioc.ioc_srq_attr.srq_wr_sz);
	mdb_printf("    iu pool: %p\n", ioc.ioc_iu_pool);
	mdb_printf("    profile send qdepth: %d\n",
	    SRPT_BSWAP_16(ioc.ioc_profile.ioc_send_msg_qdepth));
	mdb_printf("    profile rmda read qdepth: %d\n",
	    ioc.ioc_profile.ioc_rdma_read_qdepth);
	mdb_printf("    profile send msg size: %d\n",
	    SRPT_BSWAP_32(ioc.ioc_profile.ioc_send_msg_sz));
	mdb_printf("    profile rmda xfer size: %d\n",
	    SRPT_BSWAP_32(ioc.ioc_profile.ioc_rdma_xfer_sz));
	for (i = 0; i < 8; i++) {
		if (ioc.ioc_profile.ioc_ctrl_opcap_mask & 1<<i) {
			mask[i] = 'x';
		} else {
			mask[i] = '-';
		}
	}
	mask[i] = '\0';
	mdb_printf("    profile opcap mask: %s\n", mask);

	return (DCMD_OK);
}
Exemple #7
0
/*ARGSUSED*/
int
cyccover(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	cyc_coverage_t cv[CY_NCOVERAGE];
	char c[WHYLEN];
	GElf_Sym sym;
	int i;

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

	if (mdb_lookup_by_name("cyc_coverage", &sym) == -1) {
		mdb_warn("couldn't find coverage information");
		return (DCMD_ABORT);
	}

	addr = (uintptr_t)sym.st_value;

	if (mdb_vread(cv, sizeof (cyc_coverage_t) * CY_NCOVERAGE, addr) == -1) {
		mdb_warn("couldn't read coverage array at %p", addr);
		return (DCMD_ABORT);
	}

	mdb_printf("%-*s %8s %8s %8s %15s %15s\n",
	    WHYLEN, "POINT", "HIGH", "LOCK", "LOW/PASV", "ARG0", "ARG1");

	qsort(cv, CY_NCOVERAGE, sizeof (cyc_coverage_t), cyccover_comp);

	for (i = 0; i < CY_NCOVERAGE; i++) {
		if (cv[i].cyv_why != NULL) {
			(void) mdb_readstr(c, WHYLEN, (uintptr_t)cv[i].cyv_why);
			mdb_printf("%-*s %8d %8d %8d %15llx %15llx\n",
			    WHYLEN, c,
			    cv[i].cyv_count[CY_HIGH_LEVEL],
			    cv[i].cyv_count[CY_LOCK_LEVEL],
			    cv[i].cyv_passive_count != 0 ?
			    cv[i].cyv_passive_count :
			    cv[i].cyv_count[CY_LOW_LEVEL],
			    cv[i].cyv_arg0, cv[i].cyv_arg1);
		}
	}

	return (DCMD_OK);
}
Exemple #8
0
/*ARGSUSED*/
int
dof_relohdr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	dof_relohdr_t r;

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

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

	mdb_printf("dofr_strtab = %d\n", r.dofr_strtab);
	mdb_printf("dofr_relsec = %d\n", r.dofr_relsec);
	mdb_printf("dofr_tgtsec = %d\n", r.dofr_tgtsec);

	return (DCMD_OK);
}
Exemple #9
0
static void
dis_setx(const dtrace_difo_t *dp, const char *name, dif_instr_t instr)
{
	uint_t intptr = DIF_INSTR_INTEGER(instr);

	mdb_printf("%-4s DIF_INTEGER[%u], %%r%u", name,
	    intptr, DIF_INSTR_RD(instr));

	if (dp != NULL && intptr < dp->dtdo_intlen) {
		uint64_t *ip = mdb_alloc(dp->dtdo_intlen *
		    sizeof (uint64_t), UM_SLEEP | UM_GC);

		if (mdb_vread(ip, dp->dtdo_intlen * sizeof (uint64_t),
		    (uintptr_t)dp->dtdo_inttab) == -1)
			mdb_warn("failed to read data at %p", dp->dtdo_inttab);
		else
			mdb_printf("\t\t! 0x%llx", ip[intptr]);
	}
}
Exemple #10
0
/*
 * SCTP interface for geting the primary peer address of a sctp_t.
 */
static int
sctp_getpeeraddr(sctp_t *sctp, struct sockaddr *addr)
{
	struct sockaddr_in	*sin4;
	struct sockaddr_in6	*sin6;
	sctp_faddr_t		sctp_primary;
	in6_addr_t		faddr;
	conn_t			*connp = sctp->sctp_connp;

	if (sctp->sctp_faddrs == NULL)
		return (-1);

	addr->sa_family = connp->conn_family;
	if (mdb_vread(&sctp_primary, sizeof (sctp_faddr_t),
	    (uintptr_t)sctp->sctp_primary) == -1) {
		mdb_warn("failed to read sctp primary faddr");
		return (-1);
	}
	faddr = sctp_primary.sf_faddr;

	switch (connp->conn_family) {
	case AF_INET:
		/* LINTED: alignment */
		sin4 = (struct sockaddr_in *)addr;
		IN6_V4MAPPED_TO_INADDR(&faddr, &sin4->sin_addr);
		sin4->sin_port = connp->conn_fport;
		sin4->sin_family = AF_INET;
		break;

	case AF_INET6:
		/* LINTED: alignment */
		sin6 = (struct sockaddr_in6 *)addr;
		sin6->sin6_addr = faddr;
		sin6->sin6_port = connp->conn_fport;
		sin6->sin6_family = AF_INET6;
		sin6->sin6_flowinfo = 0;
		sin6->sin6_scope_id = 0;
		sin6->__sin6_src_id = 0;
		break;
	}

	return (0);
}
Exemple #11
0
static void
print_ksid(const ksid_t *ks)
{
	char str[80];
	ksiddomain_t kd;
	uintptr_t da, sa;

	/* in case of errors */
	strcpy(str, "(domain?)");

	da = (uintptr_t)ks->ks_domain;
	if (da == 0 || mdb_vread(&kd, sizeof (kd), da) < 0)
		bzero(&kd, sizeof (kd));
	sa = (uintptr_t)kd.kd_name;
	if (sa != 0)
		(void) mdb_readstr(str, sizeof (str), sa);

	mdb_printf("%s-%u,\n", str, ks->ks_rid);
}
Exemple #12
0
static int
mac_group_count_clients(mac_group_t *mgp)
{
	int clients = 0;
	uintptr_t mcp = (uintptr_t)mgp->mrg_clients;

	while (mcp != 0) {
		mac_grp_client_t c;

		if (mdb_vread(&c, sizeof (c), mcp) == -1) {
			mdb_warn("failed to read mac_grp_client_t at %p", mcp);
			return (-1);
		}
		clients++;
		mcp = (uintptr_t)c.mgc_next;
	}

	return (clients);
}
Exemple #13
0
/*
 * At each step, read a TD into our private storage, and then invoke
 * the callback function.  We terminate when we reach a QH, or
 * link_ptr is NULL.
 */
int
uhci_td_walk_step(mdb_walk_state_t *wsp)
{
	int status;
	uhci_state_t	*uhcip = (uhci_state_t *)wsp->walk_arg;


	if (mdb_vread(wsp->walk_data, sizeof (uhci_td_t), wsp->walk_addr)
		== -1) {
		mdb_warn("failed to read td at %p", wsp->walk_addr);
		return (WALK_DONE);
	}

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

	/* Next td. */
	wsp->walk_addr = ((uhci_td_t *)wsp->walk_data)->link_ptr;

	/* Check if we're at the last element */
	if (wsp->walk_addr == NULL || wsp->walk_addr & HC_END_OF_LIST)
		return (WALK_DONE);

	/* Make sure next element is a TD.  If a QH, stop.  */
	if (((((uhci_td_t *)wsp->walk_data)->link_ptr) & HC_QUEUE_HEAD)
	    == HC_QUEUE_HEAD)  {
		return (WALK_DONE);
	}

	/* Strip terminate etc. bits.  */
	wsp->walk_addr &= QH_LINK_PTR_MASK; /* there is no TD_LINK_PTR_MASK */

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

	/*
	 * Convert link_ptr paddr to vaddr
	 * Note: uhcip needed by TD_VADDR macro
	 */
	wsp->walk_addr = (uintptr_t)TD_VADDR(wsp->walk_addr);

	return (status);
}
Exemple #14
0
int
sysevent_class_list(uintptr_t addr, uint_t flags, int argc,
    const mdb_arg_t *argv)
{
	int class_name_sz;
	char class_name[CLASS_LIST_FIELD_MAX];
	class_lst_t clist;

	if ((flags & DCMD_ADDRSPEC) == 0)
		return (DCMD_USAGE);

	if ((flags & DCMD_LOOP) == 0) {
		if (mdb_pwalk_dcmd("sysevent_class_list", "sysevent_class_list",
		    argc, argv, addr) == -1) {
			mdb_warn("can't walk sysevent class list");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags))
		mdb_printf("%<u>%-?s %-24s %-?s%</u>\n",
		    "ADDR", "NAME", "SUBCLASS LIST ADDR");

	if (mdb_vread(&clist, sizeof (clist),
	    (uintptr_t)addr) == -1) {
		mdb_warn("failed to read class clist at %p", addr);
		return (DCMD_ERR);
	}
	if ((class_name_sz = mdb_readstr(class_name, CLASS_LIST_FIELD_MAX,
	    (uintptr_t)clist.cl_name)) == -1) {
		mdb_warn("failed to read class name at %p",
		    clist.cl_name);
		return (DCMD_ERR);
	}
	if (class_name_sz >= CLASS_LIST_FIELD_MAX - 1)
		(void) strcpy(&class_name[CLASS_LIST_FIELD_MAX - 4], "...");

	mdb_printf("%-?p %-24s %-?p\n", addr, class_name,
	    clist.cl_subclass_list);

	return (DCMD_OK);
}
Exemple #15
0
void
cyclic_pretty_dump(cyc_cpu_t *cpu)
{
	char **c;
	int i, j;
	int width = 80;
	int depth;
	cyc_index_t *heap;
	size_t 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", (uintptr_t)cpu->cyp_heap);
		return;
	}

	for (depth = 0; (1 << depth) < cpu->cyp_nelems; depth++)
		continue;
	depth++;
	depth = (depth + 1) * LINES_PER_LEVEL;

	c = mdb_zalloc(sizeof (char *) * depth, UM_SLEEP|UM_GC);

	for (i = 0; i < depth; i++)
		c[i] = mdb_zalloc(width, UM_SLEEP|UM_GC);

	cyclic_dump_node(cpu, heap, c, width, 0, 1, width - 2, 0);

	for (i = 0; i < depth; i++) {
		int dump = 0;
		for (j = 0; j < width - 1; j++) {
			if (c[i][j] == '\0')
				c[i][j] = ' ';
			else
				dump = 1;
		}
		c[i][width - 2] = '\n';

		if (dump)
			mdb_printf(c[i]);
	}
}
Exemple #16
0
/*
 * Display a single sv_glcient_t structure.
 * If called with no address, performs a global walk of all sv_gclients.
 */
static int
sv_gclient(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	sv_gclient_t sg;
	char name[64];

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

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

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

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

	if (mdb_readstr(name, sizeof (name), (uintptr_t)sg.sg_name) == -1) {
		mdb_warn("failed to read sv_gclient name at %p", addr);
		return (DCMD_ERR);
	}

	mdb_printf("%p  %8T%p  %8T%llx  %8T%s",
	    addr, sg.sg_next, sg.sg_id, name);

	return (DCMD_OK);
}
Exemple #17
0
/*ARGSUSED*/
int
dof_relodesc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	dof_relodesc_t r;

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

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

	mdb_printf("dofr_name = %u\n", r.dofr_name);
	mdb_printf("dofr_type = %u\n", r.dofr_type);
	mdb_printf("dofr_offset = 0x%llx\n", r.dofr_offset);
	mdb_printf("dofr_data = 0x%llx\n", r.dofr_data);

	return (DCMD_OK);
}
Exemple #18
0
static int
sv_gclient_wstep(mdb_walk_state_t *wsp)
{
	int status;

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

	if (mdb_vread(wsp->walk_data,
	    sizeof (sv_gclient_t), wsp->walk_addr) == -1) {
		mdb_warn("failed to read sv_gclient at %p", wsp->walk_addr);
		return (WALK_DONE);
	}

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

	wsp->walk_addr = (uintptr_t)(((sv_gclient_t *)wsp->walk_data)->sg_next);
	return (status);
}
Exemple #19
0
/*ARGSUSED*/
int
dof_ecbdesc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	dof_ecbdesc_t e;

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

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

	mdb_printf("dofe_probes = %d\n", e.dofe_probes);
	mdb_printf("dofe_actions = %d\n", e.dofe_actions);
	mdb_printf("dofe_pred = %d\n", e.dofe_pred);
	mdb_printf("dofe_uarg = 0x%llx\n", e.dofe_uarg);

	return (DCMD_OK);
}
Exemple #20
0
int
swap_walk_step(mdb_walk_state_t *wsp)
{
	uintptr_t	sip;
	struct swapinfo	si;

	sip = wsp->walk_addr;

	if (sip == NULL)
		return (WALK_DONE);

	if (mdb_vread(&si, sizeof (struct swapinfo), sip) == -1) {
		mdb_warn("unable to read swapinfo at %#lx", sip);
		return (WALK_ERR);
	}

	wsp->walk_addr = (uintptr_t)si.si_next;

	return (wsp->walk_callback(sip, &si, wsp->walk_cbdata));
}
Exemple #21
0
/*
 * Walk the NCA timer list; done as a layered walk on top of "nca_cpu".
 */
static int
nca_timer_walk_step(mdb_walk_state_t *wsp)
{
	const nca_cpu_t	*nca_cpu = wsp->walk_layer;
	ti_t		ti;

	/*
	 * Just skip CPUs that don't have any timers running.
	 */
	if (nca_cpu->tcp_ti == NULL)
		return (WALK_NEXT);

	if (mdb_vread(&ti, sizeof (ti_t), (uintptr_t)nca_cpu->tcp_ti) == -1) {
		mdb_warn("cannot read ti_t at %p", nca_cpu->tcp_ti);
		return (WALK_ERR);
	}

	return (wsp->walk_callback((uintptr_t)nca_cpu->tcp_ti, &ti,
	    wsp->walk_cbdata));
}
Exemple #22
0
static int
case_walk_step(mdb_walk_state_t *wsp)
{
	uintptr_t addr = wsp->walk_addr;
	fmd_case_impl_t ci;

	if (wsp->walk_data != NULL)
		return (hash_walk_step(wsp));

	if (addr == NULL)
		return (WALK_DONE);

	if (mdb_vread(&ci, sizeof (ci), addr) != sizeof (ci)) {
		mdb_warn("failed to read fmd_case at %p", addr);
		return (WALK_ERR);
	}

	wsp->walk_addr = (uintptr_t)ci.ci_list.l_next;
	return (wsp->walk_callback(addr, &ci, wsp->walk_cbdata));
}
Exemple #23
0
int
memlist_walk_step(mdb_walk_state_t *wsp)
{
	uintptr_t	mlp;
	struct memlist	ml;

	mlp = wsp->walk_addr;

	if (mlp == NULL)
		return (WALK_DONE);

	if (mdb_vread(&ml, sizeof (struct memlist), mlp) == -1) {
		mdb_warn("unable to read memlist at %#lx", mlp);
		return (WALK_ERR);
	}

	wsp->walk_addr = (uintptr_t)ml.ml_next;

	return (wsp->walk_callback(mlp, &ml, wsp->walk_cbdata));
}
Exemple #24
0
int
vfs_walk_step(mdb_walk_state_t *wsp)
{
	vfs_t vfs;
	int status;

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

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

	if (vfs.vfs_next == wsp->walk_data)
		return (WALK_DONE);

	wsp->walk_addr = (uintptr_t)vfs.vfs_next;

	return (status);
}
Exemple #25
0
/*ARGSUSED*/
static int
fcf_serd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	fcf_serd_t fcfd;

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

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

	mdb_printf("fcfd_name = 0x%x\n", fcfd.fcfd_name);
	mdb_printf("fcfd_events = %u\n", fcfd.fcfd_events);
	mdb_printf("fcfd_n = >%u\n", fcfd.fcfd_n);
	mdb_printf("fcfd_t = %lluns\n", fcfd.fcfd_t);

	return (DCMD_OK);
}
Exemple #26
0
static int
ulwp_walk_init(mdb_walk_state_t *wsp)
{
	uintptr_t addr = wsp->walk_addr;
	uintptr_t uber_addr;

	if (addr == NULL &&
	    ((uber_addr = uberdata_addr()) == NULL ||
	    mdb_vread(&addr, sizeof (addr),
	    uber_addr + OFFSETOF(uberdata_t, all_lwps))
	    != sizeof (addr))) {
		mdb_warn("cannot find 'uberdata.all_lwps'");
		return (WALK_ERR);
	}
	if (addr == NULL)
		return (WALK_DONE);
	wsp->walk_addr = addr;
	wsp->walk_data = (void *)addr;
	return (WALK_NEXT);
}
Exemple #27
0
/* ARGSUSED */
int
group(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	group_t	group;
	int	opt_q = 0; /* display only address. */

	/* Should provide an address */
	if (!(flags & DCMD_ADDRSPEC))
		return (DCMD_USAGE);

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

	if (flags & DCMD_PIPE_OUT)
		opt_q = B_TRUE;

	if (DCMD_HDRSPEC(flags) && !opt_q) {
		mdb_printf("%?s %6s %9s %?s\n",
		    "ADDR",
		    "SIZE",
		    "CAPACITY",
		    "SET");
	}

	if (mdb_vread(&group, sizeof (struct group), addr) == -1) {
		mdb_warn("unable to read 'group' at %p", addr);
		return (DCMD_ERR);
	}

	if (opt_q) {
		mdb_printf("%0?p\n", addr);
		return (DCMD_OK);
	}

	mdb_printf("%?p %6d %9d %?p\n",
	    addr, group.grp_size, group.grp_capacity, group.grp_set);

	return (DCMD_OK);
}
Exemple #28
0
/*
 * Given a usba_device pointer, figure out which dip is associated with it.
 * Relies on usba_device.usb_root_hub_dip being accurate.
 *
 * - usb_dev_addr is a pointer to a usba_device_t in core.
 * - dip_addr is the address of a uintptr_t to receive the address in core
 * of the found dip (if any).
 *
 * Returns:
 *  0 on success (no match found)
 *  1 on success (match found)
 * -1 on errors.
 */
static int
usba_device2dip(uintptr_t usb_dev_addr, uintptr_t *dip_addr)
{
	usba_device_t			usb_dev;
	usba_device2devinfo_cbdata_t	cb_data;

	/*
	 * Walk all USB children of the root hub devinfo.
	 * The callback func looks for a match on the usba_device address.
	 */
	cb_data.u2d_target_usb_dev_p = usb_dev_addr;
	cb_data.u2d_dip_addr = dip_addr;
	cb_data.u2d_found = FALSE;

	if (mdb_vread(&usb_dev, sizeof (usba_device_t),
	    usb_dev_addr) == -1) {
		mdb_warn("failed to read usba_device struct");

		return (-1);
	}

	/*
	 * Walk devinfo children starting with the root hub node,
	 * looking for a match on the usba_device pointer (which is what
	 * find_dip does).
	 * Result is placed in cb_data.dip_addr.
	 */
	if (mdb_pwalk("devinfo_children", find_dip, &cb_data,
	    (uintptr_t)usb_dev.usb_root_hub_dip) != 0) {
		mdb_warn("failed to walk devinfo_children");

		return (-1);
	}

	if (cb_data.u2d_found == TRUE) {

		return (1);
	}

	return (0);
}
Exemple #29
0
/*ARGSUSED*/
static int
fcf_case(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	fcf_case_t fcfc;

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

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

	mdb_printf("fcfc_uuid = 0x%x\n", fcfc.fcfc_uuid);
	mdb_printf("fcfc_state = %u\n", fcfc.fcfc_state);
	mdb_printf("fcfc_bufs = %u\n", fcfc.fcfc_bufs);
	mdb_printf("fcfc_events = %u\n", fcfc.fcfc_events);
	mdb_printf("fcfc_suspects = %u\n", fcfc.fcfc_suspects);

	return (DCMD_OK);
}
Exemple #30
0
int
sysevent_walk_step(mdb_walk_state_t *wsp)
{
	int status;
	uintptr_t ev_arg_addr;

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

	if (mdb_vread(wsp->walk_data, sizeof (log_eventq_t),
	    wsp->walk_addr) == -1) {
		mdb_warn("failed to read event queue at %p", wsp->walk_addr);
		return (WALK_ERR);
	}
	ev_arg_addr = wsp->walk_addr + offsetof(log_eventq_t, arg.buf);

	status = wsp->walk_callback(ev_arg_addr, wsp->walk_data,
	    wsp->walk_cbdata);
	wsp->walk_addr = (uintptr_t)(((log_eventq_t *)wsp->walk_data)->next);
	return (status);
}