xref: /illumos-gate/usr/src/cmd/mdb/common/modules/idm/idm.c (revision b1da084b)
1a6d42e7dSPeter Dunlap /*
2a6d42e7dSPeter Dunlap  * CDDL HEADER START
3a6d42e7dSPeter Dunlap  *
4a6d42e7dSPeter Dunlap  * The contents of this file are subject to the terms of the
5a6d42e7dSPeter Dunlap  * Common Development and Distribution License (the "License").
6a6d42e7dSPeter Dunlap  * You may not use this file except in compliance with the License.
7a6d42e7dSPeter Dunlap  *
8a6d42e7dSPeter Dunlap  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9a6d42e7dSPeter Dunlap  * or http://www.opensolaris.org/os/licensing.
10a6d42e7dSPeter Dunlap  * See the License for the specific language governing permissions
11a6d42e7dSPeter Dunlap  * and limitations under the License.
12a6d42e7dSPeter Dunlap  *
13a6d42e7dSPeter Dunlap  * When distributing Covered Code, include this CDDL HEADER in each
14a6d42e7dSPeter Dunlap  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15a6d42e7dSPeter Dunlap  * If applicable, add the following below this CDDL HEADER, with the
16a6d42e7dSPeter Dunlap  * fields enclosed by brackets "[]" replaced with your own identifying
17a6d42e7dSPeter Dunlap  * information: Portions Copyright [yyyy] [name of copyright owner]
18a6d42e7dSPeter Dunlap  *
19a6d42e7dSPeter Dunlap  * CDDL HEADER END
20a6d42e7dSPeter Dunlap  */
21a6d42e7dSPeter Dunlap /*
225819f75eSPeter Gill  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
23a6d42e7dSPeter Dunlap  */
24a6d42e7dSPeter Dunlap 
25d3d50737SRafael Vanoni #include <mdb/mdb_modapi.h>
26d3d50737SRafael Vanoni #include <mdb/mdb_ks.h>
27d3d50737SRafael Vanoni 
28a6d42e7dSPeter Dunlap #include <sys/cpuvar.h>
29a6d42e7dSPeter Dunlap #include <sys/conf.h>
30a6d42e7dSPeter Dunlap #include <sys/file.h>
31a6d42e7dSPeter Dunlap #include <sys/types.h>
32a6d42e7dSPeter Dunlap #include <sys/taskq.h>
33a6d42e7dSPeter Dunlap #include <sys/sysmacros.h>
34a6d42e7dSPeter Dunlap #include <sys/socket.h>		/* networking stuff */
35a6d42e7dSPeter Dunlap #include <sys/strsubr.h>	/* networking stuff */
36a6d42e7dSPeter Dunlap #include <sys/nvpair.h>
37a6d42e7dSPeter Dunlap #include <sys/sunldi.h>
38a6d42e7dSPeter Dunlap #include <sys/stmf.h>
39a6d42e7dSPeter Dunlap #include <sys/stmf_ioctl.h>
40a6d42e7dSPeter Dunlap #include <sys/portif.h>
41a6d42e7dSPeter Dunlap 
42a6d42e7dSPeter Dunlap #define	IDM_CONN_SM_STRINGS
43bf604c64SPeter Dunlap #define	IDM_TASK_SM_STRINGS
44a6d42e7dSPeter Dunlap #define	ISCSIT_TGT_SM_STRINGS
45a6d42e7dSPeter Dunlap #define	ISCSIT_SESS_SM_STRINGS
46a6d42e7dSPeter Dunlap #define	ISCSIT_LOGIN_SM_STRINGS
4730e7468fSPeter Dunlap #define	ISCSI_SESS_SM_STRINGS
4830e7468fSPeter Dunlap #define	ISCSI_CMD_SM_STRINGS
4930e7468fSPeter Dunlap #define	ISCSI_ICS_NAMES
5030e7468fSPeter Dunlap #define	ISCSI_LOGIN_STATE_NAMES
515f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States #define	IDM_CN_NOTIFY_STRINGS
52a6d42e7dSPeter Dunlap #include <sys/idm/idm.h>
53aff4bce5Syi zhang - Sun Microsystems - Beijing China #include <iscsi.h>
54a6d42e7dSPeter Dunlap #include <iscsit.h>
55a6d42e7dSPeter Dunlap #include <iscsit_isns.h>
565819f75eSPeter Gill #include <sys/ib/clients/iser/iser.h>
57a6d42e7dSPeter Dunlap 
58a6d42e7dSPeter Dunlap /*
59a6d42e7dSPeter Dunlap  * We want to be able to print multiple levels of object hierarchy with a
60a6d42e7dSPeter Dunlap  * single dcmd information, and preferably also exclude intermediate
61a6d42e7dSPeter Dunlap  * levels if desired.  For example some of the target objects have the
62a6d42e7dSPeter Dunlap  * following relationship:
63a6d42e7dSPeter Dunlap  *
64a6d42e7dSPeter Dunlap  * target --> session --> connection --> task
65a6d42e7dSPeter Dunlap  *
66a6d42e7dSPeter Dunlap  * The session dcmd should allow the printing of all associated tasks for the
67a6d42e7dSPeter Dunlap  * sessions without printing all the associated connections.  To accomplish
68a6d42e7dSPeter Dunlap  * this the following structure contains a bit for each object type.  Dcmds
695819f75eSPeter Gill  * should invoke the functions for child objects if any bits are set
70a6d42e7dSPeter Dunlap  * in iscsi_dcmd_ctrl_t but the functions for the child object should only
715819f75eSPeter Gill  * print data if their associated bit is set. Each object type should print
725819f75eSPeter Gill  * a header for its first occurrence or if it is being printed as a child
735819f75eSPeter Gill  * object for the first occurrence under each parent. For the model to follow
745819f75eSPeter Gill  * see how idc->idc_header is handled in iscsi_sess_impl.
75a6d42e7dSPeter Dunlap  *
76a6d42e7dSPeter Dunlap  * Each dcmd should provide an external interface with the standard MDB API
77a6d42e7dSPeter Dunlap  * and an internal interface that accepts iscsi_dcmd_ctrl_t.  To display
78a6d42e7dSPeter Dunlap  * child objects the dcmd calls the internal interface for the child object
79a6d42e7dSPeter Dunlap  * directly.  Dcmds invoked from the command line will, of course, call the
80a6d42e7dSPeter Dunlap  * external interface.  See iscsi_conn() and iscsi_conn_impl().
81a6d42e7dSPeter Dunlap  */
82a6d42e7dSPeter Dunlap 
83a6d42e7dSPeter Dunlap typedef struct {
84a6d42e7dSPeter Dunlap 	union	{
85a6d42e7dSPeter Dunlap 		uint32_t	idc_children;
86a6d42e7dSPeter Dunlap 		struct {
87a6d42e7dSPeter Dunlap 			uint32_t	idc_tgt:1,
885819f75eSPeter Gill 					idc_tpg:1,
89a6d42e7dSPeter Dunlap 					idc_tpgt:1,
90a6d42e7dSPeter Dunlap 					idc_portal:1,
91a6d42e7dSPeter Dunlap 					idc_sess:1,
92a6d42e7dSPeter Dunlap 					idc_conn:1,
935819f75eSPeter Gill 					idc_svc:1,
94a6d42e7dSPeter Dunlap 					idc_print_ip:1,
95a6d42e7dSPeter Dunlap 					idc_task:1,
96a6d42e7dSPeter Dunlap 					idc_buffer:1,
97a6d42e7dSPeter Dunlap 					idc_states:1,
98a6d42e7dSPeter Dunlap 					idc_rc_audit:1,
99a6d42e7dSPeter Dunlap 					idc_lun:1,
1005819f75eSPeter Gill 					idc_hba:1,
1015819f75eSPeter Gill 					idc_cmd:1;
102a6d42e7dSPeter Dunlap 		} child;
103a6d42e7dSPeter Dunlap 	} u;
104a6d42e7dSPeter Dunlap 	boolean_t		idc_ini;
105a6d42e7dSPeter Dunlap 	boolean_t		idc_tgt;
106a6d42e7dSPeter Dunlap 	boolean_t		idc_verbose;
107a6d42e7dSPeter Dunlap 	boolean_t		idc_header;
108a6d42e7dSPeter Dunlap 	/*
109a6d42e7dSPeter Dunlap 	 * Our connection dcmd code works off the global connection lists
110a6d42e7dSPeter Dunlap 	 * in IDM since we want to know about connections even when they
111a6d42e7dSPeter Dunlap 	 * have not progressed to the point that they have an associated
112a6d42e7dSPeter Dunlap 	 * session.  If we use "::iscsi_sess [-c]" then we only want to
113a6d42e7dSPeter Dunlap 	 * see connections associated with particular session.  To avoid
114a6d42e7dSPeter Dunlap 	 * writing a separate set of code to print session-specific connection
115a6d42e7dSPeter Dunlap 	 * the session code should set the sessions kernel address in the
116a6d42e7dSPeter Dunlap 	 * following field.  The connection code will then only print
117a6d42e7dSPeter Dunlap 	 * connections that match.
118a6d42e7dSPeter Dunlap 	 */
119a6d42e7dSPeter Dunlap 	uintptr_t		idc_assoc_session;
120a6d42e7dSPeter Dunlap } iscsi_dcmd_ctrl_t;
121a6d42e7dSPeter Dunlap 
1225819f75eSPeter Gill typedef struct idm_hba_walk_info {
1235819f75eSPeter Gill 	void	**array;
1245819f75eSPeter Gill 	int	n_elements;
1255819f75eSPeter Gill 	int	cur_element;
1265819f75eSPeter Gill 	void	*data;
1275819f75eSPeter Gill } idm_hba_walk_info_t;
1285819f75eSPeter Gill 
129a6d42e7dSPeter Dunlap static int iscsi_walk_all_sess(iscsi_dcmd_ctrl_t *idc);
130a6d42e7dSPeter Dunlap static int iscsi_walk_all_conn(iscsi_dcmd_ctrl_t *idc);
131a6d42e7dSPeter Dunlap static int iscsi_tgt_walk_cb(uintptr_t addr, const void *list_walker_data,
132a6d42e7dSPeter Dunlap     void *idc_void);
133a6d42e7dSPeter Dunlap static int iscsi_tpgt_walk_cb(uintptr_t addr, const void *list_walker_data,
134a6d42e7dSPeter Dunlap     void *idc_void);
135a6d42e7dSPeter Dunlap static int iscsi_tpg_walk_cb(uintptr_t addr, const void *list_walker_data,
136a6d42e7dSPeter Dunlap     void *idc_void);
137a6d42e7dSPeter Dunlap static int iscsi_portal_walk_cb(uintptr_t addr, const void *list_walker_data,
138a6d42e7dSPeter Dunlap     void *idc_void);
139a6d42e7dSPeter Dunlap static int iscsi_sess_walk_cb(uintptr_t addr, const void *list_walker_data,
140a6d42e7dSPeter Dunlap     void *idc_void);
141a6d42e7dSPeter Dunlap static int iscsi_conn_walk_cb(uintptr_t addr, const void *list_walker_data,
142a6d42e7dSPeter Dunlap     void *idc_void);
143a6d42e7dSPeter Dunlap static int iscsi_buffer_walk_cb(uintptr_t addr, const void *list_walker_data,
144a6d42e7dSPeter Dunlap     void *idc_void);
1455819f75eSPeter Gill static int iscsi_svc_walk_cb(uintptr_t addr, const void *list_walker_data,
1465819f75eSPeter Gill     void *idc_void);
1475819f75eSPeter Gill static int iscsi_ini_hba_walk_cb(uintptr_t addr, const void *vhba,
1485819f75eSPeter Gill     void *idc_void);
1495819f75eSPeter Gill static int iscsi_ini_sess_walk_cb(uintptr_t addr, const void *vsess,
1505819f75eSPeter Gill     void *idc);
1515819f75eSPeter Gill static int iscsi_ini_conn_walk_cb(uintptr_t addr, const void *vconn,
1525819f75eSPeter Gill     void *idc_void);
1535819f75eSPeter Gill static int iscsi_ini_lun_walk_cb(uintptr_t addr, const void *vlun,
1545819f75eSPeter Gill     void *idc_void);
1555819f75eSPeter Gill static int iscsi_ini_cmd_walk_cb(uintptr_t addr, const void *vcmd,
1565819f75eSPeter Gill     void *idc);
157a6d42e7dSPeter Dunlap static int iscsi_tgt_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
158a6d42e7dSPeter Dunlap static int iscsi_tpgt_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
159a6d42e7dSPeter Dunlap static int iscsi_tpg_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
160a6d42e7dSPeter Dunlap static int iscsi_portal_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
161a6d42e7dSPeter Dunlap static int iscsi_sess_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
162a6d42e7dSPeter Dunlap static int iscsi_conn_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
163a6d42e7dSPeter Dunlap static void iscsi_print_iscsit_conn_data(idm_conn_t *ict);
1645819f75eSPeter Gill static void iscsi_print_ini_conn_data(idm_conn_t *ict);
165a6d42e7dSPeter Dunlap static void iscsi_print_idm_conn_data(idm_conn_t *ict);
166a6d42e7dSPeter Dunlap static int iscsi_task_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
167a6d42e7dSPeter Dunlap static void iscsi_print_iscsit_task_data(idm_task_t *idt);
168a6d42e7dSPeter Dunlap static int iscsi_buffer_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
169a6d42e7dSPeter Dunlap static idm_conn_type_t idm_conn_type(uintptr_t addr);
170a6d42e7dSPeter Dunlap static int iscsi_i_task_impl(idm_task_t *idt, uintptr_t addr,
171a6d42e7dSPeter Dunlap     iscsi_dcmd_ctrl_t *idc);
172a6d42e7dSPeter Dunlap static int iscsi_refcnt_impl(uintptr_t addr);
173a6d42e7dSPeter Dunlap static int iscsi_sm_audit_impl(uintptr_t addr);
174a6d42e7dSPeter Dunlap static int iscsi_isns(uintptr_t addr, uint_t flags, int argc,
175a6d42e7dSPeter Dunlap     const mdb_arg_t *argv);
1765819f75eSPeter Gill static int iscsi_svc_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
1775819f75eSPeter Gill static int iscsi_ini_hba_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
1785819f75eSPeter Gill static int iscsi_print_ini_sess(uintptr_t addr, iscsi_sess_t *sess,
1795819f75eSPeter Gill     iscsi_dcmd_ctrl_t *idc);
1805819f75eSPeter Gill static int iscsi_print_ini_lun(uintptr_t addr, const iscsi_lun_t *lun,
1815819f75eSPeter Gill     iscsi_dcmd_ctrl_t *idc);
1825819f75eSPeter Gill static int iscsi_print_ini_cmd(uintptr_t addr, const iscsi_cmd_t *cmd,
1835819f75eSPeter Gill     iscsi_dcmd_ctrl_t *idc);
1845819f75eSPeter Gill static int iscsi_ini_sess_walk_init(mdb_walk_state_t *wsp);
1855819f75eSPeter Gill static int iscsi_ini_sess_step(mdb_walk_state_t *wsp);
1865819f75eSPeter Gill static int iscsi_ini_conn_walk_init(mdb_walk_state_t *wsp);
1875819f75eSPeter Gill static int iscsi_ini_conn_step(mdb_walk_state_t *wsp);
1885819f75eSPeter Gill static int iscsi_ini_lun_walk_init(mdb_walk_state_t *wsp);
1895819f75eSPeter Gill static int iscsi_ini_lun_step(mdb_walk_state_t *wsp);
1905819f75eSPeter Gill static int iscsi_ini_cmd_walk_init(mdb_walk_state_t *wsp);
1915819f75eSPeter Gill static int iscsi_ini_cmd_step(mdb_walk_state_t *wsp);
19230e7468fSPeter Dunlap static const char *iscsi_idm_conn_event(unsigned int event);
19330e7468fSPeter Dunlap static const char *iscsi_iscsit_tgt_event(unsigned int event);
19430e7468fSPeter Dunlap static const char *iscsi_iscsit_sess_event(unsigned int event);
19530e7468fSPeter Dunlap static const char *iscsi_iscsit_login_event(unsigned int event);
19630e7468fSPeter Dunlap static const char *iscsi_iscsi_cmd_event(unsigned int event);
19730e7468fSPeter Dunlap static const char *iscsi_iscsi_sess_event(unsigned int event);
19830e7468fSPeter Dunlap static const char *iscsi_idm_conn_state(unsigned int state);
19930e7468fSPeter Dunlap static const char *iscsi_idm_task_state(unsigned int state);
20030e7468fSPeter Dunlap static const char *iscsi_iscsit_tgt_state(unsigned int state);
20130e7468fSPeter Dunlap static const char *iscsi_iscsit_sess_state(unsigned int state);
20230e7468fSPeter Dunlap static const char *iscsi_iscsit_login_state(unsigned int state);
20330e7468fSPeter Dunlap static const char *iscsi_iscsi_cmd_state(unsigned int state);
20430e7468fSPeter Dunlap static const char *iscsi_iscsi_sess_state(unsigned int state);
20530e7468fSPeter Dunlap static const char *iscsi_iscsi_conn_state(unsigned int state);
2065f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States static const char *iscsi_iscsi_conn_event(unsigned int event);
20730e7468fSPeter Dunlap static const char *iscsi_iscsi_login_state(unsigned int state);
208a6d42e7dSPeter Dunlap 
209a6d42e7dSPeter Dunlap static void iscsi_format_timestamp(char *ts_str, int strlen,
210a6d42e7dSPeter Dunlap     timespec_t *ts);
21130e7468fSPeter Dunlap static char *iscsi_inet_ntop(int af, const void *addr, char *buf, int addrlen);
212a6d42e7dSPeter Dunlap static void convert2ascii(char *, const in6_addr_t *);
213a6d42e7dSPeter Dunlap static int sa_to_str(struct sockaddr_storage *sa, char *addr);
214e42a0851Speter dunlap static int iscsi_isns_esi_cb(uintptr_t addr, const void *walker_data,
215e42a0851Speter dunlap     void *data);
216a6d42e7dSPeter Dunlap static int iscsi_isns_portal_cb(uintptr_t addr, const void *walker_data,
217a6d42e7dSPeter Dunlap     void *data);
218a6d42e7dSPeter Dunlap 
219a6d42e7dSPeter Dunlap #define	PORTAL_STR_LEN	(INET6_ADDRSTRLEN + 7)
220a6d42e7dSPeter Dunlap 
221a6d42e7dSPeter Dunlap /*
222a6d42e7dSPeter Dunlap  * ::iscsi_tgt [-scatgpbSRv]
223a6d42e7dSPeter Dunlap  *
224a6d42e7dSPeter Dunlap  * iscsi_tgt - Print out information associated with an iscsit target instance
225a6d42e7dSPeter Dunlap  *
226a6d42e7dSPeter Dunlap  * s	Print associated session information
227a6d42e7dSPeter Dunlap  * c	Print associated connection information
228a6d42e7dSPeter Dunlap  * a	Print IP addresses with connection information
229a6d42e7dSPeter Dunlap  * t	Print associated task information
230a6d42e7dSPeter Dunlap  * g	Print associated TPG information
231a6d42e7dSPeter Dunlap  * p	Print portals with TPG information
232a6d42e7dSPeter Dunlap  * b	Print associated buffer information
233a6d42e7dSPeter Dunlap  * S	Print recent state events and transitions
234a6d42e7dSPeter Dunlap  * R	Print reference count audit data
235a6d42e7dSPeter Dunlap  * v	Verbose output about the connection
236a6d42e7dSPeter Dunlap  */
237a6d42e7dSPeter Dunlap /*ARGSUSED*/
238a6d42e7dSPeter Dunlap static int
239a6d42e7dSPeter Dunlap iscsi_tgt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
240a6d42e7dSPeter Dunlap {
241a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	idc;
242a6d42e7dSPeter Dunlap 	int			buffer = 0, task = 0, print_ip = 0;
243a6d42e7dSPeter Dunlap 	int			tpgt = 0, conn = 0, sess = 0, portal = 0;
244a6d42e7dSPeter Dunlap 	int			states = 0, rc_audit = 0;
245a6d42e7dSPeter Dunlap 	uintptr_t		iscsit_global_addr, avl_addr, list_addr;
246a6d42e7dSPeter Dunlap 	GElf_Sym		sym;
247a6d42e7dSPeter Dunlap 
248a6d42e7dSPeter Dunlap 	bzero(&idc, sizeof (idc));
249a6d42e7dSPeter Dunlap 	if (mdb_getopts(argc, argv,
250a6d42e7dSPeter Dunlap 	    'a', MDB_OPT_SETBITS, TRUE, &print_ip,
251a6d42e7dSPeter Dunlap 	    'g', MDB_OPT_SETBITS, TRUE, &tpgt,
252a6d42e7dSPeter Dunlap 	    's', MDB_OPT_SETBITS, TRUE, &sess,
253a6d42e7dSPeter Dunlap 	    'c', MDB_OPT_SETBITS, TRUE, &conn,
254a6d42e7dSPeter Dunlap 	    't', MDB_OPT_SETBITS, TRUE, &task,
255a6d42e7dSPeter Dunlap 	    'b', MDB_OPT_SETBITS, TRUE, &buffer,
256a6d42e7dSPeter Dunlap 	    'p', MDB_OPT_SETBITS, TRUE, &portal,
257a6d42e7dSPeter Dunlap 	    'S', MDB_OPT_SETBITS, TRUE, &states,
258a6d42e7dSPeter Dunlap 	    'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
259a6d42e7dSPeter Dunlap 	    'v', MDB_OPT_SETBITS, TRUE, &idc.idc_verbose,
260a6d42e7dSPeter Dunlap 	    NULL) != argc)
261a6d42e7dSPeter Dunlap 		return (DCMD_USAGE);
262a6d42e7dSPeter Dunlap 
263a6d42e7dSPeter Dunlap 	idc.u.child.idc_tgt = 1;
264a6d42e7dSPeter Dunlap 	idc.u.child.idc_print_ip = print_ip;
265a6d42e7dSPeter Dunlap 	idc.u.child.idc_tpgt = tpgt;
266a6d42e7dSPeter Dunlap 	idc.u.child.idc_portal = portal;
267a6d42e7dSPeter Dunlap 	idc.u.child.idc_sess = sess;
268a6d42e7dSPeter Dunlap 	idc.u.child.idc_conn = conn;
269a6d42e7dSPeter Dunlap 	idc.u.child.idc_task = task;
270a6d42e7dSPeter Dunlap 	idc.u.child.idc_buffer = buffer;
271a6d42e7dSPeter Dunlap 	idc.u.child.idc_states = states;
272a6d42e7dSPeter Dunlap 	idc.u.child.idc_rc_audit = rc_audit;
273a6d42e7dSPeter Dunlap 
274a6d42e7dSPeter Dunlap 	if (DCMD_HDRSPEC(flags))
275a6d42e7dSPeter Dunlap 		idc.idc_header = 1;
276a6d42e7dSPeter Dunlap 
277a6d42e7dSPeter Dunlap 	/*
278a6d42e7dSPeter Dunlap 	 * If no address was specified on the command line, we
279a6d42e7dSPeter Dunlap 	 * print out all tgtions
280a6d42e7dSPeter Dunlap 	 */
281a6d42e7dSPeter Dunlap 	if (!(flags & DCMD_ADDRSPEC)) {
282a6d42e7dSPeter Dunlap 		if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
283a6d42e7dSPeter Dunlap 			mdb_warn("failed to find symbol 'iscsit_global'");
284a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
285a6d42e7dSPeter Dunlap 		}
286a6d42e7dSPeter Dunlap 		iscsit_global_addr = (uintptr_t)sym.st_value;
287a6d42e7dSPeter Dunlap 		avl_addr = iscsit_global_addr +
288a6d42e7dSPeter Dunlap 		    offsetof(iscsit_global_t, global_target_list);
289a6d42e7dSPeter Dunlap 		if (mdb_pwalk("avl", iscsi_tgt_walk_cb, &idc, avl_addr) == -1) {
290a6d42e7dSPeter Dunlap 			mdb_warn("avl walk failed for global target tree");
291a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
292a6d42e7dSPeter Dunlap 		}
293a6d42e7dSPeter Dunlap 		list_addr = iscsit_global_addr +
294a6d42e7dSPeter Dunlap 		    offsetof(iscsit_global_t, global_deleted_target_list);
295a6d42e7dSPeter Dunlap 		if (mdb_pwalk("list", iscsi_tgt_walk_cb,
296a6d42e7dSPeter Dunlap 		    &idc, list_addr) == -1) {
297a6d42e7dSPeter Dunlap 			mdb_warn("list walk failed for deleted target list");
298a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
299a6d42e7dSPeter Dunlap 		}
300a6d42e7dSPeter Dunlap 		return (DCMD_OK);
301a6d42e7dSPeter Dunlap 	}
3025819f75eSPeter Gill 	return (iscsi_tgt_impl(addr, &idc));
303a6d42e7dSPeter Dunlap }
304a6d42e7dSPeter Dunlap 
305a6d42e7dSPeter Dunlap static int
306a6d42e7dSPeter Dunlap iscsi_tpg(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
307a6d42e7dSPeter Dunlap {
308a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	idc;
309a6d42e7dSPeter Dunlap 	uintptr_t		iscsit_global_addr, avl_addr;
310a6d42e7dSPeter Dunlap 	GElf_Sym		sym;
3115819f75eSPeter Gill 	int			rc_audit = 0;
312a6d42e7dSPeter Dunlap 
313a6d42e7dSPeter Dunlap 	bzero(&idc, sizeof (idc));
314a6d42e7dSPeter Dunlap 	if (mdb_getopts(argc, argv,
3155819f75eSPeter Gill 	    'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
316a6d42e7dSPeter Dunlap 	    NULL) != argc)
317a6d42e7dSPeter Dunlap 		return (DCMD_USAGE);
318a6d42e7dSPeter Dunlap 
3195819f75eSPeter Gill 	/* Always print tpgs and portals */
3205819f75eSPeter Gill 	idc.u.child.idc_tpg = 1;
3215819f75eSPeter Gill 	idc.u.child.idc_portal = 1;
3225819f75eSPeter Gill 	idc.u.child.idc_rc_audit = rc_audit;
323a6d42e7dSPeter Dunlap 	if (DCMD_HDRSPEC(flags))
324a6d42e7dSPeter Dunlap 		idc.idc_header = 1;
325a6d42e7dSPeter Dunlap 
326a6d42e7dSPeter Dunlap 	/*
327a6d42e7dSPeter Dunlap 	 * If no address was specified on the command line, we
328a6d42e7dSPeter Dunlap 	 * print out all tgtions
329a6d42e7dSPeter Dunlap 	 */
330a6d42e7dSPeter Dunlap 	if (!(flags & DCMD_ADDRSPEC)) {
331a6d42e7dSPeter Dunlap 		if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
332a6d42e7dSPeter Dunlap 			mdb_warn("failed to find symbol 'iscsit_global'");
333a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
334a6d42e7dSPeter Dunlap 		}
335a6d42e7dSPeter Dunlap 		iscsit_global_addr = (uintptr_t)sym.st_value;
336a6d42e7dSPeter Dunlap 		avl_addr = iscsit_global_addr +
337a6d42e7dSPeter Dunlap 		    offsetof(iscsit_global_t, global_tpg_list);
338a6d42e7dSPeter Dunlap 		if (mdb_pwalk("avl", iscsi_tpg_walk_cb, &idc, avl_addr) == -1) {
339a6d42e7dSPeter Dunlap 			mdb_warn("avl walk failed for global target tree");
340a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
341a6d42e7dSPeter Dunlap 		}
342a6d42e7dSPeter Dunlap 		return (DCMD_OK);
343a6d42e7dSPeter Dunlap 	}
3445819f75eSPeter Gill 	return (iscsi_tpg_impl(addr, &idc));
345a6d42e7dSPeter Dunlap }
346a6d42e7dSPeter Dunlap 
347a6d42e7dSPeter Dunlap /*
3485819f75eSPeter Gill  * ::iscsi_tpgt [-pR]
3495819f75eSPeter Gill  *
3505819f75eSPeter Gill  * Print tpgt information.
3515819f75eSPeter Gill  * R	Print reference count audit data
3525819f75eSPeter Gill  * p	Print portal data
3535819f75eSPeter Gill  */
3545819f75eSPeter Gill static int
3555819f75eSPeter Gill iscsi_tpgt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3565819f75eSPeter Gill {
3575819f75eSPeter Gill 	iscsi_dcmd_ctrl_t	idc;
3585819f75eSPeter Gill 	uintptr_t		iscsit_global_addr, avl_addr, list_addr;
3595819f75eSPeter Gill 	GElf_Sym		sym;
3605819f75eSPeter Gill 	int			rc_audit = 0, portal = 0;
3615819f75eSPeter Gill 
3625819f75eSPeter Gill 	bzero(&idc, sizeof (idc));
3635819f75eSPeter Gill 	if (mdb_getopts(argc, argv,
3645819f75eSPeter Gill 	    'p', MDB_OPT_SETBITS, TRUE, &portal,
3655819f75eSPeter Gill 	    'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
3665819f75eSPeter Gill 	    NULL) != argc)
3675819f75eSPeter Gill 		return (DCMD_USAGE);
3685819f75eSPeter Gill 
3695819f75eSPeter Gill 	idc.u.child.idc_tpgt = 1;
3705819f75eSPeter Gill 	idc.u.child.idc_portal = portal;
3715819f75eSPeter Gill 	idc.u.child.idc_rc_audit = rc_audit;
3725819f75eSPeter Gill 	if (DCMD_HDRSPEC(flags))
3735819f75eSPeter Gill 		idc.idc_header = 1;
3745819f75eSPeter Gill 
3755819f75eSPeter Gill 	/*
3765819f75eSPeter Gill 	 * If no address was specified on the command line,
3775819f75eSPeter Gill 	 * print out all tpgts
3785819f75eSPeter Gill 	 */
3795819f75eSPeter Gill 	if (!(flags & DCMD_ADDRSPEC)) {
3805819f75eSPeter Gill 		if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
3815819f75eSPeter Gill 			mdb_warn("failed to find symbol 'iscsit_global'");
3825819f75eSPeter Gill 			return (DCMD_ERR);
3835819f75eSPeter Gill 		}
3845819f75eSPeter Gill 		iscsit_global_addr = (uintptr_t)sym.st_value;
3855819f75eSPeter Gill 		avl_addr = iscsit_global_addr +
3865819f75eSPeter Gill 		    offsetof(iscsit_global_t, global_target_list);
3875819f75eSPeter Gill 		if (mdb_pwalk("avl", iscsi_tgt_walk_cb, &idc, avl_addr) == -1) {
3885819f75eSPeter Gill 			mdb_warn("avl walk failed for global target tree");
3895819f75eSPeter Gill 			return (DCMD_ERR);
3905819f75eSPeter Gill 		}
3915819f75eSPeter Gill 		list_addr = iscsit_global_addr +
3925819f75eSPeter Gill 		    offsetof(iscsit_global_t, global_deleted_target_list);
3935819f75eSPeter Gill 		if (mdb_pwalk("list", iscsi_tgt_walk_cb,
3945819f75eSPeter Gill 		    &idc, list_addr) == -1) {
3955819f75eSPeter Gill 			mdb_warn("list walk failed for deleted target list");
3965819f75eSPeter Gill 			return (DCMD_ERR);
3975819f75eSPeter Gill 		}
3985819f75eSPeter Gill 		return (DCMD_OK);
3995819f75eSPeter Gill 	}
4005819f75eSPeter Gill 	return (iscsi_tpgt_impl(addr, &idc));
4015819f75eSPeter Gill }
4025819f75eSPeter Gill 
4035819f75eSPeter Gill /*
4045819f75eSPeter Gill  * ::iscsi_sess [-ablmtvcSRIT]
405a6d42e7dSPeter Dunlap  *
406a6d42e7dSPeter Dunlap  * iscsi_sess - Print out information associated with an iSCSI session
407a6d42e7dSPeter Dunlap  *
408a6d42e7dSPeter Dunlap  * I	Print only initiator sessions
409a6d42e7dSPeter Dunlap  * T	Print only target sessions
410a6d42e7dSPeter Dunlap  * c	Print associated connection information
411a6d42e7dSPeter Dunlap  * a	Print IP addresses with connection information
412a6d42e7dSPeter Dunlap  * t	Print associated task information
4135819f75eSPeter Gill  * l	Print associated lun information (with -I)
4145819f75eSPeter Gill  * m	Print associated initiator command information (with -I)
415a6d42e7dSPeter Dunlap  * b	Print associated buffer information
416a6d42e7dSPeter Dunlap  * S	Print recent state events and transitions
417a6d42e7dSPeter Dunlap  * R	Print reference count audit data
418a6d42e7dSPeter Dunlap  * v	Verbose output about the connection
419a6d42e7dSPeter Dunlap  */
420a6d42e7dSPeter Dunlap /*ARGSUSED*/
421a6d42e7dSPeter Dunlap static int
422a6d42e7dSPeter Dunlap iscsi_sess(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
423a6d42e7dSPeter Dunlap {
424a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	idc;
425a6d42e7dSPeter Dunlap 	int			buffer = 0, task = 0, conn = 0, print_ip = 0;
4265819f75eSPeter Gill 	int			states = 0, rc_audit = 0, commands = 0;
4275819f75eSPeter Gill 	int			luns = 0;
428a6d42e7dSPeter Dunlap 
429a6d42e7dSPeter Dunlap 	bzero(&idc, sizeof (idc));
430a6d42e7dSPeter Dunlap 	if (mdb_getopts(argc, argv,
431a6d42e7dSPeter Dunlap 	    'I', MDB_OPT_SETBITS, TRUE, &idc.idc_ini,
432a6d42e7dSPeter Dunlap 	    'T', MDB_OPT_SETBITS, TRUE, &idc.idc_tgt,
433a6d42e7dSPeter Dunlap 	    'a', MDB_OPT_SETBITS, TRUE, &print_ip,
434a6d42e7dSPeter Dunlap 	    'c', MDB_OPT_SETBITS, TRUE, &conn,
435a6d42e7dSPeter Dunlap 	    't', MDB_OPT_SETBITS, TRUE, &task,
4365819f75eSPeter Gill 	    'l', MDB_OPT_SETBITS, TRUE, &luns,
4375819f75eSPeter Gill 	    'm', MDB_OPT_SETBITS, TRUE, &commands,
438a6d42e7dSPeter Dunlap 	    'b', MDB_OPT_SETBITS, TRUE, &buffer,
439a6d42e7dSPeter Dunlap 	    'S', MDB_OPT_SETBITS, TRUE, &states,
440a6d42e7dSPeter Dunlap 	    'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
441a6d42e7dSPeter Dunlap 	    'v', MDB_OPT_SETBITS, TRUE, &idc.idc_verbose,
442a6d42e7dSPeter Dunlap 	    NULL) != argc)
443a6d42e7dSPeter Dunlap 		return (DCMD_USAGE);
444a6d42e7dSPeter Dunlap 
445a6d42e7dSPeter Dunlap 	idc.u.child.idc_sess = 1;
446a6d42e7dSPeter Dunlap 	idc.u.child.idc_print_ip = print_ip;
447a6d42e7dSPeter Dunlap 	idc.u.child.idc_conn = conn;
448a6d42e7dSPeter Dunlap 	idc.u.child.idc_task = task;
4495819f75eSPeter Gill 	idc.u.child.idc_cmd = commands;
4505819f75eSPeter Gill 	idc.u.child.idc_lun = luns;
451a6d42e7dSPeter Dunlap 	idc.u.child.idc_buffer = buffer;
452a6d42e7dSPeter Dunlap 	idc.u.child.idc_states = states;
453a6d42e7dSPeter Dunlap 	idc.u.child.idc_rc_audit = rc_audit;
454a6d42e7dSPeter Dunlap 	if (DCMD_HDRSPEC(flags))
455a6d42e7dSPeter Dunlap 		idc.idc_header = 1;
456a6d42e7dSPeter Dunlap 
457a6d42e7dSPeter Dunlap 	/*
458a6d42e7dSPeter Dunlap 	 * If no address was specified on the command line, we
459a6d42e7dSPeter Dunlap 	 * print out all sessions
460a6d42e7dSPeter Dunlap 	 */
461a6d42e7dSPeter Dunlap 	if (!(flags & DCMD_ADDRSPEC)) {
462a6d42e7dSPeter Dunlap 		return (iscsi_walk_all_sess(&idc));
463a6d42e7dSPeter Dunlap 	}
4645819f75eSPeter Gill 	return (iscsi_sess_impl(addr, &idc));
465a6d42e7dSPeter Dunlap }
466a6d42e7dSPeter Dunlap 
467a6d42e7dSPeter Dunlap 
468a6d42e7dSPeter Dunlap 
469a6d42e7dSPeter Dunlap /*
4705819f75eSPeter Gill  * ::iscsi_conn [-abmtvSRIT]
471a6d42e7dSPeter Dunlap  *
472a6d42e7dSPeter Dunlap  * iscsi_conn - Print out information associated with an iSCSI connection
473a6d42e7dSPeter Dunlap  *
474a6d42e7dSPeter Dunlap  * I	Print only initiator connections
475a6d42e7dSPeter Dunlap  * T	Print only target connections
476a6d42e7dSPeter Dunlap  * a	Print IP addresses with connection information
477a6d42e7dSPeter Dunlap  * t	Print associated task information
478a6d42e7dSPeter Dunlap  * b	Print associated buffer information
4795819f75eSPeter Gill  * m	Print associated initiator commands (with -I)
480a6d42e7dSPeter Dunlap  * S	Print recent state events and transitions
481a6d42e7dSPeter Dunlap  * R	Print reference count audit data
482a6d42e7dSPeter Dunlap  * v	Verbose output about the connection
483a6d42e7dSPeter Dunlap  */
484a6d42e7dSPeter Dunlap /*ARGSUSED*/
485a6d42e7dSPeter Dunlap static int
486a6d42e7dSPeter Dunlap iscsi_conn(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
487a6d42e7dSPeter Dunlap {
488a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	idc;
489a6d42e7dSPeter Dunlap 	int			buffer = 0, task = 0, print_ip = 0;
4905819f75eSPeter Gill 	int			states = 0, rc_audit = 0, commands = 0;
491a6d42e7dSPeter Dunlap 
492a6d42e7dSPeter Dunlap 	bzero(&idc, sizeof (idc));
493a6d42e7dSPeter Dunlap 	if (mdb_getopts(argc, argv,
494a6d42e7dSPeter Dunlap 	    'I', MDB_OPT_SETBITS, TRUE, &idc.idc_ini,
495a6d42e7dSPeter Dunlap 	    'T', MDB_OPT_SETBITS, TRUE, &idc.idc_tgt,
496a6d42e7dSPeter Dunlap 	    'a', MDB_OPT_SETBITS, TRUE, &print_ip,
497a6d42e7dSPeter Dunlap 	    't', MDB_OPT_SETBITS, TRUE, &task,
498a6d42e7dSPeter Dunlap 	    'b', MDB_OPT_SETBITS, TRUE, &buffer,
4995819f75eSPeter Gill 	    'm', MDB_OPT_SETBITS, TRUE, &commands,
500a6d42e7dSPeter Dunlap 	    'S', MDB_OPT_SETBITS, TRUE, &states,
501a6d42e7dSPeter Dunlap 	    'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
502a6d42e7dSPeter Dunlap 	    'v', MDB_OPT_SETBITS, TRUE, &idc.idc_verbose,
503a6d42e7dSPeter Dunlap 	    NULL) != argc)
504a6d42e7dSPeter Dunlap 		return (DCMD_USAGE);
505a6d42e7dSPeter Dunlap 
506a6d42e7dSPeter Dunlap 	idc.u.child.idc_conn = 1;
507a6d42e7dSPeter Dunlap 	idc.u.child.idc_print_ip = print_ip;
508a6d42e7dSPeter Dunlap 	idc.u.child.idc_task = task;
509a6d42e7dSPeter Dunlap 	idc.u.child.idc_buffer = buffer;
5105819f75eSPeter Gill 	idc.u.child.idc_cmd = commands;
511a6d42e7dSPeter Dunlap 	idc.u.child.idc_states = states;
512a6d42e7dSPeter Dunlap 	idc.u.child.idc_rc_audit = rc_audit;
513a6d42e7dSPeter Dunlap 	if (DCMD_HDRSPEC(flags))
514a6d42e7dSPeter Dunlap 		idc.idc_header = 1;
515a6d42e7dSPeter Dunlap 
516a6d42e7dSPeter Dunlap 	/*
517a6d42e7dSPeter Dunlap 	 * If no address was specified on the command line, we
518a6d42e7dSPeter Dunlap 	 * print out all connections
519a6d42e7dSPeter Dunlap 	 */
520a6d42e7dSPeter Dunlap 	if (!(flags & DCMD_ADDRSPEC)) {
521a6d42e7dSPeter Dunlap 		return (iscsi_walk_all_conn(&idc));
5225819f75eSPeter Gill 	}
5235819f75eSPeter Gill 	return (iscsi_conn_impl(addr, &idc));
5245819f75eSPeter Gill }
5255819f75eSPeter Gill 
5265819f75eSPeter Gill 
5275819f75eSPeter Gill /*
5285819f75eSPeter Gill  * ::iscsi_svc [-vR]
5295819f75eSPeter Gill  *
5305819f75eSPeter Gill  * iscsi_svc - Print out information associated with an iSCSI svc
5315819f75eSPeter Gill  *
5325819f75eSPeter Gill  * R	Print reference count audit data
5335819f75eSPeter Gill  * v	Verbose output about the service
5345819f75eSPeter Gill  */
5355819f75eSPeter Gill static int
5365819f75eSPeter Gill iscsi_svc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
5375819f75eSPeter Gill {
5385819f75eSPeter Gill 	iscsi_dcmd_ctrl_t	idc;
5395819f75eSPeter Gill 	GElf_Sym		sym;
5405819f75eSPeter Gill 	uintptr_t		idm_addr;
5415819f75eSPeter Gill 	uintptr_t		svc_list_addr;
5425819f75eSPeter Gill 	int			rc_audit = 0;
5435819f75eSPeter Gill 
5445819f75eSPeter Gill 	bzero(&idc, sizeof (iscsi_dcmd_ctrl_t));
5455819f75eSPeter Gill 
5465819f75eSPeter Gill 	if (mdb_getopts(argc, argv,
5475819f75eSPeter Gill 	    'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
5485819f75eSPeter Gill 	    'v', MDB_OPT_SETBITS, TRUE, &idc.idc_verbose,
5495819f75eSPeter Gill 	    NULL) != argc)
5505819f75eSPeter Gill 		return (DCMD_USAGE);
5515819f75eSPeter Gill 
5525819f75eSPeter Gill 	idc.u.child.idc_svc = 1;
5535819f75eSPeter Gill 	idc.u.child.idc_rc_audit = rc_audit;
5545819f75eSPeter Gill 	if (DCMD_HDRSPEC(flags)) {
5555819f75eSPeter Gill 		idc.idc_header = 1;
5565819f75eSPeter Gill 	}
5575819f75eSPeter Gill 
5585819f75eSPeter Gill 	if (!(flags & DCMD_ADDRSPEC)) {
5595819f75eSPeter Gill 		if (mdb_lookup_by_name("idm", &sym) == -1) {
5605819f75eSPeter Gill 			mdb_warn("failed to find symbol 'idm'");
5615819f75eSPeter Gill 			return (DCMD_ERR);
5625819f75eSPeter Gill 		}
5635819f75eSPeter Gill 		idm_addr = (uintptr_t)sym.st_value;
5645819f75eSPeter Gill 		svc_list_addr = idm_addr + offsetof(idm_global_t,
5655819f75eSPeter Gill 		    idm_tgt_svc_list);
5665819f75eSPeter Gill 
5675819f75eSPeter Gill 		if (mdb_pwalk("list", iscsi_svc_walk_cb, &idc,
5685819f75eSPeter Gill 		    svc_list_addr) == -1) {
5695819f75eSPeter Gill 			mdb_warn("list walk failed for idm services");
5705819f75eSPeter Gill 			return (DCMD_ERR);
5715819f75eSPeter Gill 		}
5725819f75eSPeter Gill 		return (DCMD_OK);
5735819f75eSPeter Gill 	}
5745819f75eSPeter Gill 	return (iscsi_svc_impl(addr, &idc));
5755819f75eSPeter Gill }
5765819f75eSPeter Gill 
5775819f75eSPeter Gill /*
5785819f75eSPeter Gill  * ::iscsi_portal -R
5795819f75eSPeter Gill  *
5805819f75eSPeter Gill  * iscsi_portal - Print out information associated with an iSCSI portal
5815819f75eSPeter Gill  *
5825819f75eSPeter Gill  * R	Print reference count audit data
5835819f75eSPeter Gill  */
5845819f75eSPeter Gill static int
5855819f75eSPeter Gill iscsi_portal(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
5865819f75eSPeter Gill {
5875819f75eSPeter Gill 	iscsi_dcmd_ctrl_t	idc;
5885819f75eSPeter Gill 	GElf_Sym		sym;
5895819f75eSPeter Gill 	iscsit_global_t		iscsit_global;
5905819f75eSPeter Gill 	uintptr_t		iscsit_global_addr;
5915819f75eSPeter Gill 	uintptr_t		tpg_avl_addr;
5925819f75eSPeter Gill 	int			rc_audit = 0;
5935819f75eSPeter Gill 
5945819f75eSPeter Gill 	bzero(&idc, sizeof (iscsi_dcmd_ctrl_t));
5955819f75eSPeter Gill 
5965819f75eSPeter Gill 	if (mdb_getopts(argc, argv,
5975819f75eSPeter Gill 	    'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
5985819f75eSPeter Gill 	    NULL) != argc)
5995819f75eSPeter Gill 		return (DCMD_USAGE);
6005819f75eSPeter Gill 
6015819f75eSPeter Gill 	idc.u.child.idc_rc_audit = rc_audit;
6025819f75eSPeter Gill 	idc.u.child.idc_portal = 1;
6035819f75eSPeter Gill 	if (DCMD_HDRSPEC(flags)) {
6045819f75eSPeter Gill 		idc.idc_header = 1;
6055819f75eSPeter Gill 	}
6065819f75eSPeter Gill 
6075819f75eSPeter Gill 	if (!(flags & DCMD_ADDRSPEC)) {
6085819f75eSPeter Gill 		if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
6095819f75eSPeter Gill 			mdb_warn("failed to find symbol 'iscsit_global'");
6105819f75eSPeter Gill 			return (DCMD_ERR);
6115819f75eSPeter Gill 		}
6125819f75eSPeter Gill 
6135819f75eSPeter Gill 		iscsit_global_addr = (uintptr_t)sym.st_value;
6145819f75eSPeter Gill 
6155819f75eSPeter Gill 		/* get and print the global default tpg */
6165819f75eSPeter Gill 		if (mdb_vread(&iscsit_global, sizeof (iscsit_global_t),
6175819f75eSPeter Gill 		    iscsit_global_addr) != sizeof (iscsit_global_t)) {
6185819f75eSPeter Gill 			mdb_warn("failed to read iscsit_global_t");
6195819f75eSPeter Gill 			return (DCMD_ERR);
6205819f75eSPeter Gill 		}
6215819f75eSPeter Gill 		if (iscsi_tpg_impl((uintptr_t)iscsit_global.global_default_tpg,
6225819f75eSPeter Gill 		    &idc) != DCMD_OK) {
6235819f75eSPeter Gill 			return (DCMD_ERR);
6245819f75eSPeter Gill 		}
6255819f75eSPeter Gill 
6265819f75eSPeter Gill 		/* Walk the tpgs for the rest of the portals */
6275819f75eSPeter Gill 		tpg_avl_addr = iscsit_global_addr + offsetof(iscsit_global_t,
6285819f75eSPeter Gill 		    global_tpg_list);
6295819f75eSPeter Gill 		if (mdb_pwalk("avl", iscsi_tpg_walk_cb, &idc,
6305819f75eSPeter Gill 		    tpg_avl_addr) == -1) {
6315819f75eSPeter Gill 			mdb_warn("list walk failed for global tpg tree");
6325819f75eSPeter Gill 			return (DCMD_ERR);
6335819f75eSPeter Gill 		}
6345819f75eSPeter Gill 		return (DCMD_OK);
6355819f75eSPeter Gill 	}
6365819f75eSPeter Gill 	return (iscsi_portal_impl(addr, &idc));
6375819f75eSPeter Gill }
6385819f75eSPeter Gill 
6395819f75eSPeter Gill 
6405819f75eSPeter Gill /*
6415819f75eSPeter Gill  * ::iscsi_cmd -S
6425819f75eSPeter Gill  *
6435819f75eSPeter Gill  * iscsi_cmd - Print out information associated with an iSCSI cmd
6445819f75eSPeter Gill  *
6455819f75eSPeter Gill  * S	Print state audit data
6465819f75eSPeter Gill  */
6475819f75eSPeter Gill static int
6485819f75eSPeter Gill iscsi_cmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
6495819f75eSPeter Gill {
6505819f75eSPeter Gill 	iscsi_dcmd_ctrl_t	idc;
6515819f75eSPeter Gill 	iscsi_cmd_t		cmd;
6525819f75eSPeter Gill 	int			states = 0;
6535819f75eSPeter Gill 
6545819f75eSPeter Gill 	bzero(&idc, sizeof (iscsi_dcmd_ctrl_t));
6555819f75eSPeter Gill 
6565819f75eSPeter Gill 	if (mdb_getopts(argc, argv,
6575819f75eSPeter Gill 	    'S', MDB_OPT_SETBITS, TRUE, &states,
6585819f75eSPeter Gill 	    NULL) != argc)
6595819f75eSPeter Gill 		return (DCMD_USAGE);
6605819f75eSPeter Gill 
6615819f75eSPeter Gill 	idc.u.child.idc_states = states;
6625819f75eSPeter Gill 	idc.u.child.idc_cmd = 1;
6635819f75eSPeter Gill 	idc.idc_ini = 1;
6645819f75eSPeter Gill 	if (DCMD_HDRSPEC(flags)) {
6655819f75eSPeter Gill 		idc.idc_header = 1;
6665819f75eSPeter Gill 	}
6675819f75eSPeter Gill 
6685819f75eSPeter Gill 	if (!(flags & DCMD_ADDRSPEC)) {
6695819f75eSPeter Gill 		if (mdb_pwalk("iscsi_ini_hba", iscsi_ini_hba_walk_cb,
6705819f75eSPeter Gill 		    &idc, NULL) == -1) {
6715819f75eSPeter Gill 			mdb_warn("iscsi cmd hba list walk failed");
6725819f75eSPeter Gill 			return (DCMD_ERR);
6735819f75eSPeter Gill 		}
674a6d42e7dSPeter Dunlap 	} else {
6755819f75eSPeter Gill 		if (mdb_vread(&cmd, sizeof (iscsi_cmd_t), addr) !=
6765819f75eSPeter Gill 		    sizeof (iscsi_cmd_t)) {
6775819f75eSPeter Gill 			return (DCMD_ERR);
6785819f75eSPeter Gill 		}
6795819f75eSPeter Gill 		return (iscsi_print_ini_cmd(addr, &cmd, &idc));
6805819f75eSPeter Gill 	}
6815819f75eSPeter Gill 	return (DCMD_OK);
6825819f75eSPeter Gill }
6835819f75eSPeter Gill 
6845819f75eSPeter Gill 
6855819f75eSPeter Gill static int
686*b1da084bSToomas Soome iscsi_ini_hba_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
687*b1da084bSToomas Soome {
6885819f75eSPeter Gill 	iscsi_hba_t ih;
6895819f75eSPeter Gill 
6905819f75eSPeter Gill 	if (mdb_vread(&ih, sizeof (ih), addr) != sizeof (ih)) {
6915819f75eSPeter Gill 		mdb_warn("Invalid HBA\n");
6925819f75eSPeter Gill 		return (DCMD_ERR);
6935819f75eSPeter Gill 	}
6945819f75eSPeter Gill 
6955819f75eSPeter Gill 	if (idc->u.child.idc_hba) {
6965819f75eSPeter Gill 		mdb_printf("iscsi_hba %p sessions: \n", addr);
697a6d42e7dSPeter Dunlap 	}
6985819f75eSPeter Gill 
6995819f75eSPeter Gill 	if (mdb_pwalk("iscsi_ini_sess", iscsi_ini_sess_walk_cb, idc,
7005819f75eSPeter Gill 	    (uintptr_t)ih.hba_sess_list) == -1) {
7015819f75eSPeter Gill 		mdb_warn("iscsi_sess_t walk failed");
7025819f75eSPeter Gill 		return (DCMD_ERR);
7035819f75eSPeter Gill 	}
7045819f75eSPeter Gill 	return (DCMD_OK);
705a6d42e7dSPeter Dunlap }
706a6d42e7dSPeter Dunlap 
707a6d42e7dSPeter Dunlap /*
708a6d42e7dSPeter Dunlap  * ::iscsi_task [-bv]
709a6d42e7dSPeter Dunlap  *
710a6d42e7dSPeter Dunlap  * iscsi_task - Print out information associated with an iSCSI task
711a6d42e7dSPeter Dunlap  *
712a6d42e7dSPeter Dunlap  * b	Print associated buffer information
713a6d42e7dSPeter Dunlap  * S	Print recent state events and transitions
714a6d42e7dSPeter Dunlap  * R	Print reference count audit data
715a6d42e7dSPeter Dunlap  * v	Verbose output about the connection
716a6d42e7dSPeter Dunlap  */
717a6d42e7dSPeter Dunlap /*ARGSUSED*/
718a6d42e7dSPeter Dunlap static int
719a6d42e7dSPeter Dunlap iscsi_task(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
720a6d42e7dSPeter Dunlap {
721a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	idc;
722a6d42e7dSPeter Dunlap 	int			buffer = 0;
723a6d42e7dSPeter Dunlap 	int			states = 0, rc_audit = 0;
724a6d42e7dSPeter Dunlap 
725a6d42e7dSPeter Dunlap 	bzero(&idc, sizeof (idc));
726a6d42e7dSPeter Dunlap 	if (mdb_getopts(argc, argv,
727a6d42e7dSPeter Dunlap 	    'b', MDB_OPT_SETBITS, TRUE, &buffer,
728a6d42e7dSPeter Dunlap 	    'S', MDB_OPT_SETBITS, TRUE, &states,
729a6d42e7dSPeter Dunlap 	    'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
730a6d42e7dSPeter Dunlap 	    'v', MDB_OPT_SETBITS, TRUE, &idc.idc_verbose,
731a6d42e7dSPeter Dunlap 	    NULL) != argc)
732a6d42e7dSPeter Dunlap 		return (DCMD_USAGE);
733a6d42e7dSPeter Dunlap 
734a6d42e7dSPeter Dunlap 	idc.u.child.idc_conn = 0;
735a6d42e7dSPeter Dunlap 	idc.u.child.idc_task = 1;
736a6d42e7dSPeter Dunlap 	idc.u.child.idc_buffer = buffer;
737a6d42e7dSPeter Dunlap 	idc.u.child.idc_states = states;
738a6d42e7dSPeter Dunlap 	idc.u.child.idc_rc_audit = rc_audit;
739a6d42e7dSPeter Dunlap 	if (DCMD_HDRSPEC(flags))
740a6d42e7dSPeter Dunlap 		idc.idc_header = 1;
741a6d42e7dSPeter Dunlap 
742a6d42e7dSPeter Dunlap 	/*
743a6d42e7dSPeter Dunlap 	 * If no address was specified on the command line, we
744a6d42e7dSPeter Dunlap 	 * print out all connections
745a6d42e7dSPeter Dunlap 	 */
746a6d42e7dSPeter Dunlap 	if (!(flags & DCMD_ADDRSPEC)) {
747a6d42e7dSPeter Dunlap 		return (iscsi_walk_all_conn(&idc));
748a6d42e7dSPeter Dunlap 	}
7495819f75eSPeter Gill 	return (iscsi_task_impl(addr, &idc));
750a6d42e7dSPeter Dunlap }
751a6d42e7dSPeter Dunlap 
752a6d42e7dSPeter Dunlap /*
753a6d42e7dSPeter Dunlap  * ::iscsi_refcnt
754a6d42e7dSPeter Dunlap  *
755a6d42e7dSPeter Dunlap  * iscsi_refcnt - Dump an idm_refcnt_t structure
756a6d42e7dSPeter Dunlap  *
757a6d42e7dSPeter Dunlap  */
758a6d42e7dSPeter Dunlap /*ARGSUSED*/
759a6d42e7dSPeter Dunlap static int
760a6d42e7dSPeter Dunlap iscsi_refcnt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
761a6d42e7dSPeter Dunlap {
762a6d42e7dSPeter Dunlap 	if (!(flags & DCMD_ADDRSPEC)) {
763a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
764a6d42e7dSPeter Dunlap 	}
7655819f75eSPeter Gill 	return (iscsi_refcnt_impl(addr));
766a6d42e7dSPeter Dunlap }
767a6d42e7dSPeter Dunlap 
768a6d42e7dSPeter Dunlap /*
769a6d42e7dSPeter Dunlap  * ::iscsi_states
770a6d42e7dSPeter Dunlap  *
771a6d42e7dSPeter Dunlap  * iscsi_states - Dump events and state transitions recoreded in an
772a6d42e7dSPeter Dunlap  * idm_sm_audit_t structure
773a6d42e7dSPeter Dunlap  *
774a6d42e7dSPeter Dunlap  */
775a6d42e7dSPeter Dunlap /*ARGSUSED*/
776a6d42e7dSPeter Dunlap static int
777a6d42e7dSPeter Dunlap iscsi_states(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
778a6d42e7dSPeter Dunlap {
779a6d42e7dSPeter Dunlap 	if (!(flags & DCMD_ADDRSPEC)) {
780a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
781a6d42e7dSPeter Dunlap 	}
7825819f75eSPeter Gill 	return (iscsi_sm_audit_impl(addr));
783a6d42e7dSPeter Dunlap }
784a6d42e7dSPeter Dunlap 
78530e7468fSPeter Dunlap 
786a6d42e7dSPeter Dunlap static int
787a6d42e7dSPeter Dunlap iscsi_walk_all_sess(iscsi_dcmd_ctrl_t *idc)
788a6d42e7dSPeter Dunlap {
789a6d42e7dSPeter Dunlap 	uintptr_t	iscsit_global_addr;
790a6d42e7dSPeter Dunlap 	uintptr_t	avl_addr;
791a6d42e7dSPeter Dunlap 	uintptr_t	list_addr;
792a6d42e7dSPeter Dunlap 	GElf_Sym	sym;
7935819f75eSPeter Gill 
79430e7468fSPeter Dunlap 	/* Initiator sessions */
79530e7468fSPeter Dunlap 	if (idc->idc_ini) {
7965819f75eSPeter Gill 		/* Always print hba info on this path */
7975819f75eSPeter Gill 		idc->u.child.idc_hba = 1;
7985819f75eSPeter Gill 		if (mdb_pwalk("iscsi_ini_hba", iscsi_ini_hba_walk_cb,
7995819f75eSPeter Gill 		    idc, NULL) == -1) {
8005819f75eSPeter Gill 			mdb_warn("iscsi cmd hba list walk failed");
80130e7468fSPeter Dunlap 			return (DCMD_ERR);
80230e7468fSPeter Dunlap 		}
8035819f75eSPeter Gill 		return (DCMD_OK);
80430e7468fSPeter Dunlap 	}
8055819f75eSPeter Gill 
80630e7468fSPeter Dunlap 	/* Target sessions */
807a6d42e7dSPeter Dunlap 	/* Walk discovery sessions */
808a6d42e7dSPeter Dunlap 	if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
809a6d42e7dSPeter Dunlap 		mdb_warn("failed to find symbol 'iscsit_global'");
810a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
811a6d42e7dSPeter Dunlap 	}
812a6d42e7dSPeter Dunlap 	iscsit_global_addr = (uintptr_t)sym.st_value;
813a6d42e7dSPeter Dunlap 	avl_addr = iscsit_global_addr +
814a6d42e7dSPeter Dunlap 	    offsetof(iscsit_global_t, global_discovery_sessions);
815a6d42e7dSPeter Dunlap 	if (mdb_pwalk("avl", iscsi_sess_walk_cb, idc, avl_addr) == -1) {
816a6d42e7dSPeter Dunlap 		mdb_warn("avl walk failed for discovery sessions");
817a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
818a6d42e7dSPeter Dunlap 	}
819a6d42e7dSPeter Dunlap 
820a6d42e7dSPeter Dunlap 	/* Walk targets printing all session info */
821a6d42e7dSPeter Dunlap 	avl_addr = iscsit_global_addr +
822a6d42e7dSPeter Dunlap 	    offsetof(iscsit_global_t, global_target_list);
823a6d42e7dSPeter Dunlap 	if (mdb_pwalk("avl", iscsi_tgt_walk_cb, idc, avl_addr) == -1) {
824a6d42e7dSPeter Dunlap 		mdb_warn("avl walk failed for target/session tree");
825a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
826a6d42e7dSPeter Dunlap 	}
827a6d42e7dSPeter Dunlap 
828a6d42e7dSPeter Dunlap 	/* Walk deleting targets printing all session info */
829a6d42e7dSPeter Dunlap 	list_addr = iscsit_global_addr +
830a6d42e7dSPeter Dunlap 	    offsetof(iscsit_global_t, global_deleted_target_list);
831a6d42e7dSPeter Dunlap 	if (mdb_pwalk("list", iscsi_tgt_walk_cb, idc, list_addr) == -1) {
832a6d42e7dSPeter Dunlap 		mdb_warn("list walk failed for deleted target list");
833a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
834a6d42e7dSPeter Dunlap 	}
835a6d42e7dSPeter Dunlap 
836a6d42e7dSPeter Dunlap 	return (DCMD_OK);
837a6d42e7dSPeter Dunlap }
838a6d42e7dSPeter Dunlap 
839a6d42e7dSPeter Dunlap static int
840a6d42e7dSPeter Dunlap iscsi_walk_all_conn(iscsi_dcmd_ctrl_t *idc)
841a6d42e7dSPeter Dunlap {
842a6d42e7dSPeter Dunlap 	uintptr_t	idm_global_addr;
843a6d42e7dSPeter Dunlap 	uintptr_t	list_addr;
844a6d42e7dSPeter Dunlap 	GElf_Sym	sym;
845a6d42e7dSPeter Dunlap 
846a6d42e7dSPeter Dunlap 	/* Walk initiator connections */
847a6d42e7dSPeter Dunlap 	if (mdb_lookup_by_name("idm", &sym) == -1) {
848a6d42e7dSPeter Dunlap 		mdb_warn("failed to find symbol 'idm'");
849a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
850a6d42e7dSPeter Dunlap 	}
851a6d42e7dSPeter Dunlap 	idm_global_addr = (uintptr_t)sym.st_value;
852a6d42e7dSPeter Dunlap 	/* Walk connection list associated with the initiator */
853a6d42e7dSPeter Dunlap 	list_addr = idm_global_addr + offsetof(idm_global_t, idm_ini_conn_list);
854a6d42e7dSPeter Dunlap 	if (mdb_pwalk("list", iscsi_conn_walk_cb, idc, list_addr) == -1) {
855a6d42e7dSPeter Dunlap 		mdb_warn("list walk failed for initiator connections");
856a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
857a6d42e7dSPeter Dunlap 	}
858a6d42e7dSPeter Dunlap 
859a6d42e7dSPeter Dunlap 	/* Walk connection list associated with the target */
860a6d42e7dSPeter Dunlap 	list_addr = idm_global_addr + offsetof(idm_global_t, idm_tgt_conn_list);
861a6d42e7dSPeter Dunlap 	if (mdb_pwalk("list", iscsi_conn_walk_cb, idc, list_addr) == -1) {
862a6d42e7dSPeter Dunlap 		mdb_warn("list walk failed for target service instances");
863a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
864a6d42e7dSPeter Dunlap 	}
865a6d42e7dSPeter Dunlap 
866a6d42e7dSPeter Dunlap 	return (DCMD_OK);
867a6d42e7dSPeter Dunlap }
868a6d42e7dSPeter Dunlap 
869a6d42e7dSPeter Dunlap /*ARGSUSED*/
870a6d42e7dSPeter Dunlap static int
871a6d42e7dSPeter Dunlap iscsi_tpg_walk_cb(uintptr_t addr, const void *list_walker_data,
872a6d42e7dSPeter Dunlap     void *idc_void)
873a6d42e7dSPeter Dunlap {
874a6d42e7dSPeter Dunlap 	/* We don't particularly care about the list walker data */
875a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	*idc = idc_void;
876a6d42e7dSPeter Dunlap 	int			rc;
877a6d42e7dSPeter Dunlap 
878a6d42e7dSPeter Dunlap 	rc = iscsi_tpg_impl(addr, idc);
879a6d42e7dSPeter Dunlap 
880a6d42e7dSPeter Dunlap 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
881a6d42e7dSPeter Dunlap }
882a6d42e7dSPeter Dunlap 
883a6d42e7dSPeter Dunlap /*ARGSUSED*/
884a6d42e7dSPeter Dunlap static int
885a6d42e7dSPeter Dunlap iscsi_tgt_walk_cb(uintptr_t addr, const void *list_walker_data,
886a6d42e7dSPeter Dunlap     void *idc_void)
887a6d42e7dSPeter Dunlap {
888a6d42e7dSPeter Dunlap 	/* We don't particularly care about the list walker data */
889a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	*idc = idc_void;
890a6d42e7dSPeter Dunlap 	int			rc;
891a6d42e7dSPeter Dunlap 
892a6d42e7dSPeter Dunlap 	rc = iscsi_tgt_impl(addr, idc);
893a6d42e7dSPeter Dunlap 
894a6d42e7dSPeter Dunlap 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
895a6d42e7dSPeter Dunlap }
896a6d42e7dSPeter Dunlap 
897a6d42e7dSPeter Dunlap /*ARGSUSED*/
898a6d42e7dSPeter Dunlap static int
899a6d42e7dSPeter Dunlap iscsi_tpgt_walk_cb(uintptr_t addr, const void *list_walker_data,
900a6d42e7dSPeter Dunlap     void *idc_void)
901a6d42e7dSPeter Dunlap {
902a6d42e7dSPeter Dunlap 	/* We don't particularly care about the list walker data */
903a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	*idc = idc_void;
904a6d42e7dSPeter Dunlap 	int			rc;
905a6d42e7dSPeter Dunlap 
906a6d42e7dSPeter Dunlap 	rc = iscsi_tpgt_impl(addr, idc);
907a6d42e7dSPeter Dunlap 
908a6d42e7dSPeter Dunlap 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
909a6d42e7dSPeter Dunlap }
910a6d42e7dSPeter Dunlap 
911a6d42e7dSPeter Dunlap /*ARGSUSED*/
912a6d42e7dSPeter Dunlap static int
913a6d42e7dSPeter Dunlap iscsi_portal_walk_cb(uintptr_t addr, const void *list_walker_data,
914a6d42e7dSPeter Dunlap     void *idc_void)
915a6d42e7dSPeter Dunlap {
916a6d42e7dSPeter Dunlap 	/* We don't particularly care about the list walker data */
917a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	*idc = idc_void;
918a6d42e7dSPeter Dunlap 	int			rc;
919a6d42e7dSPeter Dunlap 
920a6d42e7dSPeter Dunlap 	rc = iscsi_portal_impl(addr, idc);
921a6d42e7dSPeter Dunlap 
922a6d42e7dSPeter Dunlap 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
923a6d42e7dSPeter Dunlap }
924a6d42e7dSPeter Dunlap 
925a6d42e7dSPeter Dunlap /*ARGSUSED*/
926a6d42e7dSPeter Dunlap static int
927a6d42e7dSPeter Dunlap iscsi_sess_walk_cb(uintptr_t addr, const void *list_walker_data,
928a6d42e7dSPeter Dunlap     void *idc_void)
929a6d42e7dSPeter Dunlap {
930a6d42e7dSPeter Dunlap 	/* We don't particularly care about the list walker data */
931a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	*idc = idc_void;
932a6d42e7dSPeter Dunlap 	int			rc;
933a6d42e7dSPeter Dunlap 
934a6d42e7dSPeter Dunlap 	rc = iscsi_sess_impl(addr, idc);
935a6d42e7dSPeter Dunlap 
936a6d42e7dSPeter Dunlap 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
937a6d42e7dSPeter Dunlap }
938a6d42e7dSPeter Dunlap 
939a6d42e7dSPeter Dunlap /*ARGSUSED*/
940a6d42e7dSPeter Dunlap static int
941a6d42e7dSPeter Dunlap iscsi_sess_conn_walk_cb(uintptr_t addr, const void *list_walker_data,
942a6d42e7dSPeter Dunlap     void *idc_void)
943a6d42e7dSPeter Dunlap {
944a6d42e7dSPeter Dunlap 	/* We don't particularly care about the list walker data */
945a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	*idc = idc_void;
946a6d42e7dSPeter Dunlap 	iscsit_conn_t		ict;
947a6d42e7dSPeter Dunlap 	int			rc;
948a6d42e7dSPeter Dunlap 
949a6d42e7dSPeter Dunlap 	/*
950a6d42e7dSPeter Dunlap 	 * This function is different from iscsi_conn_walk_cb because
951a6d42e7dSPeter Dunlap 	 * we get an iscsit_conn_t instead of an idm_conn_t
952a6d42e7dSPeter Dunlap 	 *
953a6d42e7dSPeter Dunlap 	 * Read iscsit_conn_t, use to get idm_conn_t pointer
954a6d42e7dSPeter Dunlap 	 */
955a6d42e7dSPeter Dunlap 	if (mdb_vread(&ict, sizeof (iscsit_conn_t), addr) !=
956a6d42e7dSPeter Dunlap 	    sizeof (iscsit_conn_t)) {
957a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
958a6d42e7dSPeter Dunlap 	}
959a6d42e7dSPeter Dunlap 	rc = iscsi_conn_impl((uintptr_t)ict.ict_ic, idc);
960a6d42e7dSPeter Dunlap 
961a6d42e7dSPeter Dunlap 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
962a6d42e7dSPeter Dunlap }
963a6d42e7dSPeter Dunlap 
964a6d42e7dSPeter Dunlap /*ARGSUSED*/
965a6d42e7dSPeter Dunlap static int
966a6d42e7dSPeter Dunlap iscsi_conn_walk_cb(uintptr_t addr, const void *list_walker_data,
967a6d42e7dSPeter Dunlap     void *idc_void)
968a6d42e7dSPeter Dunlap {
969a6d42e7dSPeter Dunlap 	/* We don't particularly care about the list walker data */
970a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	*idc = idc_void;
971a6d42e7dSPeter Dunlap 	int			rc;
972a6d42e7dSPeter Dunlap 
973a6d42e7dSPeter Dunlap 	rc = iscsi_conn_impl(addr, idc);
974a6d42e7dSPeter Dunlap 
975a6d42e7dSPeter Dunlap 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
976a6d42e7dSPeter Dunlap }
977a6d42e7dSPeter Dunlap 
978a6d42e7dSPeter Dunlap /*ARGSUSED*/
979a6d42e7dSPeter Dunlap static int
980a6d42e7dSPeter Dunlap iscsi_buffer_walk_cb(uintptr_t addr, const void *list_walker_data,
981a6d42e7dSPeter Dunlap     void *idc_void)
982a6d42e7dSPeter Dunlap {
983a6d42e7dSPeter Dunlap 	/* We don't particularly care about the list walker data */
984a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t	*idc = idc_void;
985a6d42e7dSPeter Dunlap 	int			rc;
986a6d42e7dSPeter Dunlap 
987a6d42e7dSPeter Dunlap 	rc = iscsi_buffer_impl(addr, idc);
988a6d42e7dSPeter Dunlap 
989a6d42e7dSPeter Dunlap 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
990a6d42e7dSPeter Dunlap }
991a6d42e7dSPeter Dunlap 
9925819f75eSPeter Gill /*ARGSUSED*/
9935819f75eSPeter Gill static int
9945819f75eSPeter Gill iscsi_svc_walk_cb(uintptr_t addr, const void *list_walker_data,
9955819f75eSPeter Gill     void *idc_void)
9965819f75eSPeter Gill {
9975819f75eSPeter Gill 	iscsi_dcmd_ctrl_t	*idc = idc_void;
9985819f75eSPeter Gill 	int			rc;
9995819f75eSPeter Gill 
10005819f75eSPeter Gill 	rc = iscsi_svc_impl(addr, idc);
10015819f75eSPeter Gill 
10025819f75eSPeter Gill 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
10035819f75eSPeter Gill }
10045819f75eSPeter Gill 
10055819f75eSPeter Gill /*ARGSUSED*/
10065819f75eSPeter Gill static int
1007*b1da084bSToomas Soome iscsi_ini_hba_walk_cb(uintptr_t addr, const void *vhba, void *idc_void)
1008*b1da084bSToomas Soome {
10095819f75eSPeter Gill 
10105819f75eSPeter Gill 	iscsi_dcmd_ctrl_t	*idc = idc_void;
10115819f75eSPeter Gill 	int			rc;
10125819f75eSPeter Gill 
10135819f75eSPeter Gill 	rc = iscsi_ini_hba_impl(addr, idc);
10145819f75eSPeter Gill 
10155819f75eSPeter Gill 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
10165819f75eSPeter Gill }
10175819f75eSPeter Gill 
10185819f75eSPeter Gill static int
10195819f75eSPeter Gill iscsi_ini_sess_walk_cb(uintptr_t addr, const void *vsess, void *idc_void)
10205819f75eSPeter Gill {
10215819f75eSPeter Gill 	int rc;
10225819f75eSPeter Gill 
10235819f75eSPeter Gill 	if (vsess == NULL) {
10245819f75eSPeter Gill 		return (WALK_ERR);
10255819f75eSPeter Gill 	}
10265819f75eSPeter Gill 
10275819f75eSPeter Gill 	rc = iscsi_print_ini_sess(addr, (iscsi_sess_t *)vsess,
10285819f75eSPeter Gill 	    (iscsi_dcmd_ctrl_t *)idc_void);
10295819f75eSPeter Gill 
10305819f75eSPeter Gill 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
10315819f75eSPeter Gill }
10325819f75eSPeter Gill 
10335819f75eSPeter Gill /*ARGSUSED*/
10345819f75eSPeter Gill static int
10355819f75eSPeter Gill iscsi_ini_conn_walk_cb(uintptr_t addr, const void *vconn, void *idc_void)
10365819f75eSPeter Gill {
10375819f75eSPeter Gill 	const iscsi_conn_t	*ict = vconn;
10385819f75eSPeter Gill 	int			rc;
10395819f75eSPeter Gill 
10405819f75eSPeter Gill 	if (vconn == NULL) {
10415819f75eSPeter Gill 		return (WALK_ERR);
10425819f75eSPeter Gill 	}
10435819f75eSPeter Gill 
10445819f75eSPeter Gill 	/*
10455819f75eSPeter Gill 	 * Look up the idm_conn_t in the iscsi_conn_t and call the general
10465819f75eSPeter Gill 	 * connection handler.
10475819f75eSPeter Gill 	 */
10485819f75eSPeter Gill 	rc = iscsi_conn_impl((uintptr_t)ict->conn_ic,
10495819f75eSPeter Gill 	    (iscsi_dcmd_ctrl_t *)idc_void);
10505819f75eSPeter Gill 
10515819f75eSPeter Gill 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
10525819f75eSPeter Gill }
10535819f75eSPeter Gill 
10545819f75eSPeter Gill static int
10555819f75eSPeter Gill iscsi_ini_lun_walk_cb(uintptr_t addr, const void *vlun, void *idc_void)
10565819f75eSPeter Gill {
10575819f75eSPeter Gill 	int			rc;
10585819f75eSPeter Gill 
10595819f75eSPeter Gill 	if (vlun == NULL) {
10605819f75eSPeter Gill 		return (WALK_ERR);
10615819f75eSPeter Gill 	}
10625819f75eSPeter Gill 
10635819f75eSPeter Gill 	rc = iscsi_print_ini_lun(addr, (iscsi_lun_t *)vlun,
10645819f75eSPeter Gill 	    (iscsi_dcmd_ctrl_t *)idc_void);
10655819f75eSPeter Gill 
10665819f75eSPeter Gill 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
10675819f75eSPeter Gill }
10685819f75eSPeter Gill 
10695819f75eSPeter Gill 
1070a6d42e7dSPeter Dunlap static int
1071a6d42e7dSPeter Dunlap iscsi_tgt_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1072a6d42e7dSPeter Dunlap {
1073a6d42e7dSPeter Dunlap 	iscsit_tgt_t	tgt;
1074a6d42e7dSPeter Dunlap 	uintptr_t	avl_addr, rc_addr, states_addr;
1075a6d42e7dSPeter Dunlap 	char		tgt_name[MAX_ISCSI_NODENAMELEN];
1076a6d42e7dSPeter Dunlap 	int		verbose, states, rc_audit;
1077a6d42e7dSPeter Dunlap 
1078a6d42e7dSPeter Dunlap 	/*
1079a6d42e7dSPeter Dunlap 	 * Read iscsit_tgt_t
1080a6d42e7dSPeter Dunlap 	 */
1081a6d42e7dSPeter Dunlap 	if (mdb_vread(&tgt, sizeof (iscsit_tgt_t), addr) !=
1082a6d42e7dSPeter Dunlap 	    sizeof (iscsit_tgt_t)) {
1083a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
1084a6d42e7dSPeter Dunlap 	}
1085a6d42e7dSPeter Dunlap 
1086a6d42e7dSPeter Dunlap 	/*
1087a6d42e7dSPeter Dunlap 	 * Read target name if available
1088a6d42e7dSPeter Dunlap 	 */
1089a6d42e7dSPeter Dunlap 	if ((tgt.target_name == NULL) ||
1090a6d42e7dSPeter Dunlap 	    (mdb_readstr(tgt_name, sizeof (tgt_name),
1091a6d42e7dSPeter Dunlap 	    (uintptr_t)tgt.target_name) == -1)) {
1092a6d42e7dSPeter Dunlap 		strcpy(tgt_name, "N/A");
1093a6d42e7dSPeter Dunlap 	}
1094a6d42e7dSPeter Dunlap 
1095a6d42e7dSPeter Dunlap 	/*
1096a6d42e7dSPeter Dunlap 	 * Brief output
1097a6d42e7dSPeter Dunlap 	 *
1098a6d42e7dSPeter Dunlap 	 * iscsit_tgt_t pointer
1099a6d42e7dSPeter Dunlap 	 * iscsit_tgt_t.target_stmf_state
1100a6d42e7dSPeter Dunlap 	 * iscsit_tgt_t.target_sess_list.avl_numnodes (session count)
1101a6d42e7dSPeter Dunlap 	 * iscsit_tgt_t.target_name;
1102a6d42e7dSPeter Dunlap 	 */
1103a6d42e7dSPeter Dunlap 
1104a6d42e7dSPeter Dunlap 	verbose = idc->idc_verbose;
1105a6d42e7dSPeter Dunlap 	states = idc->u.child.idc_states;
1106a6d42e7dSPeter Dunlap 	rc_audit = idc->u.child.idc_rc_audit;
1107a6d42e7dSPeter Dunlap 
1108a6d42e7dSPeter Dunlap 	/* For now we will ignore the verbose flag */
1109a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_tgt) {
1110a6d42e7dSPeter Dunlap 		/* Print target data */
1111a6d42e7dSPeter Dunlap 		if (idc->idc_header) {
1112a6d42e7dSPeter Dunlap 			mdb_printf("%<u>%-19s %-4s  %-8s%</u>\n",
1113a6d42e7dSPeter Dunlap 			    "iscsit_tgt_t", "Sess", "State");
1114a6d42e7dSPeter Dunlap 		}
1115a6d42e7dSPeter Dunlap 		mdb_printf("%-19p %-4d %-8d\n", addr,
1116a6d42e7dSPeter Dunlap 		    tgt.target_sess_list.avl_numnodes,
1117a6d42e7dSPeter Dunlap 		    tgt.target_state);
1118a6d42e7dSPeter Dunlap 		mdb_printf("  %s\n", tgt_name);
1119a6d42e7dSPeter Dunlap 
11205819f75eSPeter Gill 		/* Indent and disable verbose for any child structures */
11215819f75eSPeter Gill 		mdb_inc_indent(4);
11225819f75eSPeter Gill 		idc->idc_verbose = 0;
11235819f75eSPeter Gill 	}
1124a6d42e7dSPeter Dunlap 
1125a6d42e7dSPeter Dunlap 	/*
1126a6d42e7dSPeter Dunlap 	 * Print states if requested
1127a6d42e7dSPeter Dunlap 	 */
1128a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_tgt && states) {
1129a6d42e7dSPeter Dunlap 		states_addr = addr + offsetof(iscsit_tgt_t, target_state_audit);
1130a6d42e7dSPeter Dunlap 
11315819f75eSPeter Gill 		mdb_printf("State History(target_state_audit):\n");
1132a6d42e7dSPeter Dunlap 		if (iscsi_sm_audit_impl(states_addr) != DCMD_OK)
1133a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1134a6d42e7dSPeter Dunlap 		idc->u.child.idc_states = 0;
1135a6d42e7dSPeter Dunlap 	}
1136a6d42e7dSPeter Dunlap 
1137a6d42e7dSPeter Dunlap 	/*
1138a6d42e7dSPeter Dunlap 	 * Print refcnt audit data if requested
1139a6d42e7dSPeter Dunlap 	 */
1140a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_tgt && rc_audit) {
11415819f75eSPeter Gill 		mdb_printf("Reference History(target_sess_refcnt):\n");
1142a6d42e7dSPeter Dunlap 		rc_addr = addr +
1143a6d42e7dSPeter Dunlap 		    offsetof(iscsit_tgt_t, target_sess_refcnt);
1144a6d42e7dSPeter Dunlap 		if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
1145a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1146a6d42e7dSPeter Dunlap 
11475819f75eSPeter Gill 		mdb_printf("Reference History(target_refcnt):\n");
1148a6d42e7dSPeter Dunlap 		rc_addr = addr +
1149a6d42e7dSPeter Dunlap 		    offsetof(iscsit_tgt_t, target_refcnt);
1150a6d42e7dSPeter Dunlap 
1151a6d42e7dSPeter Dunlap 		if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
1152a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1153a6d42e7dSPeter Dunlap 		idc->u.child.idc_rc_audit = 0;
1154a6d42e7dSPeter Dunlap 	}
1155a6d42e7dSPeter Dunlap 
1156a6d42e7dSPeter Dunlap 	/* Any child objects to walk? */
11575819f75eSPeter Gill 	if (idc->u.child.idc_tpgt || idc->u.child.idc_portal) {
11585819f75eSPeter Gill 
11595819f75eSPeter Gill 		if (idc->u.child.idc_tgt) {
11605819f75eSPeter Gill 			idc->idc_header = 1;
11615819f75eSPeter Gill 		}
11625819f75eSPeter Gill 
1163a6d42e7dSPeter Dunlap 		/* Walk TPGT tree */
1164a6d42e7dSPeter Dunlap 		avl_addr = addr +
1165a6d42e7dSPeter Dunlap 		    offsetof(iscsit_tgt_t, target_tpgt_list);
1166a6d42e7dSPeter Dunlap 		if (mdb_pwalk("avl", iscsi_tpgt_walk_cb, idc,
1167a6d42e7dSPeter Dunlap 		    avl_addr) == -1) {
1168a6d42e7dSPeter Dunlap 			mdb_warn("target tpgt list walk failed");
1169a6d42e7dSPeter Dunlap 			(void) mdb_dec_indent(4);
1170a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1171a6d42e7dSPeter Dunlap 		}
11725819f75eSPeter Gill 	}
11735819f75eSPeter Gill 
11745819f75eSPeter Gill 	if (idc->u.child.idc_sess || idc->u.child.idc_conn ||
11755819f75eSPeter Gill 	    idc->u.child.idc_task || idc->u.child.idc_buffer) {
11765819f75eSPeter Gill 
11775819f75eSPeter Gill 		if (idc->u.child.idc_tgt || idc->u.child.idc_tpgt ||
11785819f75eSPeter Gill 		    idc->u.child.idc_portal) {
11795819f75eSPeter Gill 			idc->idc_header = 1;
11805819f75eSPeter Gill 		}
1181a6d42e7dSPeter Dunlap 
1182a6d42e7dSPeter Dunlap 		/* Walk sess tree */
1183a6d42e7dSPeter Dunlap 		avl_addr = addr + offsetof(iscsit_tgt_t, target_sess_list);
1184a6d42e7dSPeter Dunlap 		if (mdb_pwalk("avl", iscsi_sess_walk_cb, idc,
1185a6d42e7dSPeter Dunlap 		    avl_addr) == -1) {
1186a6d42e7dSPeter Dunlap 			mdb_warn("target sess list walk failed");
1187a6d42e7dSPeter Dunlap 			(void) mdb_dec_indent(4);
1188a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1189a6d42e7dSPeter Dunlap 		}
11905819f75eSPeter Gill 	}
1191a6d42e7dSPeter Dunlap 
11925819f75eSPeter Gill 	/* If tgts were handled decrease indent and reset header */
11935819f75eSPeter Gill 	if (idc->u.child.idc_tgt) {
1194a6d42e7dSPeter Dunlap 		idc->idc_header = 0;
11955819f75eSPeter Gill 		mdb_dec_indent(4);
1196a6d42e7dSPeter Dunlap 	}
1197a6d42e7dSPeter Dunlap 
1198a6d42e7dSPeter Dunlap 	idc->idc_verbose = verbose;
1199a6d42e7dSPeter Dunlap 	idc->u.child.idc_states = states;
1200a6d42e7dSPeter Dunlap 	idc->u.child.idc_rc_audit = rc_audit;
1201a6d42e7dSPeter Dunlap 	return (DCMD_OK);
1202a6d42e7dSPeter Dunlap }
1203a6d42e7dSPeter Dunlap 
1204a6d42e7dSPeter Dunlap static int
1205a6d42e7dSPeter Dunlap iscsi_tpgt_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1206a6d42e7dSPeter Dunlap {
1207a6d42e7dSPeter Dunlap 	iscsit_tpgt_t	tpgt;
1208a6d42e7dSPeter Dunlap 	iscsit_tpg_t	tpg;
12095819f75eSPeter Gill 	uintptr_t	avl_addr, tpg_addr, rc_addr;
12105819f75eSPeter Gill 	int		rc_audit;
1211a6d42e7dSPeter Dunlap 
1212a6d42e7dSPeter Dunlap 	/*
1213a6d42e7dSPeter Dunlap 	 * Read iscsit_tpgt_t
1214a6d42e7dSPeter Dunlap 	 */
1215a6d42e7dSPeter Dunlap 	if (mdb_vread(&tpgt, sizeof (iscsit_tpgt_t), addr) !=
1216a6d42e7dSPeter Dunlap 	    sizeof (iscsit_tpgt_t)) {
1217a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
1218a6d42e7dSPeter Dunlap 	}
1219a6d42e7dSPeter Dunlap 
1220a6d42e7dSPeter Dunlap 	tpg_addr = (uintptr_t)tpgt.tpgt_tpg;
1221a6d42e7dSPeter Dunlap 
1222a6d42e7dSPeter Dunlap 	/*
1223a6d42e7dSPeter Dunlap 	 * Read iscsit_tpg_t
1224a6d42e7dSPeter Dunlap 	 */
1225a6d42e7dSPeter Dunlap 	if (mdb_vread(&tpg, sizeof (iscsit_tpg_t), tpg_addr) !=
1226a6d42e7dSPeter Dunlap 	    sizeof (iscsit_tpg_t)) {
1227a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
1228a6d42e7dSPeter Dunlap 	}
1229a6d42e7dSPeter Dunlap 
12305819f75eSPeter Gill 	rc_audit = idc->u.child.idc_rc_audit;
12315819f75eSPeter Gill 
1232a6d42e7dSPeter Dunlap 	/*
1233a6d42e7dSPeter Dunlap 	 * Brief output
1234a6d42e7dSPeter Dunlap 	 *
1235a6d42e7dSPeter Dunlap 	 * iscsit_tpgt_t pointer
1236a6d42e7dSPeter Dunlap 	 * iscsit_tpg_t pointer
1237a6d42e7dSPeter Dunlap 	 * iscsit_tpg_t.tpg_name
1238a6d42e7dSPeter Dunlap 	 * iscsit_tpgt_t.tpgt_tag;
1239a6d42e7dSPeter Dunlap 	 */
1240a6d42e7dSPeter Dunlap 
1241a6d42e7dSPeter Dunlap 	/* For now we will ignore the verbose flag */
1242a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_tpgt) {
1243a6d42e7dSPeter Dunlap 		/* Print target data */
1244a6d42e7dSPeter Dunlap 		if (idc->idc_header) {
1245a6d42e7dSPeter Dunlap 			mdb_printf("%<u>%-?s %-?s %-18s %-6s%</u>\n",
1246a6d42e7dSPeter Dunlap 			    "iscsit_tpgt_t", "iscsit_tpg_t", "Name", "Tag");
1247a6d42e7dSPeter Dunlap 		}
1248a6d42e7dSPeter Dunlap 		mdb_printf("%?p %?p %-18s 0x%04x\n", addr, tpgt.tpgt_tpg,
1249a6d42e7dSPeter Dunlap 		    tpg.tpg_name, tpgt.tpgt_tag);
12505819f75eSPeter Gill 
12515819f75eSPeter Gill 		if (rc_audit) {
12525819f75eSPeter Gill 			(void) mdb_inc_indent(4);
12535819f75eSPeter Gill 
12545819f75eSPeter Gill 			mdb_printf("Reference History(tpgt_refcnt):\n");
12555819f75eSPeter Gill 			rc_addr = addr + offsetof(iscsit_tpgt_t, tpgt_refcnt);
12565819f75eSPeter Gill 			if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
12575819f75eSPeter Gill 				return (DCMD_ERR);
12585819f75eSPeter Gill 
12595819f75eSPeter Gill 			idc->u.child.idc_rc_audit = 0;
12605819f75eSPeter Gill 			(void) mdb_dec_indent(4);
12615819f75eSPeter Gill 		}
1262a6d42e7dSPeter Dunlap 	}
1263a6d42e7dSPeter Dunlap 
1264a6d42e7dSPeter Dunlap 	/*
1265a6d42e7dSPeter Dunlap 	 * Assume for now that anyone interested in TPGT wants to see the
12665819f75eSPeter Gill 	 * portals as well. Enable idc_header for the portals.
1267a6d42e7dSPeter Dunlap 	 */
1268a6d42e7dSPeter Dunlap 	idc->idc_header = 1;
1269a6d42e7dSPeter Dunlap 	(void) mdb_inc_indent(4);
1270a6d42e7dSPeter Dunlap 	avl_addr = tpg_addr + offsetof(iscsit_tpg_t, tpg_portal_list);
1271a6d42e7dSPeter Dunlap 	if (mdb_pwalk("avl", iscsi_portal_walk_cb, idc, avl_addr) == -1) {
1272a6d42e7dSPeter Dunlap 		mdb_warn("portal list walk failed");
1273a6d42e7dSPeter Dunlap 		(void) mdb_dec_indent(4);
1274a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
1275a6d42e7dSPeter Dunlap 	}
1276a6d42e7dSPeter Dunlap 	(void) mdb_dec_indent(4);
1277a6d42e7dSPeter Dunlap 	idc->idc_header = 0;
1278a6d42e7dSPeter Dunlap 
12795819f75eSPeter Gill 	idc->u.child.idc_rc_audit = rc_audit;
1280a6d42e7dSPeter Dunlap 	return (DCMD_OK);
1281a6d42e7dSPeter Dunlap }
1282a6d42e7dSPeter Dunlap 
1283a6d42e7dSPeter Dunlap static int
1284a6d42e7dSPeter Dunlap iscsi_tpg_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1285a6d42e7dSPeter Dunlap {
1286a6d42e7dSPeter Dunlap 	iscsit_tpg_t	tpg;
12875819f75eSPeter Gill 	uintptr_t	avl_addr, rc_addr;
12885819f75eSPeter Gill 	int		rc_audit = 0;
12895819f75eSPeter Gill 
12905819f75eSPeter Gill 	rc_audit = idc->u.child.idc_rc_audit;
1291a6d42e7dSPeter Dunlap 
1292a6d42e7dSPeter Dunlap 	/*
1293a6d42e7dSPeter Dunlap 	 * Read iscsit_tpg_t
1294a6d42e7dSPeter Dunlap 	 */
1295a6d42e7dSPeter Dunlap 	if (mdb_vread(&tpg, sizeof (iscsit_tpg_t), addr) !=
1296a6d42e7dSPeter Dunlap 	    sizeof (iscsit_tpg_t)) {
1297a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
1298a6d42e7dSPeter Dunlap 	}
1299a6d42e7dSPeter Dunlap 
1300a6d42e7dSPeter Dunlap 	/*
1301a6d42e7dSPeter Dunlap 	 * Brief output
1302a6d42e7dSPeter Dunlap 	 *
1303a6d42e7dSPeter Dunlap 	 * iscsit_tpgt_t pointer
1304a6d42e7dSPeter Dunlap 	 * iscsit_tpg_t pointer
1305a6d42e7dSPeter Dunlap 	 * iscsit_tpg_t.tpg_name
1306a6d42e7dSPeter Dunlap 	 * iscsit_tpgt_t.tpgt_tag;
1307a6d42e7dSPeter Dunlap 	 */
1308a6d42e7dSPeter Dunlap 
13095819f75eSPeter Gill 	/* Print tpg data */
13105819f75eSPeter Gill 	if (idc->u.child.idc_tpg) {
13115819f75eSPeter Gill 		if (idc->idc_header) {
13125819f75eSPeter Gill 			mdb_printf("%<u>%-?s %-18s%</u>\n",
13135819f75eSPeter Gill 			    "iscsit_tpg_t", "Name");
13145819f75eSPeter Gill 		}
13155819f75eSPeter Gill 		mdb_printf("%?p %-18s\n", addr, tpg.tpg_name);
1316a6d42e7dSPeter Dunlap 
13175819f75eSPeter Gill 		(void) mdb_inc_indent(4);
13185819f75eSPeter Gill 
13195819f75eSPeter Gill 		if (rc_audit) {
13205819f75eSPeter Gill 			mdb_printf("Reference History(tpg_refcnt):\n");
13215819f75eSPeter Gill 			rc_addr = addr + offsetof(iscsit_tpg_t, tpg_refcnt);
13225819f75eSPeter Gill 			if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
13235819f75eSPeter Gill 				return (DCMD_ERR);
13245819f75eSPeter Gill 			}
13255819f75eSPeter Gill 			idc->u.child.idc_rc_audit = 0;
13265819f75eSPeter Gill 		}
1327a6d42e7dSPeter Dunlap 	}
1328a6d42e7dSPeter Dunlap 
13295819f75eSPeter Gill 	if (idc->u.child.idc_portal) {
13305819f75eSPeter Gill 		if (idc->u.child.idc_tpg) {
13315819f75eSPeter Gill 			idc->idc_header = 1;
13325819f75eSPeter Gill 		}
13335819f75eSPeter Gill 
13345819f75eSPeter Gill 		avl_addr = addr + offsetof(iscsit_tpg_t, tpg_portal_list);
13355819f75eSPeter Gill 		if (mdb_pwalk("avl", iscsi_portal_walk_cb, idc,
13365819f75eSPeter Gill 		    avl_addr) == -1) {
13375819f75eSPeter Gill 			mdb_warn("portal list walk failed");
13385819f75eSPeter Gill 			if (idc->u.child.idc_tpg) {
13395819f75eSPeter Gill 				(void) mdb_dec_indent(4);
13405819f75eSPeter Gill 			}
13415819f75eSPeter Gill 			return (DCMD_ERR);
13425819f75eSPeter Gill 		}
13435819f75eSPeter Gill 	}
1344a6d42e7dSPeter Dunlap 
13455819f75eSPeter Gill 	if (idc->u.child.idc_tpg) {
1346a6d42e7dSPeter Dunlap 		(void) mdb_dec_indent(4);
13475819f75eSPeter Gill 		idc->idc_header = 0;
1348a6d42e7dSPeter Dunlap 	}
1349a6d42e7dSPeter Dunlap 
13505819f75eSPeter Gill 	idc->u.child.idc_rc_audit = rc_audit;
1351a6d42e7dSPeter Dunlap 	return (DCMD_OK);
1352a6d42e7dSPeter Dunlap }
1353a6d42e7dSPeter Dunlap 
1354a6d42e7dSPeter Dunlap static int
1355a6d42e7dSPeter Dunlap iscsi_portal_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1356a6d42e7dSPeter Dunlap {
1357a6d42e7dSPeter Dunlap 	iscsit_portal_t	portal;
1358a6d42e7dSPeter Dunlap 	char		portal_addr[PORTAL_STR_LEN];
13595819f75eSPeter Gill 	uintptr_t	rc_addr;
13605819f75eSPeter Gill 
1361a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_portal) {
1362a6d42e7dSPeter Dunlap 		/*
1363a6d42e7dSPeter Dunlap 		 * Read iscsit_portal_t
1364a6d42e7dSPeter Dunlap 		 */
1365a6d42e7dSPeter Dunlap 		if (mdb_vread(&portal, sizeof (iscsit_portal_t), addr) !=
1366a6d42e7dSPeter Dunlap 		    sizeof (iscsit_portal_t)) {
1367a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1368a6d42e7dSPeter Dunlap 		}
1369a6d42e7dSPeter Dunlap 
1370a6d42e7dSPeter Dunlap 		/* Print portal data */
1371a6d42e7dSPeter Dunlap 		if (idc->idc_header) {
1372a6d42e7dSPeter Dunlap 			mdb_printf("%<u>%-?s %-?s %-30s%</u>\n",
1373a6d42e7dSPeter Dunlap 			    "iscsit_portal_t", "idm_svc_t", "IP:Port");
13745819f75eSPeter Gill 			idc->idc_header = 0;
1375a6d42e7dSPeter Dunlap 		}
1376a6d42e7dSPeter Dunlap 		sa_to_str(&portal.portal_addr, portal_addr);
1377a6d42e7dSPeter Dunlap 		mdb_printf("%?p %?p %s\n", addr, portal.portal_svc,
13785819f75eSPeter Gill 		    portal.portal_default ? "(Default)" : portal_addr);
13795819f75eSPeter Gill 
13805819f75eSPeter Gill 		if (idc->u.child.idc_rc_audit) {
13815819f75eSPeter Gill 			(void) mdb_inc_indent(4);
13825819f75eSPeter Gill 			mdb_printf("Reference History(portal_refcnt):\n");
13835819f75eSPeter Gill 			rc_addr = addr + offsetof(iscsit_portal_t,
13845819f75eSPeter Gill 			    portal_refcnt);
13855819f75eSPeter Gill 			if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
13865819f75eSPeter Gill 				return (DCMD_ERR);
13875819f75eSPeter Gill 			}
13885819f75eSPeter Gill 			(void) mdb_dec_indent(4);
13895819f75eSPeter Gill 		}
1390a6d42e7dSPeter Dunlap 	}
1391a6d42e7dSPeter Dunlap 
1392a6d42e7dSPeter Dunlap 	return (DCMD_OK);
1393a6d42e7dSPeter Dunlap }
1394a6d42e7dSPeter Dunlap 
1395a6d42e7dSPeter Dunlap static int
1396a6d42e7dSPeter Dunlap iscsi_sess_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1397a6d42e7dSPeter Dunlap {
1398a6d42e7dSPeter Dunlap 	iscsit_sess_t	ist;
13995819f75eSPeter Gill 	iscsi_sess_t	ini_sess;
1400a6d42e7dSPeter Dunlap 	uintptr_t	list_addr, states_addr, rc_addr;
1401a6d42e7dSPeter Dunlap 	char		ini_name[80];
1402a6d42e7dSPeter Dunlap 	char		tgt_name[80];
1403a6d42e7dSPeter Dunlap 	int		verbose, states, rc_audit;
1404a6d42e7dSPeter Dunlap 
14055819f75eSPeter Gill 	if (idc->idc_ini) {
14065819f75eSPeter Gill 		if ((mdb_vread(&ini_sess, sizeof (iscsi_sess_t),
14075819f75eSPeter Gill 		    (uintptr_t)addr)) != sizeof (iscsi_sess_t)) {
14085819f75eSPeter Gill 			mdb_warn("Failed to read initiator session\n");
14095819f75eSPeter Gill 			return (DCMD_ERR);
14105819f75eSPeter Gill 		}
14115819f75eSPeter Gill 		if (iscsi_print_ini_sess(addr, &ini_sess, idc) != DCMD_OK) {
14125819f75eSPeter Gill 			return (DCMD_ERR);
14135819f75eSPeter Gill 		}
14145819f75eSPeter Gill 		return (DCMD_OK);
14155819f75eSPeter Gill 	}
1416a6d42e7dSPeter Dunlap 	/*
1417a6d42e7dSPeter Dunlap 	 * Read iscsit_sess_t
1418a6d42e7dSPeter Dunlap 	 */
1419a6d42e7dSPeter Dunlap 	if (mdb_vread(&ist, sizeof (iscsit_sess_t), addr) !=
1420a6d42e7dSPeter Dunlap 	    sizeof (iscsit_sess_t)) {
1421a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
1422a6d42e7dSPeter Dunlap 	}
1423a6d42e7dSPeter Dunlap 
1424a6d42e7dSPeter Dunlap 	/*
1425a6d42e7dSPeter Dunlap 	 * Brief output
1426a6d42e7dSPeter Dunlap 	 *
1427a6d42e7dSPeter Dunlap 	 * iscsit_sess_t pointer
1428a6d42e7dSPeter Dunlap 	 * iscsit_sess_t.ist_state/iscsit_sess_t.ist_ffp_conn_count
1429a6d42e7dSPeter Dunlap 	 * iscsit_sess_t.ist_tsih
1430a6d42e7dSPeter Dunlap 	 * iscsit_sess_t.ist_initiator_name
1431a6d42e7dSPeter Dunlap 	 */
1432a6d42e7dSPeter Dunlap 
1433a6d42e7dSPeter Dunlap 	verbose = idc->idc_verbose;
1434a6d42e7dSPeter Dunlap 	states = idc->u.child.idc_states;
1435a6d42e7dSPeter Dunlap 	rc_audit = idc->u.child.idc_rc_audit;
1436a6d42e7dSPeter Dunlap 
1437a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_sess) {
1438a6d42e7dSPeter Dunlap 		if (verbose) {
1439a6d42e7dSPeter Dunlap 			/*
1440a6d42e7dSPeter Dunlap 			 * Read initiator name if available
1441a6d42e7dSPeter Dunlap 			 */
1442a6d42e7dSPeter Dunlap 			if ((ist.ist_initiator_name == NULL) ||
1443a6d42e7dSPeter Dunlap 			    (mdb_readstr(ini_name, sizeof (ini_name),
1444a6d42e7dSPeter Dunlap 			    (uintptr_t)ist.ist_initiator_name) == -1)) {
1445a6d42e7dSPeter Dunlap 				strcpy(ini_name, "N/A");
1446a6d42e7dSPeter Dunlap 			}
1447a6d42e7dSPeter Dunlap 
1448a6d42e7dSPeter Dunlap 			/*
1449a6d42e7dSPeter Dunlap 			 * Read target name if available
1450a6d42e7dSPeter Dunlap 			 */
1451a6d42e7dSPeter Dunlap 			if ((ist.ist_target_name == NULL) ||
1452a6d42e7dSPeter Dunlap 			    (mdb_readstr(tgt_name, sizeof (tgt_name),
1453a6d42e7dSPeter Dunlap 			    (uintptr_t)ist.ist_target_name) == -1)) {
1454a6d42e7dSPeter Dunlap 				strcpy(tgt_name, "N/A");
1455a6d42e7dSPeter Dunlap 			}
1456a6d42e7dSPeter Dunlap 
1457a6d42e7dSPeter Dunlap 			mdb_printf("Session %p\n", addr);
1458a6d42e7dSPeter Dunlap 			mdb_printf("%16s: %d\n", "State",
1459a6d42e7dSPeter Dunlap 			    ist.ist_state);
1460a6d42e7dSPeter Dunlap 			mdb_printf("%16s: %d\n", "Last State",
1461a6d42e7dSPeter Dunlap 			    ist.ist_last_state);
1462a6d42e7dSPeter Dunlap 			mdb_printf("%16s: %d\n", "FFP Connections",
1463a6d42e7dSPeter Dunlap 			    ist.ist_ffp_conn_count);
1464a6d42e7dSPeter Dunlap 			mdb_printf("%16s: %02x%02x%02x%02x%02x%02x\n", "ISID",
1465a6d42e7dSPeter Dunlap 			    ist.ist_isid[0], ist.ist_isid[1], ist.ist_isid[2],
1466a6d42e7dSPeter Dunlap 			    ist.ist_isid[3], ist.ist_isid[4], ist.ist_isid[5]);
1467a6d42e7dSPeter Dunlap 			mdb_printf("%16s: 0x%04x\n", "TSIH",
1468a6d42e7dSPeter Dunlap 			    ist.ist_tsih);
1469a6d42e7dSPeter Dunlap 			mdb_printf("%16s: %s\n", "Initiator IQN",
1470a6d42e7dSPeter Dunlap 			    ini_name);
1471a6d42e7dSPeter Dunlap 			mdb_printf("%16s: %s\n", "Target IQN",
1472a6d42e7dSPeter Dunlap 			    tgt_name);
1473a6d42e7dSPeter Dunlap 			mdb_printf("%16s: %08x\n", "ExpCmdSN",
1474a6d42e7dSPeter Dunlap 			    ist.ist_expcmdsn);
1475a6d42e7dSPeter Dunlap 			mdb_printf("%16s: %08x\n", "MaxCmdSN",
1476a6d42e7dSPeter Dunlap 			    ist.ist_maxcmdsn);
14775819f75eSPeter Gill 
14785819f75eSPeter Gill 			idc->idc_verbose = 0;
1479a6d42e7dSPeter Dunlap 		} else {
1480a6d42e7dSPeter Dunlap 			/* Print session data */
1481a6d42e7dSPeter Dunlap 			if (idc->idc_header) {
1482a6d42e7dSPeter Dunlap 				mdb_printf("%<u>%-?s %10s %-12s %-6s%</u>\n",
1483a6d42e7dSPeter Dunlap 				    "iscsit_sess_t", "State/Conn", "ISID",
1484a6d42e7dSPeter Dunlap 				    "TSIH");
1485a6d42e7dSPeter Dunlap 			}
1486a6d42e7dSPeter Dunlap 			mdb_printf("%?p  %4d/%-4d %02x%02x%02x%02x%02x%02x "
1487a6d42e7dSPeter Dunlap 			    "0x%04x\n", addr,
1488a6d42e7dSPeter Dunlap 			    ist.ist_state, ist.ist_ffp_conn_count,
1489a6d42e7dSPeter Dunlap 			    ist.ist_isid[0], ist.ist_isid[1], ist.ist_isid[2],
1490a6d42e7dSPeter Dunlap 			    ist.ist_isid[3], ist.ist_isid[4], ist.ist_isid[5],
1491a6d42e7dSPeter Dunlap 			    ist.ist_tsih);
1492a6d42e7dSPeter Dunlap 		}
1493a6d42e7dSPeter Dunlap 
14945819f75eSPeter Gill 		/*
14955819f75eSPeter Gill 		 * Indent for any child structures
14965819f75eSPeter Gill 		 */
14975819f75eSPeter Gill 		(void) mdb_inc_indent(4);
14985819f75eSPeter Gill 	}
1499a6d42e7dSPeter Dunlap 
1500a6d42e7dSPeter Dunlap 	/*
1501a6d42e7dSPeter Dunlap 	 * Print states if requested
1502a6d42e7dSPeter Dunlap 	 */
15035819f75eSPeter Gill 	if (idc->u.child.idc_sess && states) {
1504a6d42e7dSPeter Dunlap 		states_addr = addr + offsetof(iscsit_sess_t, ist_state_audit);
1505a6d42e7dSPeter Dunlap 
15065819f75eSPeter Gill 		mdb_printf("State History(ist_state_audit):\n");
1507a6d42e7dSPeter Dunlap 		if (iscsi_sm_audit_impl(states_addr) != DCMD_OK)
1508a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1509a6d42e7dSPeter Dunlap 
1510a6d42e7dSPeter Dunlap 		/* Don't print state history for child objects */
1511a6d42e7dSPeter Dunlap 		idc->u.child.idc_states = 0;
1512a6d42e7dSPeter Dunlap 	}
1513a6d42e7dSPeter Dunlap 
1514a6d42e7dSPeter Dunlap 	/*
1515a6d42e7dSPeter Dunlap 	 * Print refcnt audit data if requested
1516a6d42e7dSPeter Dunlap 	 */
15175819f75eSPeter Gill 	if (idc->u.child.idc_sess && rc_audit) {
15185819f75eSPeter Gill 		mdb_printf("Reference History(ist_refcnt):\n");
1519a6d42e7dSPeter Dunlap 		rc_addr = addr +
1520a6d42e7dSPeter Dunlap 		    offsetof(iscsit_sess_t, ist_refcnt);
1521a6d42e7dSPeter Dunlap 		if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
1522a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1523a6d42e7dSPeter Dunlap 
1524a6d42e7dSPeter Dunlap 		/* Don't print audit data for child objects */
1525a6d42e7dSPeter Dunlap 		idc->u.child.idc_rc_audit = 0;
1526a6d42e7dSPeter Dunlap 	}
1527a6d42e7dSPeter Dunlap 
1528a6d42e7dSPeter Dunlap 	/* Any child objects to walk? */
1529a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_conn || idc->u.child.idc_task ||
1530a6d42e7dSPeter Dunlap 	    idc->u.child.idc_buffer) {
15315819f75eSPeter Gill 		/*
15325819f75eSPeter Gill 		 * If a session has been printed enable headers for
15335819f75eSPeter Gill 		 * any child structs.
15345819f75eSPeter Gill 		 */
15355819f75eSPeter Gill 		if (idc->u.child.idc_sess) {
15365819f75eSPeter Gill 			idc->idc_header = 1;
15375819f75eSPeter Gill 		}
15385819f75eSPeter Gill 
1539a6d42e7dSPeter Dunlap 		/* Walk conn list */
1540a6d42e7dSPeter Dunlap 		list_addr = addr + offsetof(iscsit_sess_t, ist_conn_list);
1541a6d42e7dSPeter Dunlap 		if (mdb_pwalk("list", iscsi_sess_conn_walk_cb, idc,
1542a6d42e7dSPeter Dunlap 		    list_addr) == -1) {
1543a6d42e7dSPeter Dunlap 			mdb_warn("session conn list walk failed");
1544a6d42e7dSPeter Dunlap 			(void) mdb_dec_indent(4);
1545a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1546a6d42e7dSPeter Dunlap 		}
15475819f75eSPeter Gill 	}
15485819f75eSPeter Gill 
15495819f75eSPeter Gill 	/* If a session was handled decrease indent and reset header. */
15505819f75eSPeter Gill 	if (idc->u.child.idc_sess) {
1551a6d42e7dSPeter Dunlap 		idc->idc_header = 0;
15525819f75eSPeter Gill 		mdb_dec_indent(4);
1553a6d42e7dSPeter Dunlap 	}
1554a6d42e7dSPeter Dunlap 
1555a6d42e7dSPeter Dunlap 	idc->idc_verbose = verbose;
1556a6d42e7dSPeter Dunlap 	idc->u.child.idc_states = states;
1557a6d42e7dSPeter Dunlap 	idc->u.child.idc_rc_audit = rc_audit;
1558a6d42e7dSPeter Dunlap 
1559a6d42e7dSPeter Dunlap 	return (DCMD_OK);
1560a6d42e7dSPeter Dunlap }
1561a6d42e7dSPeter Dunlap 
15625819f75eSPeter Gill static int
15635819f75eSPeter Gill iscsi_print_ini_sess(uintptr_t addr, iscsi_sess_t *sess,
15645819f75eSPeter Gill     iscsi_dcmd_ctrl_t *idc)
15655819f75eSPeter Gill {
15665819f75eSPeter Gill 
15675819f75eSPeter Gill 	int verbose, states;
15685819f75eSPeter Gill 	uintptr_t states_addr;
15695819f75eSPeter Gill 
15705819f75eSPeter Gill 	verbose = idc->idc_verbose;
15715819f75eSPeter Gill 	states = idc->u.child.idc_states;
15725819f75eSPeter Gill 
15735819f75eSPeter Gill 
15745819f75eSPeter Gill 	if (idc->u.child.idc_sess) {
15755819f75eSPeter Gill 		if (!idc->idc_verbose) {
15765819f75eSPeter Gill 			if (idc->idc_header) {
15775819f75eSPeter Gill 				mdb_printf("%<u>%-?s %-4s  %-8s%</u>\n",
15785819f75eSPeter Gill 				    "iscsi_sess_t", "Type", "State");
15795819f75eSPeter Gill 			}
15805819f75eSPeter Gill 			mdb_printf("%-19p %-4d %-8d\n", addr,
15815819f75eSPeter Gill 			    sess->sess_type, sess->sess_state);
15825819f75eSPeter Gill 		} else {
15835819f75eSPeter Gill 			mdb_printf("Session %p\n", addr);
15845819f75eSPeter Gill 			mdb_printf("%22s: %d\n", "State",
15855819f75eSPeter Gill 			    sess->sess_state);
15865819f75eSPeter Gill 			mdb_printf("%22s: %d\n", "Last State",
15875819f75eSPeter Gill 			    sess->sess_prev_state);
15885819f75eSPeter Gill 			mdb_printf("%22s: %s\n", "Session Name",
15895819f75eSPeter Gill 			    sess->sess_name);
15905819f75eSPeter Gill 			mdb_printf("%22s: %s\n", "Alias",
15915819f75eSPeter Gill 			    sess->sess_alias);
15925819f75eSPeter Gill 			mdb_printf("%22s: %08x\n", "CmdSN",
15935819f75eSPeter Gill 			    sess->sess_cmdsn);
15945819f75eSPeter Gill 			mdb_printf("%22s: %08x\n", "ExpCmdSN",
15955819f75eSPeter Gill 			    sess->sess_expcmdsn);
15965819f75eSPeter Gill 			mdb_printf("%22s: %08x\n", "MaxCmdSN",
15975819f75eSPeter Gill 			    sess->sess_maxcmdsn);
15985819f75eSPeter Gill 			mdb_printf("%22s: %p\n", "Pending Queue Head",
15995819f75eSPeter Gill 			    sess->sess_queue_pending.head);
16005819f75eSPeter Gill 			mdb_printf("%22s: %p\n", "Completion Queue Head",
16015819f75eSPeter Gill 			    sess->sess_queue_completion.head);
16025819f75eSPeter Gill 			mdb_printf("%22s: %p\n", "Connnection List Head",
16035819f75eSPeter Gill 			    sess->sess_conn_list);
16045819f75eSPeter Gill 
16055819f75eSPeter Gill 			idc->idc_verbose = 0;
16065819f75eSPeter Gill 		}
16075819f75eSPeter Gill 
16085819f75eSPeter Gill 		/* Indent for any child structures */
16095819f75eSPeter Gill 		mdb_inc_indent(4);
16105819f75eSPeter Gill 
16115819f75eSPeter Gill 		if (idc->u.child.idc_states) {
16125819f75eSPeter Gill 			states_addr = (uintptr_t)addr +
16135819f75eSPeter Gill 			    offsetof(iscsi_sess_t, sess_state_audit);
16145819f75eSPeter Gill 
16155819f75eSPeter Gill 			mdb_printf("State History(sess_state_audit):\n");
16165819f75eSPeter Gill 			if (iscsi_sm_audit_impl(states_addr) != DCMD_OK) {
16175819f75eSPeter Gill 				(void) mdb_dec_indent(4);
16185819f75eSPeter Gill 				return (DCMD_ERR);
16195819f75eSPeter Gill 			}
16205819f75eSPeter Gill 			idc->u.child.idc_states = 0;
16215819f75eSPeter Gill 		}
16225819f75eSPeter Gill 	}
16235819f75eSPeter Gill 
16245819f75eSPeter Gill 	if (idc->u.child.idc_lun && sess->sess_lun_list) {
16255819f75eSPeter Gill 		if (idc->u.child.idc_sess) {
16265819f75eSPeter Gill 			idc->idc_header = 1;
16275819f75eSPeter Gill 		}
16285819f75eSPeter Gill 
16295819f75eSPeter Gill 		if (mdb_pwalk("iscsi_ini_lun", iscsi_ini_lun_walk_cb, idc,
16305819f75eSPeter Gill 		    (uintptr_t)sess->sess_lun_list) == -1) {
16315819f75eSPeter Gill 			mdb_warn("iscsi_ini_lun walk failed");
16325819f75eSPeter Gill 			(void) mdb_dec_indent(4);
16335819f75eSPeter Gill 			return (DCMD_ERR);
16345819f75eSPeter Gill 		}
16355819f75eSPeter Gill 	}
16365819f75eSPeter Gill 
16375819f75eSPeter Gill 
16385819f75eSPeter Gill 	/* If requested print the cmds in the session queue */
16395819f75eSPeter Gill 	if (idc->u.child.idc_cmd) {
16405819f75eSPeter Gill 
16415819f75eSPeter Gill 		/* If any other structs printed enable header */
16425819f75eSPeter Gill 		if (idc->u.child.idc_sess || idc->u.child.idc_lun) {
16435819f75eSPeter Gill 			idc->idc_header = 1;
16445819f75eSPeter Gill 		}
16455819f75eSPeter Gill 
16465819f75eSPeter Gill 		if (sess->sess_queue_pending.head) {
16475819f75eSPeter Gill 			if (mdb_pwalk("iscsi_ini_cmd", iscsi_ini_cmd_walk_cb,
16485819f75eSPeter Gill 			    idc, (uintptr_t)sess->sess_queue_pending.head)
16495819f75eSPeter Gill 			    == -1) {
16505819f75eSPeter Gill 				mdb_warn("list walk failed for iscsi cmds");
16515819f75eSPeter Gill 			}
16525819f75eSPeter Gill 		}
16535819f75eSPeter Gill 		if (sess->sess_queue_completion.head) {
16545819f75eSPeter Gill 			if (mdb_pwalk("iscsi_ini_cmd", iscsi_ini_cmd_walk_cb,
16555819f75eSPeter Gill 			    idc, (uintptr_t)sess->sess_queue_completion.head)
16565819f75eSPeter Gill 			    == -1) {
16575819f75eSPeter Gill 				mdb_warn("list walk failed for iscsi cmds");
16585819f75eSPeter Gill 			}
16595819f75eSPeter Gill 		}
16605819f75eSPeter Gill 	}
16615819f75eSPeter Gill 
16625819f75eSPeter Gill 	/* If connections or cmds requested walk the connections */
16635819f75eSPeter Gill 	if (idc->u.child.idc_conn || idc->u.child.idc_cmd) {
16645819f75eSPeter Gill 		/*
16655819f75eSPeter Gill 		 * If idc_conn is not set don't enable header or the
16665819f75eSPeter Gill 		 * commands may get extraneous headers.
16675819f75eSPeter Gill 		 */
16685819f75eSPeter Gill 		if (idc->u.child.idc_conn) {
16695819f75eSPeter Gill 			idc->idc_header = 1;
16705819f75eSPeter Gill 		}
16715819f75eSPeter Gill 		if (mdb_pwalk("iscsi_ini_conn", iscsi_ini_conn_walk_cb, idc,
16725819f75eSPeter Gill 		    (uintptr_t)sess->sess_conn_list) == -1) {
16735819f75eSPeter Gill 			mdb_warn("iscsi_ini_conn walk failed");
16745819f75eSPeter Gill 			return (DCMD_ERR);
16755819f75eSPeter Gill 		}
16765819f75eSPeter Gill 	}
16775819f75eSPeter Gill 
16785819f75eSPeter Gill 	/* If sessions were handled decrease indent and reset header */
16795819f75eSPeter Gill 	if (idc->u.child.idc_sess) {
16805819f75eSPeter Gill 		idc->idc_header = 0;
16815819f75eSPeter Gill 		mdb_dec_indent(4);
16825819f75eSPeter Gill 	}
16835819f75eSPeter Gill 
16845819f75eSPeter Gill 	idc->u.child.idc_states = states;
16855819f75eSPeter Gill 	idc->idc_verbose = verbose;
16865819f75eSPeter Gill 	return (DCMD_OK);
16875819f75eSPeter Gill }
16885819f75eSPeter Gill 
16895819f75eSPeter Gill 
1690a6d42e7dSPeter Dunlap static int
1691a6d42e7dSPeter Dunlap iscsi_conn_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1692a6d42e7dSPeter Dunlap {
1693a6d42e7dSPeter Dunlap 	uintptr_t	idm_global_addr, states_addr, rc_addr;
1694a6d42e7dSPeter Dunlap 	uintptr_t	task_addr, task_ptr;
1695a6d42e7dSPeter Dunlap 	GElf_Sym	sym;
1696a6d42e7dSPeter Dunlap 	idm_task_t	idt;
1697a6d42e7dSPeter Dunlap 	idm_conn_t	ic;
16985819f75eSPeter Gill 	iscsit_conn_t	ict;
16995819f75eSPeter Gill 	iscsi_conn_t	ini_conn;
1700a6d42e7dSPeter Dunlap 	char		*conn_type;
1701a6d42e7dSPeter Dunlap 	int		task_idx;
1702a6d42e7dSPeter Dunlap 	char		laddr[PORTAL_STR_LEN];
1703a6d42e7dSPeter Dunlap 	char		raddr[PORTAL_STR_LEN];
1704a6d42e7dSPeter Dunlap 	int		verbose, states, rc_audit;
1705a6d42e7dSPeter Dunlap 
1706a6d42e7dSPeter Dunlap 	/*
1707a6d42e7dSPeter Dunlap 	 * Get pointer to task table
1708a6d42e7dSPeter Dunlap 	 */
1709a6d42e7dSPeter Dunlap 
1710a6d42e7dSPeter Dunlap 	if (mdb_lookup_by_name("idm", &sym) == -1) {
1711a6d42e7dSPeter Dunlap 		mdb_warn("failed to find symbol 'idm'");
1712a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
1713a6d42e7dSPeter Dunlap 	}
1714a6d42e7dSPeter Dunlap 
1715a6d42e7dSPeter Dunlap 	idm_global_addr = (uintptr_t)sym.st_value;
1716a6d42e7dSPeter Dunlap 
1717a6d42e7dSPeter Dunlap 	if (mdb_vread(&task_ptr, sizeof (uintptr_t),
1718a6d42e7dSPeter Dunlap 	    idm_global_addr + offsetof(idm_global_t, idm_taskid_table)) !=
1719a6d42e7dSPeter Dunlap 	    sizeof (uintptr_t)) {
1720a6d42e7dSPeter Dunlap 		mdb_warn("Failed to read address of task table");
1721a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
1722a6d42e7dSPeter Dunlap 	}
1723a6d42e7dSPeter Dunlap 
1724a6d42e7dSPeter Dunlap 	/*
1725a6d42e7dSPeter Dunlap 	 * Read idm_conn_t
1726a6d42e7dSPeter Dunlap 	 */
1727a6d42e7dSPeter Dunlap 	if (mdb_vread(&ic, sizeof (idm_conn_t), addr) != sizeof (idm_conn_t)) {
1728a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
1729a6d42e7dSPeter Dunlap 	}
17305819f75eSPeter Gill 
17315819f75eSPeter Gill 	/*
17325819f75eSPeter Gill 	 * If filter bits are set to only print targets or only initiators
17335819f75eSPeter Gill 	 * skip entries of the other type.
17345819f75eSPeter Gill 	 */
17355819f75eSPeter Gill 	if (!(idc->idc_ini && idc->idc_tgt) &&
17365819f75eSPeter Gill 	    ((idc->idc_ini && (ic.ic_conn_type != CONN_TYPE_INI)) ||
17375819f75eSPeter Gill 	    (idc->idc_tgt && (ic.ic_conn_type != CONN_TYPE_TGT)))) {
17385819f75eSPeter Gill 		return (DCMD_OK);
17395819f75eSPeter Gill 	}
17405819f75eSPeter Gill 
17415819f75eSPeter Gill 
1742a6d42e7dSPeter Dunlap 	conn_type = (ic.ic_conn_type == CONN_TYPE_INI) ? "Ini" :
1743a6d42e7dSPeter Dunlap 	    (ic.ic_conn_type == CONN_TYPE_TGT) ? "Tgt" : "Unk";
1744a6d42e7dSPeter Dunlap 
1745a6d42e7dSPeter Dunlap 	/*
1746a6d42e7dSPeter Dunlap 	 * Brief output
1747a6d42e7dSPeter Dunlap 	 *
1748a6d42e7dSPeter Dunlap 	 * idm_conn_t pointer
1749a6d42e7dSPeter Dunlap 	 * idm_conn_t.ic_conn_type
1750a6d42e7dSPeter Dunlap 	 * idm_conn_t.ic_statet+idm_conn_t.ic_ffp
1751a6d42e7dSPeter Dunlap 	 */
1752a6d42e7dSPeter Dunlap 
1753a6d42e7dSPeter Dunlap 	verbose = idc->idc_verbose;
1754a6d42e7dSPeter Dunlap 	states = idc->u.child.idc_states;
1755a6d42e7dSPeter Dunlap 	rc_audit = idc->u.child.idc_rc_audit;
1756a6d42e7dSPeter Dunlap 
17575819f75eSPeter Gill 	/*
17585819f75eSPeter Gill 	 * If targets(-T) and/or initiators (-I) are specifically requested,
17595819f75eSPeter Gill 	 * fetch the iscsit_conn_t and/or iscsi_conn_t struct as a sanity
17605819f75eSPeter Gill 	 * check and for use below.
17615819f75eSPeter Gill 	 */
17625819f75eSPeter Gill 	if (idc->idc_tgt && IDM_CONN_ISTGT(&ic)) {
17635819f75eSPeter Gill 		if (mdb_vread(&ict, sizeof (iscsit_conn_t),
17645819f75eSPeter Gill 		    (uintptr_t)ic.ic_handle) !=
17655819f75eSPeter Gill 		    sizeof (iscsit_conn_t)) {
17665819f75eSPeter Gill 			mdb_printf("Failed to read target connection "
17675819f75eSPeter Gill 			    "handle data\n");
17685819f75eSPeter Gill 			return (DCMD_ERR);
17695819f75eSPeter Gill 		}
17705819f75eSPeter Gill 	}
17715819f75eSPeter Gill 
17725819f75eSPeter Gill 	if (idc->idc_ini && IDM_CONN_ISINI(&ic)) {
17735819f75eSPeter Gill 		if (mdb_vread(&ini_conn, sizeof (iscsi_conn_t),
17745819f75eSPeter Gill 		    (uintptr_t)ic.ic_handle) !=
17755819f75eSPeter Gill 		    sizeof (iscsi_conn_t)) {
17765819f75eSPeter Gill 			mdb_printf("Failed to read initiator "
17775819f75eSPeter Gill 			    "connection handle data\n");
17785819f75eSPeter Gill 			return (DCMD_ERR);
17795819f75eSPeter Gill 		}
17805819f75eSPeter Gill 	}
17815819f75eSPeter Gill 
1782a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_conn) {
1783a6d42e7dSPeter Dunlap 		if (idc->idc_verbose) {
1784a6d42e7dSPeter Dunlap 			mdb_printf("IDM Conn %p\n", addr);
1785a6d42e7dSPeter Dunlap 			if (ic.ic_conn_type == CONN_TYPE_TGT) {
1786a6d42e7dSPeter Dunlap 				iscsi_print_iscsit_conn_data(&ic);
1787a6d42e7dSPeter Dunlap 			} else {
17885819f75eSPeter Gill 				iscsi_print_ini_conn_data(&ic);
1789a6d42e7dSPeter Dunlap 			}
17905819f75eSPeter Gill 			idc->idc_verbose = 0;
1791a6d42e7dSPeter Dunlap 		} else {
1792a6d42e7dSPeter Dunlap 			/* Print connection data */
1793a6d42e7dSPeter Dunlap 			if (idc->idc_header) {
1794a6d42e7dSPeter Dunlap 				mdb_printf("%<u>%-?s %-6s %-10s %12s%</u>\n",
1795a6d42e7dSPeter Dunlap 				    "idm_conn_t", "Type", "Transport",
1796a6d42e7dSPeter Dunlap 				    "State/FFP");
1797a6d42e7dSPeter Dunlap 			}
1798a6d42e7dSPeter Dunlap 			mdb_printf("%?p %-6s %-10s %6d/%-6d\n", addr, conn_type,
1799a6d42e7dSPeter Dunlap 			    (ic.ic_transport_type ==
1800a6d42e7dSPeter Dunlap 			    IDM_TRANSPORT_TYPE_ISER) ? "ISER_IB" :
1801a6d42e7dSPeter Dunlap 			    (ic.ic_transport_type ==
1802a6d42e7dSPeter Dunlap 			    IDM_TRANSPORT_TYPE_SOCKETS) ? "SOCKETS" :
1803a6d42e7dSPeter Dunlap 			    "N/A",
1804a6d42e7dSPeter Dunlap 			    ic.ic_state, ic.ic_ffp);
1805a6d42e7dSPeter Dunlap 			if (idc->u.child.idc_print_ip) {
1806a6d42e7dSPeter Dunlap 				sa_to_str(&ic.ic_laddr, laddr);
1807a6d42e7dSPeter Dunlap 				sa_to_str(&ic.ic_raddr, raddr);
1808a6d42e7dSPeter Dunlap 				mdb_printf("  L%s  R%s\n",
1809a6d42e7dSPeter Dunlap 				    laddr, raddr);
1810a6d42e7dSPeter Dunlap 			}
1811a6d42e7dSPeter Dunlap 		}
1812a6d42e7dSPeter Dunlap 
18135819f75eSPeter Gill 		/* Indent for any child structs */
18145819f75eSPeter Gill 		mdb_inc_indent(4);
18155819f75eSPeter Gill 	}
1816a6d42e7dSPeter Dunlap 
1817a6d42e7dSPeter Dunlap 	/*
1818a6d42e7dSPeter Dunlap 	 * Print states if requested
1819a6d42e7dSPeter Dunlap 	 */
18205819f75eSPeter Gill 	if (idc->u.child.idc_conn && states) {
1821a6d42e7dSPeter Dunlap 		states_addr = addr + offsetof(idm_conn_t, ic_state_audit);
1822a6d42e7dSPeter Dunlap 
18235819f75eSPeter Gill 		mdb_printf("State History(ic_state_audit):\n");
1824a6d42e7dSPeter Dunlap 		if (iscsi_sm_audit_impl(states_addr) != DCMD_OK)
1825a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1826a6d42e7dSPeter Dunlap 
18275819f75eSPeter Gill 		/*
18285819f75eSPeter Gill 		 * If targets are specifically requested show the
18295819f75eSPeter Gill 		 * state audit for the target specific connection struct
18305819f75eSPeter Gill 		 */
18315819f75eSPeter Gill 		if (idc->idc_tgt && IDM_CONN_ISTGT(&ic)) {
18325819f75eSPeter Gill 			states_addr = (uintptr_t)ic.ic_handle +
18335819f75eSPeter Gill 			    offsetof(iscsit_conn_t, ict_login_sm) +
18345819f75eSPeter Gill 			    offsetof(iscsit_conn_login_t, icl_state_audit);
18355819f75eSPeter Gill 
18365819f75eSPeter Gill 			mdb_printf("State History(icl_state_audit):\n");
18375819f75eSPeter Gill 			if (iscsi_sm_audit_impl(states_addr) != DCMD_OK) {
18385819f75eSPeter Gill 				return (DCMD_ERR);
18395819f75eSPeter Gill 			}
18405819f75eSPeter Gill 		}
18415819f75eSPeter Gill 
18425819f75eSPeter Gill 		/*
18435819f75eSPeter Gill 		 * If initiators are specifically requested show the
18445819f75eSPeter Gill 		 * state audit for the initiator specific connection struct
18455819f75eSPeter Gill 		 */
18465819f75eSPeter Gill 		if (idc->idc_ini && IDM_CONN_ISINI(&ic)) {
18475819f75eSPeter Gill 			states_addr = (uintptr_t)ic.ic_handle +
18485819f75eSPeter Gill 			    offsetof(iscsi_conn_t, conn_state_audit);
18495819f75eSPeter Gill 
18505819f75eSPeter Gill 			mdb_printf("State History(iscsi_conn_t "
18515819f75eSPeter Gill 			    "conn_state_audit):\n");
18525819f75eSPeter Gill 			if (iscsi_sm_audit_impl(states_addr) != DCMD_OK) {
18535819f75eSPeter Gill 				return (DCMD_ERR);
18545819f75eSPeter Gill 			}
18555819f75eSPeter Gill 		}
18565819f75eSPeter Gill 
1857a6d42e7dSPeter Dunlap 		/* Don't print state history for child objects */
1858a6d42e7dSPeter Dunlap 		idc->u.child.idc_states = 0;
1859a6d42e7dSPeter Dunlap 	}
1860a6d42e7dSPeter Dunlap 
1861a6d42e7dSPeter Dunlap 	/*
18625819f75eSPeter Gill 	 * Print refcnt audit data for the connection struct if requested.
1863a6d42e7dSPeter Dunlap 	 */
18645819f75eSPeter Gill 	if (idc->u.child.idc_conn && rc_audit) {
18655819f75eSPeter Gill 		mdb_printf("Reference History(ic_refcnt):\n");
1866a6d42e7dSPeter Dunlap 		rc_addr = addr + offsetof(idm_conn_t, ic_refcnt);
1867a6d42e7dSPeter Dunlap 		if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
1868a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
1869a6d42e7dSPeter Dunlap 
18705819f75eSPeter Gill 		/*
18715819f75eSPeter Gill 		 * If targets are specifically requested show the
18725819f75eSPeter Gill 		 * Refcounts for the target specific connection struct
18735819f75eSPeter Gill 		 */
18745819f75eSPeter Gill 		if (idc->idc_tgt && IDM_CONN_ISTGT(&ic)) {
18755819f75eSPeter Gill 			mdb_printf("Reference History(ict_refcnt):\n");
18765819f75eSPeter Gill 			rc_addr = (uintptr_t)ic.ic_handle +
18775819f75eSPeter Gill 			    offsetof(iscsit_conn_t, ict_refcnt);
18785819f75eSPeter Gill 			if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
18795819f75eSPeter Gill 				return (DCMD_ERR);
18805819f75eSPeter Gill 			}
18815819f75eSPeter Gill 
18825819f75eSPeter Gill 			mdb_printf("Reference History(ict_dispatch_refcnt):\n");
18835819f75eSPeter Gill 			rc_addr = (uintptr_t)ic.ic_handle +
18845819f75eSPeter Gill 			    offsetof(iscsit_conn_t, ict_dispatch_refcnt);
18855819f75eSPeter Gill 			if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
18865819f75eSPeter Gill 				return (DCMD_ERR);
18875819f75eSPeter Gill 			}
18885819f75eSPeter Gill 		}
18895819f75eSPeter Gill 
1890a6d42e7dSPeter Dunlap 		/* Don't print audit data for child objects */
1891a6d42e7dSPeter Dunlap 		idc->u.child.idc_rc_audit = 0;
1892a6d42e7dSPeter Dunlap 	}
1893a6d42e7dSPeter Dunlap 
1894a6d42e7dSPeter Dunlap 	task_idx = 0;
1895a6d42e7dSPeter Dunlap 
1896a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_task || idc->u.child.idc_buffer) {
1897a6d42e7dSPeter Dunlap 
18985819f75eSPeter Gill 		if (idc->u.child.idc_conn) {
18995819f75eSPeter Gill 			idc->idc_header = 1;
19005819f75eSPeter Gill 		}
19015819f75eSPeter Gill 
19025819f75eSPeter Gill 		while (task_idx < IDM_TASKIDS_MAX) {
1903a6d42e7dSPeter Dunlap 			/*
1904a6d42e7dSPeter Dunlap 			 * Read the next idm_task_t
1905a6d42e7dSPeter Dunlap 			 */
1906a6d42e7dSPeter Dunlap 			if (mdb_vread(&task_addr, sizeof (uintptr_t),
1907a6d42e7dSPeter Dunlap 			    task_ptr) != sizeof (uintptr_t)) {
1908a6d42e7dSPeter Dunlap 				mdb_warn("Failed to read task pointer");
1909a6d42e7dSPeter Dunlap 				return (DCMD_ERR);
1910a6d42e7dSPeter Dunlap 			}
1911a6d42e7dSPeter Dunlap 
1912a6d42e7dSPeter Dunlap 			if (task_addr == NULL) {
1913a6d42e7dSPeter Dunlap 				task_ptr += sizeof (uintptr_t);
1914a6d42e7dSPeter Dunlap 				task_idx++;
1915a6d42e7dSPeter Dunlap 				continue;
1916a6d42e7dSPeter Dunlap 			}
1917a6d42e7dSPeter Dunlap 
1918a6d42e7dSPeter Dunlap 			if (mdb_vread(&idt, sizeof (idm_task_t), task_addr)
1919a6d42e7dSPeter Dunlap 			    != sizeof (idm_task_t)) {
1920a6d42e7dSPeter Dunlap 				mdb_warn("Failed to read task pointer");
1921a6d42e7dSPeter Dunlap 				return (DCMD_ERR);
1922a6d42e7dSPeter Dunlap 			}
1923a6d42e7dSPeter Dunlap 
1924a6d42e7dSPeter Dunlap 			if (((uintptr_t)idt.idt_ic == addr) &&
1925a6d42e7dSPeter Dunlap 			    (idt.idt_state != TASK_IDLE)) {
1926a6d42e7dSPeter Dunlap 				if (iscsi_i_task_impl(&idt, task_addr, idc)
1927a6d42e7dSPeter Dunlap 				    == -1) {
1928a6d42e7dSPeter Dunlap 					mdb_warn("Failed to walk connection "
1929a6d42e7dSPeter Dunlap 					    "task tree");
1930a6d42e7dSPeter Dunlap 					return (DCMD_ERR);
1931a6d42e7dSPeter Dunlap 				}
1932a6d42e7dSPeter Dunlap 			}
1933a6d42e7dSPeter Dunlap 
1934a6d42e7dSPeter Dunlap 			task_ptr += sizeof (uintptr_t);
1935a6d42e7dSPeter Dunlap 			task_idx++;
1936a6d42e7dSPeter Dunlap 		}
19375819f75eSPeter Gill 	}
19385819f75eSPeter Gill 
19395819f75eSPeter Gill 	if (idc->idc_ini && IDM_CONN_ISINI(&ic) && idc->u.child.idc_cmd) {
19405819f75eSPeter Gill 		if (idc->u.child.idc_conn || idc->u.child.idc_task) {
19415819f75eSPeter Gill 			idc->idc_header = 1;
19425819f75eSPeter Gill 		}
19435819f75eSPeter Gill 		if (ini_conn.conn_queue_active.head &&
19445819f75eSPeter Gill 		    (mdb_pwalk("iscsi_ini_cmd", iscsi_ini_cmd_walk_cb, idc,
19455819f75eSPeter Gill 		    (uintptr_t)ini_conn.conn_queue_active.head) == -1)) {
19465819f75eSPeter Gill 			mdb_warn("list walk failed for iscsi cmds");
19475819f75eSPeter Gill 		}
19485819f75eSPeter Gill 		if (ini_conn.conn_queue_idm_aborting.head &&
19495819f75eSPeter Gill 		    (mdb_pwalk("iscsi_ini_cmd", iscsi_ini_cmd_walk_cb, idc,
19505819f75eSPeter Gill 		    (uintptr_t)ini_conn.conn_queue_idm_aborting.head) == -1)) {
19515819f75eSPeter Gill 			mdb_warn("list walk failed for iscsi cmds");
19525819f75eSPeter Gill 		}
19535819f75eSPeter Gill 	}
19545819f75eSPeter Gill 
19555819f75eSPeter Gill 	/*
19565819f75eSPeter Gill 	 * If connection information was handled unset header and
19575819f75eSPeter Gill 	 * decrease indent
19585819f75eSPeter Gill 	 */
19595819f75eSPeter Gill 	if (idc->u.child.idc_conn) {
1960a6d42e7dSPeter Dunlap 		idc->idc_header = 0;
19615819f75eSPeter Gill 		mdb_dec_indent(4);
1962a6d42e7dSPeter Dunlap 	}
1963a6d42e7dSPeter Dunlap 
1964a6d42e7dSPeter Dunlap 	idc->idc_verbose = verbose;
1965a6d42e7dSPeter Dunlap 	idc->u.child.idc_states = states;
1966a6d42e7dSPeter Dunlap 	idc->u.child.idc_rc_audit = rc_audit;
1967a6d42e7dSPeter Dunlap 
1968a6d42e7dSPeter Dunlap 	return (DCMD_OK);
1969a6d42e7dSPeter Dunlap }
1970a6d42e7dSPeter Dunlap 
19715819f75eSPeter Gill static int
19725819f75eSPeter Gill iscsi_svc_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
19735819f75eSPeter Gill {
19745819f75eSPeter Gill 	idm_svc_t	svc;
19755819f75eSPeter Gill 	iser_svc_t	iser_svc;
19765819f75eSPeter Gill 	uintptr_t	rc_addr;
19775819f75eSPeter Gill 
19785819f75eSPeter Gill 	if (mdb_vread(&svc, sizeof (idm_svc_t), addr) !=
19795819f75eSPeter Gill 	    sizeof (idm_svc_t)) {
19805819f75eSPeter Gill 		return (DCMD_ERR);
19815819f75eSPeter Gill 	}
19825819f75eSPeter Gill 
19835819f75eSPeter Gill 	if (idc->u.child.idc_svc) {
19845819f75eSPeter Gill 		if (idc->idc_verbose) {
19855819f75eSPeter Gill 			mdb_printf("Service %p\n", addr);
19865819f75eSPeter Gill 			mdb_printf("%20s: %d\n", "Port",
19875819f75eSPeter Gill 			    svc.is_svc_req.sr_port);
19885819f75eSPeter Gill 			mdb_printf("%20s: %d\n", "Online",
19895819f75eSPeter Gill 			    svc.is_online);
19905819f75eSPeter Gill 			mdb_printf("%20s: %p\n", "Socket Service",
19915819f75eSPeter Gill 			    svc.is_so_svc);
19925819f75eSPeter Gill 			mdb_printf("%20s: %p\n", "iSER Service",
19935819f75eSPeter Gill 			    svc.is_iser_svc);
19945819f75eSPeter Gill 		} else {
19955819f75eSPeter Gill 			if (idc->idc_header) {
19965819f75eSPeter Gill 				mdb_printf("%<u>%-?s %-8s %-8s%</u>\n",
19975819f75eSPeter Gill 				    "idm_svc_t", "Port", "Online");
19985819f75eSPeter Gill 				idc->idc_header = 0;
19995819f75eSPeter Gill 			}
20005819f75eSPeter Gill 
20015819f75eSPeter Gill 			mdb_printf("%?p %-8d %-8d\n", addr,
20025819f75eSPeter Gill 			    svc.is_svc_req.sr_port, svc.is_online);
20035819f75eSPeter Gill 		}
20045819f75eSPeter Gill 
20055819f75eSPeter Gill 		if (idc->u.child.idc_rc_audit) {
20065819f75eSPeter Gill 			(void) mdb_inc_indent(4);
20075819f75eSPeter Gill 			mdb_printf("Reference History(is_refcnt):\n");
20085819f75eSPeter Gill 			rc_addr = addr + offsetof(idm_svc_t, is_refcnt);
20095819f75eSPeter Gill 			if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
20105819f75eSPeter Gill 				(void) mdb_dec_indent(4);
20115819f75eSPeter Gill 				return (DCMD_ERR);
20125819f75eSPeter Gill 			}
20135819f75eSPeter Gill 
20145819f75eSPeter Gill 			if (svc.is_iser_svc != NULL) {
20155819f75eSPeter Gill 				mdb_printf("Reference History"
20165819f75eSPeter Gill 				    "(iser_svc is_refcnt):\n");
20175819f75eSPeter Gill 
20185819f75eSPeter Gill 				/* Sanity check the iser svc struct */
20195819f75eSPeter Gill 				if (mdb_vread(&iser_svc, sizeof (iser_svc_t),
20205819f75eSPeter Gill 				    (uintptr_t)svc.is_iser_svc) !=
20215819f75eSPeter Gill 				    sizeof (iser_svc_t)) {
20225819f75eSPeter Gill 					return (DCMD_ERR);
20235819f75eSPeter Gill 				}
20245819f75eSPeter Gill 
20255819f75eSPeter Gill 				rc_addr = (uintptr_t)svc.is_iser_svc +
20265819f75eSPeter Gill 				    offsetof(iser_svc_t, is_refcnt);
20275819f75eSPeter Gill 
20285819f75eSPeter Gill 				if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
20295819f75eSPeter Gill 					return (DCMD_ERR);
20305819f75eSPeter Gill 				}
20315819f75eSPeter Gill 			}
20325819f75eSPeter Gill 			(void) mdb_dec_indent(4);
20335819f75eSPeter Gill 		}
20345819f75eSPeter Gill 	}
20355819f75eSPeter Gill 	return (DCMD_OK);
20365819f75eSPeter Gill }
20375819f75eSPeter Gill 
2038a6d42e7dSPeter Dunlap static void
2039a6d42e7dSPeter Dunlap iscsi_print_iscsit_conn_data(idm_conn_t *ic)
2040a6d42e7dSPeter Dunlap {
2041a6d42e7dSPeter Dunlap 	iscsit_conn_t	ict;
2042a6d42e7dSPeter Dunlap 	char		*csg;
2043a6d42e7dSPeter Dunlap 	char		*nsg;
2044a6d42e7dSPeter Dunlap 
2045a6d42e7dSPeter Dunlap 	iscsi_print_idm_conn_data(ic);
2046a6d42e7dSPeter Dunlap 
2047a6d42e7dSPeter Dunlap 	if (mdb_vread(&ict, sizeof (iscsit_conn_t),
2048a6d42e7dSPeter Dunlap 	    (uintptr_t)ic->ic_handle) != sizeof (iscsit_conn_t)) {
2049a6d42e7dSPeter Dunlap 		mdb_printf("**Failed to read conn private data\n");
2050a6d42e7dSPeter Dunlap 		return;
2051a6d42e7dSPeter Dunlap 	}
2052a6d42e7dSPeter Dunlap 
20535819f75eSPeter Gill 	mdb_printf("%20s: %p\n", "iSCSIT TGT Conn",
20545819f75eSPeter Gill 	    ic->ic_handle);
20555819f75eSPeter Gill 
2056a6d42e7dSPeter Dunlap 	if (ict.ict_login_sm.icl_login_state != ILS_LOGIN_DONE) {
2057a6d42e7dSPeter Dunlap 		switch (ict.ict_login_sm.icl_login_csg) {
2058a6d42e7dSPeter Dunlap 		case ISCSI_SECURITY_NEGOTIATION_STAGE:
2059a6d42e7dSPeter Dunlap 			csg = "Security";
2060a6d42e7dSPeter Dunlap 			break;
2061a6d42e7dSPeter Dunlap 		case ISCSI_OP_PARMS_NEGOTIATION_STAGE:
2062a6d42e7dSPeter Dunlap 			csg = "Operational";
2063a6d42e7dSPeter Dunlap 			break;
2064a6d42e7dSPeter Dunlap 		case ISCSI_FULL_FEATURE_PHASE:
2065a6d42e7dSPeter Dunlap 			csg = "FFP";
2066a6d42e7dSPeter Dunlap 			break;
2067a6d42e7dSPeter Dunlap 		default:
2068a6d42e7dSPeter Dunlap 			csg = "Unknown";
2069a6d42e7dSPeter Dunlap 		}
2070a6d42e7dSPeter Dunlap 		switch (ict.ict_login_sm.icl_login_nsg) {
2071a6d42e7dSPeter Dunlap 		case ISCSI_SECURITY_NEGOTIATION_STAGE:
2072a6d42e7dSPeter Dunlap 			nsg = "Security";
2073a6d42e7dSPeter Dunlap 			break;
2074a6d42e7dSPeter Dunlap 		case ISCSI_OP_PARMS_NEGOTIATION_STAGE:
2075a6d42e7dSPeter Dunlap 			nsg = "Operational";
2076a6d42e7dSPeter Dunlap 			break;
2077a6d42e7dSPeter Dunlap 		case ISCSI_FULL_FEATURE_PHASE:
2078a6d42e7dSPeter Dunlap 			nsg = "FFP";
2079a6d42e7dSPeter Dunlap 			break;
2080a6d42e7dSPeter Dunlap 		default:
2081a6d42e7dSPeter Dunlap 			nsg = "Unknown";
2082a6d42e7dSPeter Dunlap 		}
2083a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %d\n", "Login State",
2084a6d42e7dSPeter Dunlap 		    ict.ict_login_sm.icl_login_state);
2085a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %d\n", "Login Last State",
2086a6d42e7dSPeter Dunlap 		    ict.ict_login_sm.icl_login_last_state);
2087a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %s\n", "CSG", csg);
2088a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %s\n", "NSG", nsg);
2089a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %d\n", "Transit",
2090a6d42e7dSPeter Dunlap 		    ict.ict_login_sm.icl_login_transit >> 7);
2091a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %p\n", "Request nvlist",
2092a6d42e7dSPeter Dunlap 		    ict.ict_login_sm.icl_request_nvlist);
2093a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %p\n", "Response nvlist",
2094a6d42e7dSPeter Dunlap 		    ict.ict_login_sm.icl_response_nvlist);
2095a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %p\n", "Negotiated nvlist",
2096a6d42e7dSPeter Dunlap 		    ict.ict_login_sm.icl_negotiated_values);
2097a6d42e7dSPeter Dunlap 		if (ict.ict_login_sm.icl_login_state == ILS_LOGIN_ERROR) {
2098a6d42e7dSPeter Dunlap 			mdb_printf("%20s: 0x%02x\n", "Error Class",
2099a6d42e7dSPeter Dunlap 			    ict.ict_login_sm.icl_login_resp_err_class);
2100a6d42e7dSPeter Dunlap 			mdb_printf("%20s: 0x%02x\n", "Error Detail",
2101a6d42e7dSPeter Dunlap 			    ict.ict_login_sm.icl_login_resp_err_detail);
2102a6d42e7dSPeter Dunlap 		}
2103a6d42e7dSPeter Dunlap 	}
2104a6d42e7dSPeter Dunlap 	mdb_printf("%20s: 0x%04x\n", "CID", ict.ict_cid);
2105a6d42e7dSPeter Dunlap 	mdb_printf("%20s: 0x%08x\n", "StatSN", ict.ict_statsn);
2106a6d42e7dSPeter Dunlap }
2107a6d42e7dSPeter Dunlap 
21085819f75eSPeter Gill static void
21095819f75eSPeter Gill iscsi_print_ini_conn_data(idm_conn_t *ic)
21105819f75eSPeter Gill {
21115819f75eSPeter Gill 	iscsi_conn_t	ini_conn;
21125819f75eSPeter Gill 
21135819f75eSPeter Gill 	iscsi_print_idm_conn_data(ic);
21145819f75eSPeter Gill 
21155819f75eSPeter Gill 	if (mdb_vread(&ini_conn, sizeof (iscsi_conn_t),
21165819f75eSPeter Gill 	    (uintptr_t)ic->ic_handle) != sizeof (iscsi_conn_t)) {
21175819f75eSPeter Gill 		mdb_printf("Failed to read conn private data\n");
21185819f75eSPeter Gill 		return;
21195819f75eSPeter Gill 	}
21205819f75eSPeter Gill 
21215819f75eSPeter Gill 	mdb_printf("%20s: %p\n", "iSCSI Ini Conn",
21225819f75eSPeter Gill 	    ic->ic_handle);
21235819f75eSPeter Gill 	mdb_printf("%20s: %p\n", "Parent Session",
21245819f75eSPeter Gill 	    ini_conn.conn_sess);
21255819f75eSPeter Gill 	mdb_printf("%20s: %d\n", "Conn State",
21265819f75eSPeter Gill 	    ini_conn.conn_state);
21275819f75eSPeter Gill 	mdb_printf("%20s: %d\n", "Last Conn State",
21285819f75eSPeter Gill 	    ini_conn.conn_prev_state);
21295819f75eSPeter Gill 
21305819f75eSPeter Gill 	mdb_printf("%20s: %d\n", "Login Stage",
21315819f75eSPeter Gill 	    ini_conn.conn_current_stage);
21325819f75eSPeter Gill 	mdb_printf("%20s: %d\n", "Next Login Stage",
21335819f75eSPeter Gill 	    ini_conn.conn_next_stage);
21345819f75eSPeter Gill 
21355819f75eSPeter Gill 	mdb_printf("%20s: 0x%08x\n", "Expected StatSN",
21365819f75eSPeter Gill 	    ini_conn.conn_expstatsn);
21375819f75eSPeter Gill 	mdb_printf("%20s: %p\n", "Active Queue Head",
21385819f75eSPeter Gill 	    ini_conn.conn_queue_active.head);
21395819f75eSPeter Gill 	mdb_printf("%20s: %d\n", "Abort Queue Head",
21405819f75eSPeter Gill 	    ini_conn.conn_queue_idm_aborting.head);
21415819f75eSPeter Gill }
21425819f75eSPeter Gill 
2143a6d42e7dSPeter Dunlap static void
2144a6d42e7dSPeter Dunlap iscsi_print_idm_conn_data(idm_conn_t *ic)
2145a6d42e7dSPeter Dunlap {
2146a6d42e7dSPeter Dunlap 	char		laddr[PORTAL_STR_LEN];
2147a6d42e7dSPeter Dunlap 	char		raddr[PORTAL_STR_LEN];
2148a6d42e7dSPeter Dunlap 
2149a6d42e7dSPeter Dunlap 	sa_to_str(&ic->ic_laddr, laddr);
2150a6d42e7dSPeter Dunlap 	sa_to_str(&ic->ic_raddr, raddr);
2151a6d42e7dSPeter Dunlap 
2152a6d42e7dSPeter Dunlap 	mdb_printf("%20s: %s\n", "Conn Type",
2153a6d42e7dSPeter Dunlap 	    ((ic->ic_conn_type == CONN_TYPE_TGT) ? "Target" :
2154a6d42e7dSPeter Dunlap 	    ((ic->ic_conn_type == CONN_TYPE_INI) ? "Initiator" :
2155a6d42e7dSPeter Dunlap 	    "Unknown")));
2156a6d42e7dSPeter Dunlap 	if (ic->ic_conn_type == CONN_TYPE_TGT) {
2157a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %p\n", "Svc. Binding",
2158a6d42e7dSPeter Dunlap 		    ic->ic_svc_binding);
2159a6d42e7dSPeter Dunlap 	}
2160a6d42e7dSPeter Dunlap 	mdb_printf("%20s: %s\n", "Transport",
2161a6d42e7dSPeter Dunlap 	    (ic->ic_transport_type == IDM_TRANSPORT_TYPE_ISER) ? "ISER_IB" :
2162a6d42e7dSPeter Dunlap 	    (ic->ic_transport_type == IDM_TRANSPORT_TYPE_SOCKETS) ? "SOCKETS" :
2163a6d42e7dSPeter Dunlap 	    "N/A");
2164a6d42e7dSPeter Dunlap 
2165a6d42e7dSPeter Dunlap 	mdb_printf("%20s: %s\n", "Local IP", laddr);
2166a6d42e7dSPeter Dunlap 	mdb_printf("%20s: %s\n", "Remote IP", raddr);
2167a6d42e7dSPeter Dunlap 	mdb_printf("%20s: %d\n", "State",
2168a6d42e7dSPeter Dunlap 	    ic->ic_state);
2169a6d42e7dSPeter Dunlap 	mdb_printf("%20s: %d\n", "Last State",
2170a6d42e7dSPeter Dunlap 	    ic->ic_last_state);
2171a6d42e7dSPeter Dunlap 	mdb_printf("%20s: %d %s\n", "Refcount",
2172a6d42e7dSPeter Dunlap 	    ic->ic_refcnt.ir_refcnt,
2173a6d42e7dSPeter Dunlap 	    (ic->ic_refcnt.ir_waiting == REF_NOWAIT) ? "" :
2174a6d42e7dSPeter Dunlap 	    ((ic->ic_refcnt.ir_waiting == REF_WAIT_SYNC) ? "REF_WAIT_SYNC" :
2175a6d42e7dSPeter Dunlap 	    ((ic->ic_refcnt.ir_waiting == REF_WAIT_ASYNC) ? "REF_WAIT_ASYNC" :
2176a6d42e7dSPeter Dunlap 	    "UNKNOWN")));
2177a6d42e7dSPeter Dunlap }
2178a6d42e7dSPeter Dunlap 
2179a6d42e7dSPeter Dunlap static int
2180a6d42e7dSPeter Dunlap iscsi_i_task_impl(idm_task_t *idt, uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
2181a6d42e7dSPeter Dunlap {
2182a6d42e7dSPeter Dunlap 	uintptr_t	list_addr, rc_addr;
2183a6d42e7dSPeter Dunlap 	idm_conn_type_t	conn_type;
2184a6d42e7dSPeter Dunlap 	int		verbose, states, rc_audit;
2185a6d42e7dSPeter Dunlap 
2186a6d42e7dSPeter Dunlap 	conn_type = idm_conn_type((uintptr_t)idt->idt_ic);
2187a6d42e7dSPeter Dunlap 
2188a6d42e7dSPeter Dunlap 	verbose = idc->idc_verbose;
2189a6d42e7dSPeter Dunlap 	states = idc->u.child.idc_states;
2190a6d42e7dSPeter Dunlap 	rc_audit = idc->u.child.idc_rc_audit;
2191a6d42e7dSPeter Dunlap 
2192a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_task) {
2193a6d42e7dSPeter Dunlap 		if (verbose) {
2194a6d42e7dSPeter Dunlap 			mdb_printf("Task %p\n", addr);
2195a6d42e7dSPeter Dunlap 			(void) mdb_inc_indent(2);
2196a6d42e7dSPeter Dunlap 			if (conn_type == CONN_TYPE_TGT) {
2197a6d42e7dSPeter Dunlap 				iscsi_print_iscsit_task_data(idt);
2198a6d42e7dSPeter Dunlap 			}
2199a6d42e7dSPeter Dunlap 			(void) mdb_dec_indent(2);
2200a6d42e7dSPeter Dunlap 		} else {
2201a6d42e7dSPeter Dunlap 			/* Print task data */
2202a6d42e7dSPeter Dunlap 			if (idc->idc_header) {
2203a6d42e7dSPeter Dunlap 				mdb_printf(
2204bf604c64SPeter Dunlap 				    "%<u>%-?s %-16s %-4s %-8s %-8s%</u>\n",
2205bf604c64SPeter Dunlap 				    "Tasks:", "State", "Ref",
2206a6d42e7dSPeter Dunlap 				    (conn_type == CONN_TYPE_TGT ? "TTT" :
2207a6d42e7dSPeter Dunlap 				    (conn_type == CONN_TYPE_INI ? "ITT" :
2208a6d42e7dSPeter Dunlap 				    "TT")), "Handle");
2209a6d42e7dSPeter Dunlap 			}
2210bf604c64SPeter Dunlap 			mdb_printf("%?p %-16s %04x %08x %08x\n", addr,
2211bf604c64SPeter Dunlap 			    idm_ts_name[idt->idt_state],
2212bf604c64SPeter Dunlap 			    idt->idt_refcnt.ir_refcnt,
2213bf604c64SPeter Dunlap 			    idt->idt_tt, idt->idt_client_handle);
2214a6d42e7dSPeter Dunlap 		}
2215a6d42e7dSPeter Dunlap 	}
2216a6d42e7dSPeter Dunlap 	idc->idc_header = 0;
2217a6d42e7dSPeter Dunlap 	idc->idc_verbose = 0;
2218a6d42e7dSPeter Dunlap 
2219a6d42e7dSPeter Dunlap 	/*
2220a6d42e7dSPeter Dunlap 	 * Print states if requested
2221a6d42e7dSPeter Dunlap 	 */
2222a6d42e7dSPeter Dunlap #if 0
2223a6d42e7dSPeter Dunlap 	if (states) {
2224a6d42e7dSPeter Dunlap 		states_addr = addr + offsetof(idm_task_t, idt_state_audit);
2225a6d42e7dSPeter Dunlap 
2226a6d42e7dSPeter Dunlap 		(void) mdb_inc_indent(4);
22275819f75eSPeter Gill 		mdb_printf("State History(idt_state_audit):\n");
2228a6d42e7dSPeter Dunlap 		if (iscsi_sm_audit_impl(states_addr) != DCMD_OK)
2229a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
2230a6d42e7dSPeter Dunlap 
2231a6d42e7dSPeter Dunlap 		/* Don't print state history for child objects */
2232a6d42e7dSPeter Dunlap 		idc->u.child.idc_states = 0;
2233a6d42e7dSPeter Dunlap 		(void) mdb_dec_indent(4);
2234a6d42e7dSPeter Dunlap 	}
2235a6d42e7dSPeter Dunlap #endif
2236a6d42e7dSPeter Dunlap 
2237a6d42e7dSPeter Dunlap 	/*
2238a6d42e7dSPeter Dunlap 	 * Print refcnt audit data if requested
2239a6d42e7dSPeter Dunlap 	 */
2240a6d42e7dSPeter Dunlap 	if (rc_audit) {
2241a6d42e7dSPeter Dunlap 		(void) mdb_inc_indent(4);
22425819f75eSPeter Gill 		mdb_printf("Reference History(idt_refcnt):\n");
2243a6d42e7dSPeter Dunlap 		rc_addr = addr +
2244a6d42e7dSPeter Dunlap 		    offsetof(idm_task_t, idt_refcnt);
2245a6d42e7dSPeter Dunlap 		if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
2246a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
2247a6d42e7dSPeter Dunlap 
2248a6d42e7dSPeter Dunlap 		/* Don't print audit data for child objects */
2249a6d42e7dSPeter Dunlap 		idc->u.child.idc_rc_audit = 0;
2250a6d42e7dSPeter Dunlap 		(void) mdb_dec_indent(4);
2251a6d42e7dSPeter Dunlap 	}
2252a6d42e7dSPeter Dunlap 
2253a6d42e7dSPeter Dunlap 
22545819f75eSPeter Gill 	/*
22555819f75eSPeter Gill 	 * Buffers are leaf objects and always get headers so the
22565819f75eSPeter Gill 	 * user can discern between in and out buffers.
22575819f75eSPeter Gill 	 */
2258a6d42e7dSPeter Dunlap 	if (idc->u.child.idc_buffer) {
2259a6d42e7dSPeter Dunlap 		/* Walk in buffer list */
2260a6d42e7dSPeter Dunlap 		(void) mdb_inc_indent(2);
2261a6d42e7dSPeter Dunlap 		mdb_printf("In buffers:\n");
2262a6d42e7dSPeter Dunlap 		idc->idc_header = 1;
2263a6d42e7dSPeter Dunlap 		(void) mdb_inc_indent(2);
2264a6d42e7dSPeter Dunlap 		list_addr = addr + offsetof(idm_task_t, idt_inbufv);
2265a6d42e7dSPeter Dunlap 		if (mdb_pwalk("list", iscsi_buffer_walk_cb, idc, list_addr) ==
2266a6d42e7dSPeter Dunlap 		    -1) {
2267a6d42e7dSPeter Dunlap 			mdb_warn("list walk failed for task in buffers");
2268a6d42e7dSPeter Dunlap 			(void) mdb_dec_indent(4);
2269a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
2270a6d42e7dSPeter Dunlap 		}
2271a6d42e7dSPeter Dunlap 		(void) mdb_dec_indent(2);
2272a6d42e7dSPeter Dunlap 		/* Walk out buffer list */
2273a6d42e7dSPeter Dunlap 		mdb_printf("Out buffers:\n");
2274a6d42e7dSPeter Dunlap 		idc->idc_header = 1;
2275a6d42e7dSPeter Dunlap 		(void) mdb_inc_indent(2);
2276a6d42e7dSPeter Dunlap 		list_addr = addr + offsetof(idm_task_t, idt_outbufv);
2277a6d42e7dSPeter Dunlap 		if (mdb_pwalk("list", iscsi_buffer_walk_cb, idc, list_addr) ==
2278a6d42e7dSPeter Dunlap 		    -1) {
2279a6d42e7dSPeter Dunlap 			mdb_warn("list walk failed for task out buffers\n");
2280a6d42e7dSPeter Dunlap 			(void) mdb_dec_indent(2);
2281a6d42e7dSPeter Dunlap 			return (DCMD_ERR);
2282a6d42e7dSPeter Dunlap 		}
2283a6d42e7dSPeter Dunlap 		(void) mdb_dec_indent(4);
2284a6d42e7dSPeter Dunlap 	}
2285a6d42e7dSPeter Dunlap 
2286a6d42e7dSPeter Dunlap 	idc->idc_verbose = verbose;
2287a6d42e7dSPeter Dunlap 	idc->u.child.idc_states = states;
2288a6d42e7dSPeter Dunlap 	idc->u.child.idc_rc_audit = rc_audit;
2289a6d42e7dSPeter Dunlap 
2290a6d42e7dSPeter Dunlap 	return (DCMD_OK);
2291a6d42e7dSPeter Dunlap }
2292a6d42e7dSPeter Dunlap 
2293a6d42e7dSPeter Dunlap static int
2294a6d42e7dSPeter Dunlap iscsi_task_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
2295a6d42e7dSPeter Dunlap {
2296a6d42e7dSPeter Dunlap 	idm_task_t	idt;
2297a6d42e7dSPeter Dunlap 
2298a6d42e7dSPeter Dunlap 	/*
2299a6d42e7dSPeter Dunlap 	 * Read idm_conn_t
2300a6d42e7dSPeter Dunlap 	 */
2301a6d42e7dSPeter Dunlap 	if (mdb_vread(&idt, sizeof (idm_task_t), addr) != sizeof (idm_task_t)) {
2302a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
2303a6d42e7dSPeter Dunlap 	}
2304a6d42e7dSPeter Dunlap 
2305a6d42e7dSPeter Dunlap 	return (iscsi_i_task_impl(&idt, addr, idc));
2306a6d42e7dSPeter Dunlap }
2307a6d42e7dSPeter Dunlap 
2308a6d42e7dSPeter Dunlap #define	ISCSI_CDB_INDENT	16
2309a6d42e7dSPeter Dunlap 
2310a6d42e7dSPeter Dunlap static void
2311a6d42e7dSPeter Dunlap iscsi_print_iscsit_task_data(idm_task_t *idt)
2312a6d42e7dSPeter Dunlap {
2313a6d42e7dSPeter Dunlap 	iscsit_task_t	itask;
2314a6d42e7dSPeter Dunlap 	boolean_t	good_scsi_task = B_TRUE;
2315a6d42e7dSPeter Dunlap 	scsi_task_t	scsi_task;
2316a6d42e7dSPeter Dunlap 
2317a6d42e7dSPeter Dunlap 	if (mdb_vread(&itask, sizeof (iscsit_task_t),
2318a6d42e7dSPeter Dunlap 	    (uintptr_t)idt->idt_private) != sizeof (iscsit_task_t)) {
2319a6d42e7dSPeter Dunlap 		mdb_printf("**Failed to read idt_private data\n");
2320a6d42e7dSPeter Dunlap 		return;
2321a6d42e7dSPeter Dunlap 	}
2322a6d42e7dSPeter Dunlap 
2323a6d42e7dSPeter Dunlap 	if (mdb_vread(&scsi_task, sizeof (scsi_task_t),
2324a6d42e7dSPeter Dunlap 	    (uintptr_t)itask.it_stmf_task) != sizeof (scsi_task_t)) {
2325a6d42e7dSPeter Dunlap 		good_scsi_task = B_FALSE;
2326a6d42e7dSPeter Dunlap 	}
2327a6d42e7dSPeter Dunlap 
2328bf604c64SPeter Dunlap 	mdb_printf("%20s: %s(%d)\n", "State",
2329bf604c64SPeter Dunlap 	    idt->idt_state > TASK_MAX_STATE ?
2330bf604c64SPeter Dunlap 	    "UNKNOWN" : idm_ts_name[idt->idt_state],
2331bf604c64SPeter Dunlap 	    idt->idt_state);
2332bf604c64SPeter Dunlap 	mdb_printf("%20s: %d/%d\n", "STMF abort/IDM aborted",
2333bf604c64SPeter Dunlap 	    itask.it_stmf_abort, itask.it_aborted);
2334a6d42e7dSPeter Dunlap 	mdb_printf("%20s: %p/%p/%p%s\n",
2335a6d42e7dSPeter Dunlap 	    "iscsit/STMF/LU", idt->idt_private,
2336a6d42e7dSPeter Dunlap 	    itask.it_stmf_task, good_scsi_task ? scsi_task.task_lu_private : 0,
2337a6d42e7dSPeter Dunlap 	    good_scsi_task ? "" : "**");
2338a6d42e7dSPeter Dunlap 	if (good_scsi_task) {
2339a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %08x/%08x\n", "ITT/TTT",
2340a6d42e7dSPeter Dunlap 		    itask.it_itt, itask.it_ttt);
2341a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %08x\n", "CmdSN",
2342a6d42e7dSPeter Dunlap 		    itask.it_cmdsn);
2343a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
2344a6d42e7dSPeter Dunlap 		    "LU number",
2345a6d42e7dSPeter Dunlap 		    scsi_task.task_lun_no[0], scsi_task.task_lun_no[1],
2346a6d42e7dSPeter Dunlap 		    scsi_task.task_lun_no[2], scsi_task.task_lun_no[3],
2347a6d42e7dSPeter Dunlap 		    scsi_task.task_lun_no[4], scsi_task.task_lun_no[5],
2348a6d42e7dSPeter Dunlap 		    scsi_task.task_lun_no[6], scsi_task.task_lun_no[7]);
2349bf604c64SPeter Dunlap 		mdb_printf("     CDB (%d bytes):\n",
2350a6d42e7dSPeter Dunlap 		    scsi_task.task_cdb_length);
2351a6d42e7dSPeter Dunlap 		(void) mdb_inc_indent(ISCSI_CDB_INDENT);
2352a6d42e7dSPeter Dunlap 		if (mdb_dumpptr((uintptr_t)scsi_task.task_cdb,
2353a6d42e7dSPeter Dunlap 		    scsi_task.task_cdb_length,
2354a6d42e7dSPeter Dunlap 		    MDB_DUMP_RELATIVE | MDB_DUMP_TRIM |
2355a6d42e7dSPeter Dunlap 		    MDB_DUMP_GROUP(1),
2356a6d42e7dSPeter Dunlap 		    (mdb_dumpptr_cb_t)mdb_vread, NULL)) {
2357a6d42e7dSPeter Dunlap 			mdb_printf("** Invalid CDB addr (%p)\n",
2358a6d42e7dSPeter Dunlap 			    scsi_task.task_cdb);
2359a6d42e7dSPeter Dunlap 		}
2360a6d42e7dSPeter Dunlap 		(void) mdb_dec_indent(ISCSI_CDB_INDENT);
2361a6d42e7dSPeter Dunlap 		mdb_printf("%20s: %d/%d\n", "STMF cur/max bufs",
2362a6d42e7dSPeter Dunlap 		    scsi_task.task_cur_nbufs,
2363a6d42e7dSPeter Dunlap 		    scsi_task.task_max_nbufs);
2364a6d42e7dSPeter Dunlap 		mdb_printf("%20s: 0x%08x/0x%08x/0x%08x\n", "Bytes Exp/Cmd/Done",
2365a6d42e7dSPeter Dunlap 		    scsi_task.task_expected_xfer_length,
2366a6d42e7dSPeter Dunlap 		    scsi_task.task_cmd_xfer_length,
2367a6d42e7dSPeter Dunlap 		    scsi_task.task_nbytes_transferred);
2368a6d42e7dSPeter Dunlap 		mdb_printf("%20s: 0x%x/0x%x\n", "TX-ini start/done",
2369a6d42e7dSPeter Dunlap 		    idt->idt_tx_to_ini_start,
2370a6d42e7dSPeter Dunlap 		    idt->idt_tx_to_ini_done);
2371a6d42e7dSPeter Dunlap 		mdb_printf("%20s: 0x%x/0x%x\n", "RX-ini start/done",
2372a6d42e7dSPeter Dunlap 		    idt->idt_rx_from_ini_start,
2373a6d42e7dSPeter Dunlap 		    idt->idt_rx_from_ini_done);
2374a6d42e7dSPeter Dunlap 	}
2375a6d42e7dSPeter Dunlap }
2376a6d42e7dSPeter Dunlap 
23775819f75eSPeter Gill static int
23785819f75eSPeter Gill iscsi_print_ini_lun(uintptr_t addr, const iscsi_lun_t *lun,
23795819f75eSPeter Gill     iscsi_dcmd_ctrl_t *idc)
23805819f75eSPeter Gill {
23815819f75eSPeter Gill 
23825819f75eSPeter Gill 	if (idc->u.child.idc_lun) {
23835819f75eSPeter Gill 		if (idc->idc_header) {
23845819f75eSPeter Gill 			mdb_printf("%<u>%-?s %-5s %-10s%</u>\n",
23855819f75eSPeter Gill 			    "iscsi_lun_t", "State", "Lun Number");
23865819f75eSPeter Gill 			idc->idc_header = 0;
23875819f75eSPeter Gill 		}
23885819f75eSPeter Gill 		mdb_printf("%?p %-5d %-10d\n", addr,
23895819f75eSPeter Gill 		    lun->lun_state, lun->lun_num);
23905819f75eSPeter Gill 	}
23915819f75eSPeter Gill 	return (DCMD_OK);
23925819f75eSPeter Gill }
23935819f75eSPeter Gill 
23945819f75eSPeter Gill static int
23955819f75eSPeter Gill iscsi_print_ini_cmd(uintptr_t addr, const iscsi_cmd_t *cmd,
2396*b1da084bSToomas Soome     iscsi_dcmd_ctrl_t *idc)
2397*b1da084bSToomas Soome {
23985819f75eSPeter Gill 
23995819f75eSPeter Gill 	uintptr_t states_addr;
24005819f75eSPeter Gill 
24015819f75eSPeter Gill 	if (idc->idc_header) {
24025819f75eSPeter Gill 		mdb_printf("%<u>%-?s %-?s %4s %6s/%-6s %-?s%</u>\n",
24035819f75eSPeter Gill 		    "iscsi_cmd_t", "idm_task_t", "Type",
24045819f75eSPeter Gill 		    "State", "Prev", "iscsi_lun_t");
24055819f75eSPeter Gill 		idc->idc_header = 0;
24065819f75eSPeter Gill 	}
24075819f75eSPeter Gill 
24085819f75eSPeter Gill 	mdb_printf("%?p %?p %4d %6d/%-6d %?p\n",
24095819f75eSPeter Gill 	    addr, cmd->cmd_itp, cmd->cmd_type, cmd->cmd_state,
24105819f75eSPeter Gill 	    cmd->cmd_prev_state, cmd->cmd_lun);
24115819f75eSPeter Gill 
24125819f75eSPeter Gill 	/*
24135819f75eSPeter Gill 	 * Print states if requested
24145819f75eSPeter Gill 	 */
24155819f75eSPeter Gill 	if (idc->u.child.idc_states) {
24165819f75eSPeter Gill 		states_addr = addr + offsetof(iscsi_cmd_t, cmd_state_audit);
24175819f75eSPeter Gill 
24185819f75eSPeter Gill 		(void) mdb_inc_indent(4);
24195819f75eSPeter Gill 		mdb_printf("State History(cmd_state_audit):\n");
24205819f75eSPeter Gill 		if (iscsi_sm_audit_impl(states_addr) != DCMD_OK)
24215819f75eSPeter Gill 			return (DCMD_ERR);
24225819f75eSPeter Gill 		idc->u.child.idc_states = 0;
24235819f75eSPeter Gill 		(void) mdb_dec_indent(4);
24245819f75eSPeter Gill 	}
24255819f75eSPeter Gill 	return (DCMD_OK);
24265819f75eSPeter Gill }
24275819f75eSPeter Gill 
2428a6d42e7dSPeter Dunlap static int
2429a6d42e7dSPeter Dunlap iscsi_buffer_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
2430a6d42e7dSPeter Dunlap {
2431a6d42e7dSPeter Dunlap 	idm_buf_t	idb;
2432a6d42e7dSPeter Dunlap 
2433a6d42e7dSPeter Dunlap 	/*
2434a6d42e7dSPeter Dunlap 	 * Read idm_buf_t
2435a6d42e7dSPeter Dunlap 	 */
2436a6d42e7dSPeter Dunlap 	if (mdb_vread(&idb, sizeof (idm_buf_t), addr) != sizeof (idm_buf_t)) {
2437a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
2438a6d42e7dSPeter Dunlap 	}
2439a6d42e7dSPeter Dunlap 
2440a6d42e7dSPeter Dunlap 
2441a6d42e7dSPeter Dunlap 	if (idc->idc_header) {
2442a6d42e7dSPeter Dunlap 		mdb_printf("%<u>%-?s %?s/%-8s %8s %8s %8s%</u>\n",
2443a6d42e7dSPeter Dunlap 		    "idm_buf_t", "Mem Rgn", "Length",
2444a6d42e7dSPeter Dunlap 		    "Rel Off", "Xfer Len", "Exp. Off");
24455819f75eSPeter Gill 		idc->idc_header = 0;
2446a6d42e7dSPeter Dunlap 	}
2447a6d42e7dSPeter Dunlap 
2448a6d42e7dSPeter Dunlap 	/* Print buffer data */
2449a6d42e7dSPeter Dunlap 	mdb_printf("%?p %?p/%08x %8x %8x %08x\n", addr,
2450a6d42e7dSPeter Dunlap 	    idb.idb_buf, idb.idb_buflen,
2451a6d42e7dSPeter Dunlap 	    idb.idb_bufoffset, idb.idb_xfer_len,
2452a6d42e7dSPeter Dunlap 	    idb.idb_exp_offset);
2453a6d42e7dSPeter Dunlap 
2454a6d42e7dSPeter Dunlap 
2455a6d42e7dSPeter Dunlap 	/* Buffers are leaf objects */
2456a6d42e7dSPeter Dunlap 
2457a6d42e7dSPeter Dunlap 	return (DCMD_OK);
2458a6d42e7dSPeter Dunlap }
2459a6d42e7dSPeter Dunlap 
2460a6d42e7dSPeter Dunlap static int
2461a6d42e7dSPeter Dunlap iscsi_refcnt_impl(uintptr_t addr)
2462a6d42e7dSPeter Dunlap {
2463a6d42e7dSPeter Dunlap 	idm_refcnt_t		refcnt;
2464a6d42e7dSPeter Dunlap 	refcnt_audit_buf_t	*anb;
2465a6d42e7dSPeter Dunlap 	int			ctr;
2466a6d42e7dSPeter Dunlap 
2467a6d42e7dSPeter Dunlap 	/*
2468a6d42e7dSPeter Dunlap 	 * Print refcnt info
2469a6d42e7dSPeter Dunlap 	 */
2470a6d42e7dSPeter Dunlap 	if (mdb_vread(&refcnt, sizeof (idm_refcnt_t), addr) !=
2471a6d42e7dSPeter Dunlap 	    sizeof (idm_refcnt_t)) {
24725819f75eSPeter Gill 		mdb_warn("read refcnt failed");
2473a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
2474a6d42e7dSPeter Dunlap 	}
2475a6d42e7dSPeter Dunlap 
2476a6d42e7dSPeter Dunlap 	anb = &refcnt.ir_audit_buf;
2477a6d42e7dSPeter Dunlap 
2478a6d42e7dSPeter Dunlap 	ctr = anb->anb_max_index + 1;
2479a6d42e7dSPeter Dunlap 	anb->anb_index--;
2480a6d42e7dSPeter Dunlap 	anb->anb_index &= anb->anb_max_index;
2481a6d42e7dSPeter Dunlap 
2482a6d42e7dSPeter Dunlap 	while (ctr) {
2483a6d42e7dSPeter Dunlap 		refcnt_audit_record_t	*anr;
2484a6d42e7dSPeter Dunlap 
2485a6d42e7dSPeter Dunlap 		anr = anb->anb_records + anb->anb_index;
2486a6d42e7dSPeter Dunlap 
2487a6d42e7dSPeter Dunlap 		if (anr->anr_depth) {
2488a6d42e7dSPeter Dunlap 			char c[MDB_SYM_NAMLEN];
2489a6d42e7dSPeter Dunlap 			GElf_Sym sym;
2490a6d42e7dSPeter Dunlap 			int i;
2491a6d42e7dSPeter Dunlap 
2492a6d42e7dSPeter Dunlap 			mdb_printf("\nRefCnt: %u\t", anr->anr_refcnt);
2493a6d42e7dSPeter Dunlap 
2494a6d42e7dSPeter Dunlap 			for (i = 0; i < anr->anr_depth; i++) {
2495a6d42e7dSPeter Dunlap 				if (mdb_lookup_by_addr(anr->anr_stack[i],
2496a6d42e7dSPeter Dunlap 				    MDB_SYM_FUZZY, c, sizeof (c),
2497a6d42e7dSPeter Dunlap 				    &sym) == -1) {
2498a6d42e7dSPeter Dunlap 					continue;
2499a6d42e7dSPeter Dunlap 				}
2500a6d42e7dSPeter Dunlap 				mdb_printf("%s+0x%1x", c,
2501a6d42e7dSPeter Dunlap 				    anr->anr_stack[i] -
2502a6d42e7dSPeter Dunlap 				    (uintptr_t)sym.st_value);
2503a6d42e7dSPeter Dunlap 				++i;
2504a6d42e7dSPeter Dunlap 				break;
2505a6d42e7dSPeter Dunlap 			}
2506a6d42e7dSPeter Dunlap 
2507a6d42e7dSPeter Dunlap 			while (i < anr->anr_depth) {
2508a6d42e7dSPeter Dunlap 				if (mdb_lookup_by_addr(anr->anr_stack[i],
2509a6d42e7dSPeter Dunlap 				    MDB_SYM_FUZZY, c, sizeof (c),
2510a6d42e7dSPeter Dunlap 				    &sym) == -1) {
2511a6d42e7dSPeter Dunlap 					++i;
2512a6d42e7dSPeter Dunlap 					continue;
2513a6d42e7dSPeter Dunlap 				}
2514a6d42e7dSPeter Dunlap 				mdb_printf("\n\t\t%s+0x%1x", c,
2515a6d42e7dSPeter Dunlap 				    anr->anr_stack[i] -
2516a6d42e7dSPeter Dunlap 				    (uintptr_t)sym.st_value);
2517a6d42e7dSPeter Dunlap 				++i;
2518a6d42e7dSPeter Dunlap 			}
2519a6d42e7dSPeter Dunlap 			mdb_printf("\n");
2520a6d42e7dSPeter Dunlap 		}
2521a6d42e7dSPeter Dunlap 		anb->anb_index--;
2522a6d42e7dSPeter Dunlap 		anb->anb_index &= anb->anb_max_index;
2523a6d42e7dSPeter Dunlap 		ctr--;
2524a6d42e7dSPeter Dunlap 	}
2525a6d42e7dSPeter Dunlap 
2526a6d42e7dSPeter Dunlap 	return (DCMD_OK);
2527a6d42e7dSPeter Dunlap }
2528a6d42e7dSPeter Dunlap 
2529a6d42e7dSPeter Dunlap static int
2530a6d42e7dSPeter Dunlap iscsi_sm_audit_impl(uintptr_t addr)
2531a6d42e7dSPeter Dunlap {
2532a6d42e7dSPeter Dunlap 	sm_audit_buf_t		audit_buf;
2533a6d42e7dSPeter Dunlap 	int			ctr;
2534a6d42e7dSPeter Dunlap 	const char		*event_name;
2535a6d42e7dSPeter Dunlap 	const char		*state_name;
2536a6d42e7dSPeter Dunlap 	const char		*new_state_name;
2537a6d42e7dSPeter Dunlap 	char			ts_string[40];
2538a6d42e7dSPeter Dunlap 	/*
2539a6d42e7dSPeter Dunlap 	 * Print refcnt info
2540a6d42e7dSPeter Dunlap 	 */
2541a6d42e7dSPeter Dunlap 	if (mdb_vread(&audit_buf, sizeof (sm_audit_buf_t), addr) !=
2542a6d42e7dSPeter Dunlap 	    sizeof (sm_audit_buf_t)) {
25435819f75eSPeter Gill 		mdb_warn("failed to read audit buf");
2544a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
2545a6d42e7dSPeter Dunlap 	}
2546a6d42e7dSPeter Dunlap 
2547a6d42e7dSPeter Dunlap 	ctr = audit_buf.sab_max_index + 1;
2548a6d42e7dSPeter Dunlap 	audit_buf.sab_index++;
2549a6d42e7dSPeter Dunlap 	audit_buf.sab_index &= audit_buf.sab_max_index;
2550a6d42e7dSPeter Dunlap 
2551a6d42e7dSPeter Dunlap 	while (ctr) {
2552a6d42e7dSPeter Dunlap 		sm_audit_record_t	*sar;
2553a6d42e7dSPeter Dunlap 
2554a6d42e7dSPeter Dunlap 		sar = audit_buf.sab_records + audit_buf.sab_index;
2555a6d42e7dSPeter Dunlap 
2556a6d42e7dSPeter Dunlap 		iscsi_format_timestamp(ts_string, 40, &sar->sar_timestamp);
2557a6d42e7dSPeter Dunlap 
2558a6d42e7dSPeter Dunlap 		switch (sar->sar_type) {
2559a6d42e7dSPeter Dunlap 		case SAR_STATE_EVENT:
2560a6d42e7dSPeter Dunlap 			switch (sar->sar_sm_type) {
2561a6d42e7dSPeter Dunlap 			case SAS_IDM_CONN:
2562a6d42e7dSPeter Dunlap 				state_name =
2563a6d42e7dSPeter Dunlap 				    iscsi_idm_conn_state(sar->sar_state);
2564a6d42e7dSPeter Dunlap 				event_name =
2565a6d42e7dSPeter Dunlap 				    iscsi_idm_conn_event(sar->sar_event);
2566a6d42e7dSPeter Dunlap 				break;
2567a6d42e7dSPeter Dunlap 			case SAS_ISCSIT_TGT:
2568a6d42e7dSPeter Dunlap 				state_name =
2569a6d42e7dSPeter Dunlap 				    iscsi_iscsit_tgt_state(sar->sar_state);
2570a6d42e7dSPeter Dunlap 				event_name =
2571a6d42e7dSPeter Dunlap 				    iscsi_iscsit_tgt_event(sar->sar_event);
2572a6d42e7dSPeter Dunlap 				break;
2573a6d42e7dSPeter Dunlap 			case SAS_ISCSIT_SESS:
2574a6d42e7dSPeter Dunlap 				state_name =
2575a6d42e7dSPeter Dunlap 				    iscsi_iscsit_sess_state(sar->sar_state);
2576a6d42e7dSPeter Dunlap 				event_name =
2577a6d42e7dSPeter Dunlap 				    iscsi_iscsit_sess_event(sar->sar_event);
2578a6d42e7dSPeter Dunlap 				break;
2579a6d42e7dSPeter Dunlap 			case SAS_ISCSIT_LOGIN:
2580a6d42e7dSPeter Dunlap 				state_name =
2581a6d42e7dSPeter Dunlap 				    iscsi_iscsit_login_state(sar->sar_state);
2582a6d42e7dSPeter Dunlap 				event_name =
2583a6d42e7dSPeter Dunlap 				    iscsi_iscsit_login_event(sar->sar_event);
2584a6d42e7dSPeter Dunlap 				break;
258530e7468fSPeter Dunlap 			case SAS_ISCSI_CMD:
258630e7468fSPeter Dunlap 				state_name =
258730e7468fSPeter Dunlap 				    iscsi_iscsi_cmd_state(sar->sar_state);
258830e7468fSPeter Dunlap 				event_name=
258930e7468fSPeter Dunlap 				    iscsi_iscsi_cmd_event(sar->sar_event);
259030e7468fSPeter Dunlap 				break;
259130e7468fSPeter Dunlap 			case SAS_ISCSI_SESS:
259230e7468fSPeter Dunlap 				state_name =
259330e7468fSPeter Dunlap 				    iscsi_iscsi_sess_state(sar->sar_state);
259430e7468fSPeter Dunlap 				event_name=
259530e7468fSPeter Dunlap 				    iscsi_iscsi_sess_event(sar->sar_event);
259630e7468fSPeter Dunlap 				break;
25975f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			case SAS_ISCSI_CONN:
25985f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 				state_name =
25995f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 				    iscsi_iscsi_conn_state(sar->sar_state);
26005f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 				event_name=
26015f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 				    iscsi_iscsi_conn_event(sar->sar_event);
26025f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 				break;
2603a6d42e7dSPeter Dunlap 			default:
2604a6d42e7dSPeter Dunlap 				state_name = event_name = "N/A";
2605a6d42e7dSPeter Dunlap 				break;
2606a6d42e7dSPeter Dunlap 			}
2607a6d42e7dSPeter Dunlap 			mdb_printf("%s|%s (%d)\n\t%9s %s (%d) %p\n",
2608a6d42e7dSPeter Dunlap 			    ts_string, state_name, sar->sar_state,
2609a6d42e7dSPeter Dunlap 			    "Event", event_name,
2610a6d42e7dSPeter Dunlap 			    sar->sar_event, sar->sar_event_info);
2611a6d42e7dSPeter Dunlap 
2612a6d42e7dSPeter Dunlap 			break;
2613a6d42e7dSPeter Dunlap 		case SAR_STATE_CHANGE:
2614a6d42e7dSPeter Dunlap 			switch (sar->sar_sm_type) {
2615a6d42e7dSPeter Dunlap 			case SAS_IDM_CONN:
2616a6d42e7dSPeter Dunlap 				state_name =
2617a6d42e7dSPeter Dunlap 				    iscsi_idm_conn_state(sar->sar_state);
2618a6d42e7dSPeter Dunlap 				new_state_name =
2619a6d42e7dSPeter Dunlap 				    iscsi_idm_conn_state(sar->sar_new_state);
2620a6d42e7dSPeter Dunlap 				break;
2621a6d42e7dSPeter Dunlap 			case SAS_IDM_TASK:
2622a6d42e7dSPeter Dunlap 				state_name =
2623a6d42e7dSPeter Dunlap 				    iscsi_idm_task_state(sar->sar_state);
2624a6d42e7dSPeter Dunlap 				new_state_name =
2625a6d42e7dSPeter Dunlap 				    iscsi_idm_task_state(sar->sar_new_state);
2626a6d42e7dSPeter Dunlap 				break;
2627a6d42e7dSPeter Dunlap 			case SAS_ISCSIT_TGT:
2628a6d42e7dSPeter Dunlap 				state_name =
2629a6d42e7dSPeter Dunlap 				    iscsi_iscsit_tgt_state(sar->sar_state);
2630a6d42e7dSPeter Dunlap 				new_state_name =
2631a6d42e7dSPeter Dunlap 				    iscsi_iscsit_tgt_state(sar->sar_new_state);
2632a6d42e7dSPeter Dunlap 				break;
2633a6d42e7dSPeter Dunlap 			case SAS_ISCSIT_SESS:
2634a6d42e7dSPeter Dunlap 				state_name =
2635a6d42e7dSPeter Dunlap 				    iscsi_iscsit_sess_state(sar->sar_state);
2636a6d42e7dSPeter Dunlap 				new_state_name =
2637a6d42e7dSPeter Dunlap 				    iscsi_iscsit_sess_state(sar->sar_new_state);
2638a6d42e7dSPeter Dunlap 				break;
2639a6d42e7dSPeter Dunlap 			case SAS_ISCSIT_LOGIN:
2640a6d42e7dSPeter Dunlap 				state_name =
2641a6d42e7dSPeter Dunlap 				    iscsi_iscsit_login_state(sar->sar_state);
2642a6d42e7dSPeter Dunlap 				new_state_name =
2643a6d42e7dSPeter Dunlap 				    iscsi_iscsit_login_state(
2644a6d42e7dSPeter Dunlap 				    sar->sar_new_state);
2645a6d42e7dSPeter Dunlap 				break;
264630e7468fSPeter Dunlap 			case SAS_ISCSI_CMD:
264730e7468fSPeter Dunlap 				state_name =
264830e7468fSPeter Dunlap 				    iscsi_iscsi_cmd_state(sar->sar_state);
264930e7468fSPeter Dunlap 				new_state_name=
265030e7468fSPeter Dunlap 				    iscsi_iscsi_cmd_state(sar->sar_new_state);
265130e7468fSPeter Dunlap 				break;
265230e7468fSPeter Dunlap 			case SAS_ISCSI_SESS:
265330e7468fSPeter Dunlap 				state_name =
265430e7468fSPeter Dunlap 				    iscsi_iscsi_sess_state(sar->sar_state);
265530e7468fSPeter Dunlap 				new_state_name=
265630e7468fSPeter Dunlap 				    iscsi_iscsi_sess_state(sar->sar_new_state);
265730e7468fSPeter Dunlap 				break;
265830e7468fSPeter Dunlap 			case SAS_ISCSI_CONN:
265930e7468fSPeter Dunlap 				state_name =
266030e7468fSPeter Dunlap 				    iscsi_iscsi_conn_state(sar->sar_state);
266130e7468fSPeter Dunlap 				new_state_name=
266230e7468fSPeter Dunlap 				    iscsi_iscsi_conn_state(sar->sar_new_state);
266330e7468fSPeter Dunlap 				break;
266430e7468fSPeter Dunlap 			case SAS_ISCSI_LOGIN:
266530e7468fSPeter Dunlap 				state_name =
266630e7468fSPeter Dunlap 				    iscsi_iscsi_login_state(sar->sar_state);
266730e7468fSPeter Dunlap 				new_state_name=
266830e7468fSPeter Dunlap 				    iscsi_iscsi_login_state(sar->sar_new_state);
266930e7468fSPeter Dunlap 				break;
2670a6d42e7dSPeter Dunlap 			default:
2671*b1da084bSToomas Soome 				state_name = new_state_name = "N/A";
2672a6d42e7dSPeter Dunlap 				break;
2673a6d42e7dSPeter Dunlap 			}
2674a6d42e7dSPeter Dunlap 			mdb_printf("%s|%s (%d)\n\t%9s %s (%d)\n",
2675a6d42e7dSPeter Dunlap 			    ts_string, state_name, sar->sar_state,
2676a6d42e7dSPeter Dunlap 			    "New State", new_state_name, sar->sar_new_state);
2677*b1da084bSToomas Soome 
2678*b1da084bSToomas Soome 			break;
2679a6d42e7dSPeter Dunlap 		default:
2680a6d42e7dSPeter Dunlap 			break;
2681a6d42e7dSPeter Dunlap 		}
2682a6d42e7dSPeter Dunlap 
2683a6d42e7dSPeter Dunlap 		audit_buf.sab_index++;
2684a6d42e7dSPeter Dunlap 		audit_buf.sab_index &= audit_buf.sab_max_index;
2685a6d42e7dSPeter Dunlap 		ctr--;
2686a6d42e7dSPeter Dunlap 	}
2687a6d42e7dSPeter Dunlap 
2688a6d42e7dSPeter Dunlap 	return (DCMD_OK);
2689a6d42e7dSPeter Dunlap }
2690a6d42e7dSPeter Dunlap 
2691a6d42e7dSPeter Dunlap static const char *
269230e7468fSPeter Dunlap iscsi_idm_conn_event(unsigned int event)
2693a6d42e7dSPeter Dunlap {
269430e7468fSPeter Dunlap 	return ((event < CE_MAX_EVENT) ? idm_ce_name[event] : "N/A");
2695a6d42e7dSPeter Dunlap }
2696a6d42e7dSPeter Dunlap 
2697a6d42e7dSPeter Dunlap static const char *
269830e7468fSPeter Dunlap iscsi_iscsit_tgt_event(unsigned int event)
2699a6d42e7dSPeter Dunlap {
270030e7468fSPeter Dunlap 	return ((event < TE_MAX_EVENT) ? iscsit_te_name[event] : "N/A");
2701a6d42e7dSPeter Dunlap }
2702a6d42e7dSPeter Dunlap 
2703a6d42e7dSPeter Dunlap static const char *
270430e7468fSPeter Dunlap iscsi_iscsit_sess_event(unsigned int event)
2705a6d42e7dSPeter Dunlap {
270630e7468fSPeter Dunlap 	return ((event < SE_MAX_EVENT) ? iscsit_se_name[event] : "N/A");
2707a6d42e7dSPeter Dunlap }
2708a6d42e7dSPeter Dunlap 
2709a6d42e7dSPeter Dunlap static const char *
271030e7468fSPeter Dunlap iscsi_iscsit_login_event(unsigned int event)
2711a6d42e7dSPeter Dunlap {
271230e7468fSPeter Dunlap 	return ((event < ILE_MAX_EVENT) ? iscsit_ile_name[event] : "N/A");
271330e7468fSPeter Dunlap }
2714a6d42e7dSPeter Dunlap 
271530e7468fSPeter Dunlap static const char *
271630e7468fSPeter Dunlap iscsi_iscsi_cmd_event(unsigned int event)
271730e7468fSPeter Dunlap {
271830e7468fSPeter Dunlap 	return ((event < ISCSI_CMD_EVENT_MAX) ?
271930e7468fSPeter Dunlap 	    iscsi_cmd_event_names[event] : "N/A");
2720a6d42e7dSPeter Dunlap }
2721a6d42e7dSPeter Dunlap 
2722a6d42e7dSPeter Dunlap static const char *
272330e7468fSPeter Dunlap iscsi_iscsi_sess_event(unsigned int event)
2724a6d42e7dSPeter Dunlap {
2725a6d42e7dSPeter Dunlap 
272630e7468fSPeter Dunlap 	return ((event < ISCSI_SESS_EVENT_MAX) ?
272730e7468fSPeter Dunlap 	    iscsi_sess_event_names[event] : "N/A");
272830e7468fSPeter Dunlap }
2729a6d42e7dSPeter Dunlap 
273030e7468fSPeter Dunlap static const char *
273130e7468fSPeter Dunlap iscsi_idm_conn_state(unsigned int state)
273230e7468fSPeter Dunlap {
273330e7468fSPeter Dunlap 	return ((state < CS_MAX_STATE) ? idm_cs_name[state] : "N/A");
2734a6d42e7dSPeter Dunlap }
2735a6d42e7dSPeter Dunlap 
27365f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States static const char *
27375f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States iscsi_iscsi_conn_event(unsigned int event)
27385f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States {
27395f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
27405f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	return ((event < CN_MAX) ? idm_cn_strings[event] : "N/A");
27415f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States }
27425f7d09c6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
2743a6d42e7dSPeter Dunlap /*ARGSUSED*/
2744a6d42e7dSPeter Dunlap static const char *
274530e7468fSPeter Dunlap iscsi_idm_task_state(unsigned int state)
2746a6d42e7dSPeter Dunlap {
274730e7468fSPeter Dunlap 	return ("N/A");
2748a6d42e7dSPeter Dunlap }
2749a6d42e7dSPeter Dunlap 
2750a6d42e7dSPeter Dunlap static const char *
275130e7468fSPeter Dunlap iscsi_iscsit_tgt_state(unsigned int state)
2752a6d42e7dSPeter Dunlap {
275330e7468fSPeter Dunlap 	return ((state < TS_MAX_STATE) ? iscsit_ts_name[state] : "N/A");
2754a6d42e7dSPeter Dunlap }
2755a6d42e7dSPeter Dunlap 
2756a6d42e7dSPeter Dunlap static const char *
275730e7468fSPeter Dunlap iscsi_iscsit_sess_state(unsigned int state)
2758a6d42e7dSPeter Dunlap {
275930e7468fSPeter Dunlap 	return ((state < SS_MAX_STATE) ? iscsit_ss_name[state] : "N/A");
276030e7468fSPeter Dunlap }
2761a6d42e7dSPeter Dunlap 
276230e7468fSPeter Dunlap static const char *
276330e7468fSPeter Dunlap iscsi_iscsit_login_state(unsigned int state)
276430e7468fSPeter Dunlap {
276530e7468fSPeter Dunlap 	return ((state < ILS_MAX_STATE) ? iscsit_ils_name[state] : "N/A");
2766a6d42e7dSPeter Dunlap }
2767a6d42e7dSPeter Dunlap 
2768a6d42e7dSPeter Dunlap static const char *
276930e7468fSPeter Dunlap iscsi_iscsi_cmd_state(unsigned int state)
2770a6d42e7dSPeter Dunlap {
277130e7468fSPeter Dunlap 	return ((state < ISCSI_CMD_STATE_MAX) ?
277230e7468fSPeter Dunlap 	    iscsi_cmd_state_names[state] : "N/A");
277330e7468fSPeter Dunlap }
2774a6d42e7dSPeter Dunlap 
277530e7468fSPeter Dunlap static const char *
277630e7468fSPeter Dunlap iscsi_iscsi_sess_state(unsigned int state)
277730e7468fSPeter Dunlap {
277830e7468fSPeter Dunlap 	return ((state < ISCSI_SESS_STATE_MAX) ?
277930e7468fSPeter Dunlap 	    iscsi_sess_state_names[state] : "N/A");
278030e7468fSPeter Dunlap }
2781a6d42e7dSPeter Dunlap 
278230e7468fSPeter Dunlap static const char *
278330e7468fSPeter Dunlap iscsi_iscsi_conn_state(unsigned int state)
278430e7468fSPeter Dunlap {
278530e7468fSPeter Dunlap 	return ((state < ISCSI_CONN_STATE_MAX) ? iscsi_ics_name[state] : "N/A");
2786a6d42e7dSPeter Dunlap }
2787a6d42e7dSPeter Dunlap 
278830e7468fSPeter Dunlap static const char *
278930e7468fSPeter Dunlap iscsi_iscsi_login_state(unsigned int state)
279030e7468fSPeter Dunlap {
279130e7468fSPeter Dunlap 	return ((state < LOGIN_MAX) ? iscsi_login_state_names[state] : "N/A");
279230e7468fSPeter Dunlap }
2793a6d42e7dSPeter Dunlap 
2794a6d42e7dSPeter Dunlap 
2795a6d42e7dSPeter Dunlap /*
2796a6d42e7dSPeter Dunlap  * Retrieve connection type given a kernel address
2797a6d42e7dSPeter Dunlap  */
2798a6d42e7dSPeter Dunlap static idm_conn_type_t
2799a6d42e7dSPeter Dunlap idm_conn_type(uintptr_t addr)
2800a6d42e7dSPeter Dunlap {
2801a6d42e7dSPeter Dunlap 	idm_conn_type_t result = 0; /* Unknown */
2802a6d42e7dSPeter Dunlap 	uintptr_t idm_conn_type_addr;
2803a6d42e7dSPeter Dunlap 
2804a6d42e7dSPeter Dunlap 	idm_conn_type_addr = addr + offsetof(idm_conn_t, ic_conn_type);
2805a6d42e7dSPeter Dunlap 	(void) mdb_vread(&result, sizeof (result), idm_conn_type_addr);
2806a6d42e7dSPeter Dunlap 
2807a6d42e7dSPeter Dunlap 	return (result);
2808a6d42e7dSPeter Dunlap }
2809a6d42e7dSPeter Dunlap 
2810a6d42e7dSPeter Dunlap /*
2811a6d42e7dSPeter Dunlap  * Convert a sockaddr to the string representation, suitable for
2812a6d42e7dSPeter Dunlap  * storing in an nvlist or printing out in a list.
2813a6d42e7dSPeter Dunlap  */
2814a6d42e7dSPeter Dunlap static int
2815a6d42e7dSPeter Dunlap sa_to_str(struct sockaddr_storage *sa, char *buf)
2816a6d42e7dSPeter Dunlap {
2817a6d42e7dSPeter Dunlap 	char			pbuf[7];
2818a6d42e7dSPeter Dunlap 	const char		*bufp;
2819a6d42e7dSPeter Dunlap 	struct sockaddr_in	*sin;
2820a6d42e7dSPeter Dunlap 	struct sockaddr_in6	*sin6;
2821a6d42e7dSPeter Dunlap 	uint16_t		port;
2822a6d42e7dSPeter Dunlap 
2823a6d42e7dSPeter Dunlap 	if (!sa || !buf) {
2824a6d42e7dSPeter Dunlap 		return (EINVAL);
2825a6d42e7dSPeter Dunlap 	}
2826a6d42e7dSPeter Dunlap 
2827a6d42e7dSPeter Dunlap 	buf[0] = '\0';
2828a6d42e7dSPeter Dunlap 
2829a6d42e7dSPeter Dunlap 	if (sa->ss_family == AF_INET) {
2830a6d42e7dSPeter Dunlap 		sin = (struct sockaddr_in *)sa;
283130e7468fSPeter Dunlap 		bufp = iscsi_inet_ntop(AF_INET,
2832a6d42e7dSPeter Dunlap 		    (const void *)&(sin->sin_addr.s_addr),
2833a6d42e7dSPeter Dunlap 		    buf, PORTAL_STR_LEN);
2834a6d42e7dSPeter Dunlap 		if (bufp == NULL) {
2835a6d42e7dSPeter Dunlap 			return (-1);
2836a6d42e7dSPeter Dunlap 		}
2837a6d42e7dSPeter Dunlap 		mdb_nhconvert(&port, &sin->sin_port, sizeof (uint16_t));
2838a6d42e7dSPeter Dunlap 	} else if (sa->ss_family == AF_INET6) {
2839a6d42e7dSPeter Dunlap 		strlcat(buf, "[", sizeof (buf));
2840a6d42e7dSPeter Dunlap 		sin6 = (struct sockaddr_in6 *)sa;
284130e7468fSPeter Dunlap 		bufp = iscsi_inet_ntop(AF_INET6,
2842a6d42e7dSPeter Dunlap 		    (const void *)&sin6->sin6_addr.s6_addr,
2843a6d42e7dSPeter Dunlap 		    &buf[1], PORTAL_STR_LEN - 1);
2844a6d42e7dSPeter Dunlap 		if (bufp == NULL) {
2845a6d42e7dSPeter Dunlap 			return (-1);
2846a6d42e7dSPeter Dunlap 		}
2847a6d42e7dSPeter Dunlap 		strlcat(buf, "]", PORTAL_STR_LEN);
2848c89a15d4SRichard Lowe 		mdb_nhconvert(&port, &sin6->sin6_port, sizeof (uint16_t));
2849a6d42e7dSPeter Dunlap 	} else {
2850a6d42e7dSPeter Dunlap 		return (EINVAL);
2851a6d42e7dSPeter Dunlap 	}
2852a6d42e7dSPeter Dunlap 
2853a6d42e7dSPeter Dunlap 
2854a6d42e7dSPeter Dunlap 	mdb_snprintf(pbuf, sizeof (pbuf), ":%u", port);
2855a6d42e7dSPeter Dunlap 	strlcat(buf, pbuf, PORTAL_STR_LEN);
2856a6d42e7dSPeter Dunlap 
2857a6d42e7dSPeter Dunlap 	return (0);
2858a6d42e7dSPeter Dunlap }
2859a6d42e7dSPeter Dunlap 
2860a6d42e7dSPeter Dunlap 
2861a6d42e7dSPeter Dunlap static void
2862a6d42e7dSPeter Dunlap iscsi_format_timestamp(char *ts_str, int strlen, timespec_t *ts)
2863a6d42e7dSPeter Dunlap {
2864a6d42e7dSPeter Dunlap 	mdb_snprintf(ts_str, strlen, "%Y:%03d:%03d:%03d", ts->tv_sec,
2865a6d42e7dSPeter Dunlap 	    (ts->tv_nsec / 1000000) % 1000, (ts->tv_nsec / 1000) % 1000,
2866a6d42e7dSPeter Dunlap 	    ts->tv_nsec % 1000);
2867a6d42e7dSPeter Dunlap }
2868a6d42e7dSPeter Dunlap 
2869a6d42e7dSPeter Dunlap /*
2870a6d42e7dSPeter Dunlap  * Help information for the iscsi_isns dcmd
2871a6d42e7dSPeter Dunlap  */
2872a6d42e7dSPeter Dunlap static void
2873a6d42e7dSPeter Dunlap iscsi_isns_help(void)
2874a6d42e7dSPeter Dunlap {
2875a6d42e7dSPeter Dunlap 	mdb_printf("iscsi_isns:\n");
2876a6d42e7dSPeter Dunlap 	mdb_inc_indent(4);
2877a6d42e7dSPeter Dunlap 	mdb_printf("-e: Print ESI information\n");
2878a6d42e7dSPeter Dunlap 	mdb_printf("-p: Print portal information\n");
2879a6d42e7dSPeter Dunlap 	mdb_printf("-s: Print iSNS server information\n");
2880a6d42e7dSPeter Dunlap 	mdb_printf("-t: Print target information\n");
2881a6d42e7dSPeter Dunlap 	mdb_printf("-v: Add verbosity to the other options' output\n");
28825819f75eSPeter Gill 	mdb_printf("-R: Add Refcount information to '-t' output\n");
2883a6d42e7dSPeter Dunlap 	mdb_dec_indent(4);
2884a6d42e7dSPeter Dunlap }
2885a6d42e7dSPeter Dunlap 
2886a6d42e7dSPeter Dunlap /* ARGSUSED */
2887a6d42e7dSPeter Dunlap static int
2888a6d42e7dSPeter Dunlap iscsi_isns_esi_cb(uintptr_t addr, const void *walker_data, void *data)
2889a6d42e7dSPeter Dunlap {
2890a6d42e7dSPeter Dunlap 	isns_esi_tinfo_t tinfo;
2891a6d42e7dSPeter Dunlap 
2892a6d42e7dSPeter Dunlap 	if (mdb_vread(&tinfo, sizeof (isns_esi_tinfo_t), addr) !=
2893a6d42e7dSPeter Dunlap 	    sizeof (isns_esi_tinfo_t)) {
2894a6d42e7dSPeter Dunlap 		return (WALK_ERR);
2895a6d42e7dSPeter Dunlap 	}
2896a6d42e7dSPeter Dunlap 
2897a6d42e7dSPeter Dunlap 	mdb_printf("ESI thread/thr did : 0x%p / %d\n", tinfo.esi_thread,
2898a6d42e7dSPeter Dunlap 	    tinfo.esi_thread_did);
2899a6d42e7dSPeter Dunlap 	mdb_printf("ESI sonode         : 0x%p\n", tinfo.esi_so);
2900a6d42e7dSPeter Dunlap 	mdb_printf("ESI port           : %d\n", tinfo.esi_port);
2901a6d42e7dSPeter Dunlap 	mdb_printf("ESI thread running : %s\n",
2902a6d42e7dSPeter Dunlap 	    (tinfo.esi_thread_running) ? "Yes" : "No");
2903a6d42e7dSPeter Dunlap 
2904a6d42e7dSPeter Dunlap 	return (WALK_NEXT);
2905a6d42e7dSPeter Dunlap }
2906a6d42e7dSPeter Dunlap 
2907a6d42e7dSPeter Dunlap static int
2908a6d42e7dSPeter Dunlap iscsi_isns_esi(iscsi_dcmd_ctrl_t *idc)
2909a6d42e7dSPeter Dunlap {
2910e42a0851Speter dunlap 	GElf_Sym		sym;
2911e42a0851Speter dunlap 	uintptr_t		addr;
2912a6d42e7dSPeter Dunlap 
2913e42a0851Speter dunlap 	if (mdb_lookup_by_name("esi", &sym) == -1) {
2914a6d42e7dSPeter Dunlap 		mdb_warn("failed to find symbol 'esi_list'");
2915a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
2916a6d42e7dSPeter Dunlap 	}
2917e42a0851Speter dunlap 	addr = (uintptr_t)sym.st_value;
2918a6d42e7dSPeter Dunlap 
2919a6d42e7dSPeter Dunlap 	idc->idc_header = 1;
2920e42a0851Speter dunlap 	(void) iscsi_isns_esi_cb(addr, NULL, idc);
2921a6d42e7dSPeter Dunlap 
2922a6d42e7dSPeter Dunlap 	return (0);
2923a6d42e7dSPeter Dunlap }
2924a6d42e7dSPeter Dunlap 
2925a6d42e7dSPeter Dunlap /* ARGSUSED */
2926a6d42e7dSPeter Dunlap static int
2927a6d42e7dSPeter Dunlap iscsi_isns_portal_cb(uintptr_t addr, const void *walker_data, void *data)
2928a6d42e7dSPeter Dunlap {
2929a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t *idc = (iscsi_dcmd_ctrl_t *)data;
2930bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	isns_portal_t portal;
2931a6d42e7dSPeter Dunlap 	char portal_addr[PORTAL_STR_LEN];
2932a6d42e7dSPeter Dunlap 	struct sockaddr_storage *ss;
2933e42a0851Speter dunlap 	char			ts_string[40];
2934a6d42e7dSPeter Dunlap 
2935bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	if (mdb_vread(&portal, sizeof (isns_portal_t), addr) !=
2936bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    sizeof (isns_portal_t)) {
2937a6d42e7dSPeter Dunlap 		return (WALK_ERR);
2938a6d42e7dSPeter Dunlap 	}
2939a6d42e7dSPeter Dunlap 
2940a6d42e7dSPeter Dunlap 	ss = &portal.portal_addr;
2941a6d42e7dSPeter Dunlap 	sa_to_str(ss, portal_addr);
2942a6d42e7dSPeter Dunlap 	mdb_printf("Portal IP address ");
2943a6d42e7dSPeter Dunlap 
2944a6d42e7dSPeter Dunlap 	if (ss->ss_family == AF_INET) {
2945a6d42e7dSPeter Dunlap 		mdb_printf("(v4): %s", portal_addr);
2946a6d42e7dSPeter Dunlap 	} else {
2947a6d42e7dSPeter Dunlap 		mdb_printf("(v6): %s", portal_addr);
2948a6d42e7dSPeter Dunlap 	}
2949a6d42e7dSPeter Dunlap 
2950bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	if (portal.portal_default == B_TRUE) {
2951a6d42e7dSPeter Dunlap 		mdb_printf(" (Default portal)\n");
2952a6d42e7dSPeter Dunlap 	} else {
2953a6d42e7dSPeter Dunlap 		mdb_printf("\n");
2954a6d42e7dSPeter Dunlap 	}
2955bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	if (portal.portal_iscsit != NULL) {
29565819f75eSPeter Gill 		mdb_printf("(Part of TPG: 0x%p)\n", portal.portal_iscsit);
2957bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	}
2958bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
2959bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	iscsi_format_timestamp(ts_string, 40, &portal.portal_esi_timestamp);
29605819f75eSPeter Gill 	mdb_printf("Portal ESI timestamp: %s\n\n", ts_string);
2961a6d42e7dSPeter Dunlap 
2962a6d42e7dSPeter Dunlap 	if ((portal.portal_iscsit != NULL) && (idc->idc_verbose)) {
2963bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mdb_inc_indent(4);
2964a6d42e7dSPeter Dunlap 		iscsi_portal_impl((uintptr_t)portal.portal_iscsit, idc);
2965bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mdb_dec_indent(4);
2966a6d42e7dSPeter Dunlap 	}
2967a6d42e7dSPeter Dunlap 
2968a6d42e7dSPeter Dunlap 
2969a6d42e7dSPeter Dunlap 	return (WALK_NEXT);
2970a6d42e7dSPeter Dunlap }
2971a6d42e7dSPeter Dunlap 
2972a6d42e7dSPeter Dunlap static int
2973a6d42e7dSPeter Dunlap iscsi_isns_portals(iscsi_dcmd_ctrl_t *idc)
2974a6d42e7dSPeter Dunlap {
2975a6d42e7dSPeter Dunlap 	GElf_Sym sym;
2976a6d42e7dSPeter Dunlap 	uintptr_t portal_list;
2977a6d42e7dSPeter Dunlap 
2978bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("All Active Portals:\n");
2979bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
2980bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	if (mdb_lookup_by_name("isns_all_portals", &sym) == -1) {
2981bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mdb_warn("failed to find symbol 'isns_all_portals'");
2982bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		return (DCMD_ERR);
2983bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	}
2984bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
2985bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	portal_list = (uintptr_t)sym.st_value;
2986bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	idc->idc_header = 1;
2987bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
2988bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	if (mdb_pwalk("avl", iscsi_isns_portal_cb, idc, portal_list) == -1) {
2989bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mdb_warn("avl walk failed for isns_all_portals");
2990bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		return (DCMD_ERR);
2991bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	}
2992bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("\nPortals from TPGs:\n");
2993bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
2994bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	if (mdb_lookup_by_name("isns_tpg_portals", &sym) == -1) {
2995bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mdb_warn("failed to find symbol 'isns_tpg_portals'");
2996a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
2997a6d42e7dSPeter Dunlap 	}
2998a6d42e7dSPeter Dunlap 
2999a6d42e7dSPeter Dunlap 	portal_list = (uintptr_t)sym.st_value;
3000a6d42e7dSPeter Dunlap 	idc->idc_header = 1;
3001a6d42e7dSPeter Dunlap 
3002bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	if (mdb_pwalk("avl", iscsi_isns_portal_cb, idc, portal_list) == -1) {
3003bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mdb_warn("avl walk failed for isns_tpg_portals");
3004a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
3005a6d42e7dSPeter Dunlap 	}
3006a6d42e7dSPeter Dunlap 
3007bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
3008a6d42e7dSPeter Dunlap 	return (0);
3009a6d42e7dSPeter Dunlap }
3010a6d42e7dSPeter Dunlap 
3011a6d42e7dSPeter Dunlap /* ARGSUSED */
3012a6d42e7dSPeter Dunlap static int
3013a6d42e7dSPeter Dunlap iscsi_isns_targets_cb(uintptr_t addr, const void *walker_data, void *data)
3014a6d42e7dSPeter Dunlap {
3015bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	iscsi_dcmd_ctrl_t	*idc = (iscsi_dcmd_ctrl_t *)data;
3016bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	isns_target_t		itarget;
3017bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	int			rc = 0;
30185819f75eSPeter Gill 	int			rc_audit = 0;
30195819f75eSPeter Gill 	uintptr_t		rc_addr;
3020a6d42e7dSPeter Dunlap 
3021a6d42e7dSPeter Dunlap 	if (mdb_vread(&itarget, sizeof (isns_target_t), addr) !=
3022a6d42e7dSPeter Dunlap 	    sizeof (isns_target_t)) {
3023a6d42e7dSPeter Dunlap 		return (WALK_ERR);
3024a6d42e7dSPeter Dunlap 	}
3025a6d42e7dSPeter Dunlap 
3026a6d42e7dSPeter Dunlap 	idc->idc_header = 1;
30275819f75eSPeter Gill 	rc_audit = idc->u.child.idc_rc_audit;
3028a6d42e7dSPeter Dunlap 
3029bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("Target: %p\n", addr);
3030a6d42e7dSPeter Dunlap 	mdb_inc_indent(4);
3031a6d42e7dSPeter Dunlap 	mdb_printf("Registered: %s\n",
3032a6d42e7dSPeter Dunlap 	    (itarget.target_registered) ? "Yes" : "No");
3033bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("Update needed: %s\n",
3034bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    (itarget.target_update_needed) ? "Yes" : "No");
3035bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("Target Info: %p\n", itarget.target_info);
3036a6d42e7dSPeter Dunlap 
30375819f75eSPeter Gill 	/* Prevent target refcounts from showing through this path */
30385819f75eSPeter Gill 	idc->u.child.idc_rc_audit = 0;
3039a6d42e7dSPeter Dunlap 	rc = iscsi_tgt_impl((uintptr_t)itarget.target, idc);
3040a6d42e7dSPeter Dunlap 
30415819f75eSPeter Gill 	idc->u.child.idc_rc_audit = rc_audit;
30425819f75eSPeter Gill 	if (idc->u.child.idc_rc_audit) {
30435819f75eSPeter Gill 		rc_addr = (uintptr_t)itarget.target_info +
30445819f75eSPeter Gill 		    offsetof(isns_target_info_t, ti_refcnt);
30455819f75eSPeter Gill 
30465819f75eSPeter Gill 		mdb_printf("Reference History(isns_target_info ti_refcnt):\n");
30475819f75eSPeter Gill 		if (iscsi_refcnt_impl(rc_addr) != 0) {
30485819f75eSPeter Gill 			return (WALK_ERR);
30495819f75eSPeter Gill 		}
30505819f75eSPeter Gill 	}
30515819f75eSPeter Gill 
3052a6d42e7dSPeter Dunlap 	mdb_dec_indent(4);
3053a6d42e7dSPeter Dunlap 
3054a6d42e7dSPeter Dunlap 	if (rc == DCMD_OK) {
3055a6d42e7dSPeter Dunlap 		return (WALK_NEXT);
3056a6d42e7dSPeter Dunlap 	}
3057a6d42e7dSPeter Dunlap 
3058a6d42e7dSPeter Dunlap 	return (WALK_ERR);
3059a6d42e7dSPeter Dunlap }
3060a6d42e7dSPeter Dunlap 
3061a6d42e7dSPeter Dunlap static int
3062a6d42e7dSPeter Dunlap iscsi_isns_targets(iscsi_dcmd_ctrl_t *idc)
3063a6d42e7dSPeter Dunlap {
3064a6d42e7dSPeter Dunlap 	GElf_Sym sym;
3065a6d42e7dSPeter Dunlap 	uintptr_t isns_target_list;
3066a6d42e7dSPeter Dunlap 
3067a6d42e7dSPeter Dunlap 	if (mdb_lookup_by_name("isns_target_list", &sym) == -1) {
3068a6d42e7dSPeter Dunlap 		mdb_warn("failed to find symbol 'isns_target_list'");
3069a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
3070a6d42e7dSPeter Dunlap 	}
3071a6d42e7dSPeter Dunlap 
3072a6d42e7dSPeter Dunlap 	isns_target_list = (uintptr_t)sym.st_value;
3073a6d42e7dSPeter Dunlap 	idc->idc_header = 1;
3074a6d42e7dSPeter Dunlap 	idc->u.child.idc_tgt = 1;
3075a6d42e7dSPeter Dunlap 
3076a6d42e7dSPeter Dunlap 	if (mdb_pwalk("avl", iscsi_isns_targets_cb, idc,
3077a6d42e7dSPeter Dunlap 	    isns_target_list) == -1) {
3078a6d42e7dSPeter Dunlap 		mdb_warn("avl walk failed for isns_target_list");
3079a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
3080a6d42e7dSPeter Dunlap 	}
3081a6d42e7dSPeter Dunlap 
3082a6d42e7dSPeter Dunlap 	return (0);
3083a6d42e7dSPeter Dunlap }
3084a6d42e7dSPeter Dunlap 
3085a6d42e7dSPeter Dunlap /* ARGSUSED */
3086a6d42e7dSPeter Dunlap static int
3087a6d42e7dSPeter Dunlap iscsi_isns_servers_cb(uintptr_t addr, const void *walker_data, void *data)
3088a6d42e7dSPeter Dunlap {
3089a6d42e7dSPeter Dunlap 	iscsit_isns_svr_t	server;
3090a6d42e7dSPeter Dunlap 	char			server_addr[PORTAL_STR_LEN];
3091a6d42e7dSPeter Dunlap 	struct sockaddr_storage *ss;
3092a6d42e7dSPeter Dunlap 	clock_t			lbolt;
3093bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	iscsi_dcmd_ctrl_t	*idc = (iscsi_dcmd_ctrl_t *)data;
3094bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	uintptr_t		avl_addr;
3095a6d42e7dSPeter Dunlap 
3096a6d42e7dSPeter Dunlap 	if (mdb_vread(&server, sizeof (iscsit_isns_svr_t), addr) !=
3097a6d42e7dSPeter Dunlap 	    sizeof (iscsit_isns_svr_t)) {
3098a6d42e7dSPeter Dunlap 		return (WALK_ERR);
3099a6d42e7dSPeter Dunlap 	}
3100a6d42e7dSPeter Dunlap 
3101d3d50737SRafael Vanoni 	if ((lbolt = (clock_t)mdb_get_lbolt()) == -1)
3102a6d42e7dSPeter Dunlap 		return (WALK_ERR);
3103a6d42e7dSPeter Dunlap 
3104a6d42e7dSPeter Dunlap 	mdb_printf("iSNS server %p:\n", addr);
3105a6d42e7dSPeter Dunlap 	mdb_inc_indent(4);
3106a6d42e7dSPeter Dunlap 	ss = &server.svr_sa;
3107a6d42e7dSPeter Dunlap 	sa_to_str(ss, server_addr);
3108a6d42e7dSPeter Dunlap 
3109a6d42e7dSPeter Dunlap 	mdb_printf("IP address ");
3110a6d42e7dSPeter Dunlap 	if (ss->ss_family == AF_INET) {
3111a6d42e7dSPeter Dunlap 		mdb_printf("(v4): %s\n", server_addr);
3112a6d42e7dSPeter Dunlap 	} else {
3113a6d42e7dSPeter Dunlap 		mdb_printf("(v6): %s\n", server_addr);
3114a6d42e7dSPeter Dunlap 	}
3115a6d42e7dSPeter Dunlap 
3116bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("ESI Interval: %d seconds\n",
3117bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    server.svr_esi_interval);
3118bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("Last message: %d seconds ago\n",
3119a6d42e7dSPeter Dunlap 	    ((lbolt - server.svr_last_msg) / 100));
3120a6d42e7dSPeter Dunlap 	mdb_printf("Client registered: %s\n",
3121a6d42e7dSPeter Dunlap 	    (server.svr_registered) ? "Yes" : "No");
3122bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("Retry Count: %d\n",
3123bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    server.svr_retry_count);
3124bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("Targets Changes Pending: %s\n",
3125bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    (server.svr_targets_changed) ? "Yes" : "No");
3126bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("Delete Pending: %s\n",
3127bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    (server.svr_delete_needed) ? "Yes" : "No");
3128bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mdb_printf("Replace-All Needed: %s\n",
3129bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    (server.svr_reset_needed) ? "Yes" : "No");
3130bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
3131bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	if (idc->idc_verbose) {
3132bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		idc->idc_header = 1;
3133bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		idc->u.child.idc_tgt = 1;
3134bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
3135bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mdb_inc_indent(2);
3136bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		avl_addr = addr + offsetof(iscsit_isns_svr_t,
3137bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		    svr_target_list);
3138bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		if (mdb_pwalk("avl", iscsi_isns_targets_cb, idc,
3139bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		    avl_addr) == -1) {
3140bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			mdb_warn("avl walk failed for svr_target_list");
3141bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			return (WALK_ERR);
3142bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		}
3143bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mdb_dec_indent(2);
3144bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	}
3145bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
3146a6d42e7dSPeter Dunlap 	mdb_dec_indent(4);
3147a6d42e7dSPeter Dunlap 
3148bdbe8dc6SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	return (WALK_NEXT);
3149a6d42e7dSPeter Dunlap }
3150a6d42e7dSPeter Dunlap 
3151a6d42e7dSPeter Dunlap static int
3152a6d42e7dSPeter Dunlap iscsi_isns_servers(iscsi_dcmd_ctrl_t *idc)
3153a6d42e7dSPeter Dunlap {
3154a6d42e7dSPeter Dunlap 	uintptr_t	iscsit_global_addr;
3155a6d42e7dSPeter Dunlap 	uintptr_t	list_addr;
3156a6d42e7dSPeter Dunlap 	GElf_Sym	sym;
3157a6d42e7dSPeter Dunlap 
3158a6d42e7dSPeter Dunlap 	if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
3159a6d42e7dSPeter Dunlap 		mdb_warn("failed to find symbol 'iscsit_global'");
3160a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
3161a6d42e7dSPeter Dunlap 	}
3162a6d42e7dSPeter Dunlap 
3163a6d42e7dSPeter Dunlap 	iscsit_global_addr = (uintptr_t)sym.st_value;
3164a6d42e7dSPeter Dunlap 	idc->idc_header = 1;
3165a6d42e7dSPeter Dunlap 	list_addr = iscsit_global_addr +
3166a6d42e7dSPeter Dunlap 	    offsetof(iscsit_global_t, global_isns_cfg.isns_svrs);
3167a6d42e7dSPeter Dunlap 
3168a6d42e7dSPeter Dunlap 	if (mdb_pwalk("list", iscsi_isns_servers_cb, idc, list_addr) == -1) {
3169a6d42e7dSPeter Dunlap 		mdb_warn("list walk failed for iSNS servers");
3170a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
3171a6d42e7dSPeter Dunlap 	}
3172a6d42e7dSPeter Dunlap 
3173a6d42e7dSPeter Dunlap 	return (0);
3174a6d42e7dSPeter Dunlap }
3175a6d42e7dSPeter Dunlap 
3176a6d42e7dSPeter Dunlap /* ARGSUSED */
3177a6d42e7dSPeter Dunlap static int
3178a6d42e7dSPeter Dunlap iscsi_isns(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3179a6d42e7dSPeter Dunlap {
3180a6d42e7dSPeter Dunlap 	iscsi_dcmd_ctrl_t idc;
3181a6d42e7dSPeter Dunlap 	int portals = 0, esi = 0, targets = 0, verbose = 0, servers = 0;
31825819f75eSPeter Gill 	int rc_audit = 0;
3183a6d42e7dSPeter Dunlap 
3184a6d42e7dSPeter Dunlap 	if (flags & DCMD_ADDRSPEC) {
3185a6d42e7dSPeter Dunlap 		mdb_warn("iscsi_isns is only a global dcmd.");
3186a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
3187a6d42e7dSPeter Dunlap 	}
3188a6d42e7dSPeter Dunlap 
3189a6d42e7dSPeter Dunlap 	bzero(&idc, sizeof (idc));
3190a6d42e7dSPeter Dunlap 	if (mdb_getopts(argc, argv,
3191a6d42e7dSPeter Dunlap 	    'e', MDB_OPT_SETBITS, TRUE, &esi,
3192a6d42e7dSPeter Dunlap 	    'p', MDB_OPT_SETBITS, TRUE, &portals,
3193a6d42e7dSPeter Dunlap 	    's', MDB_OPT_SETBITS, TRUE, &servers,
3194a6d42e7dSPeter Dunlap 	    't', MDB_OPT_SETBITS, TRUE, &targets,
3195a6d42e7dSPeter Dunlap 	    'v', MDB_OPT_SETBITS, TRUE, &verbose,
31965819f75eSPeter Gill 	    'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
3197a6d42e7dSPeter Dunlap 	    NULL) != argc)
3198a6d42e7dSPeter Dunlap 		return (DCMD_USAGE);
3199a6d42e7dSPeter Dunlap 
3200a6d42e7dSPeter Dunlap 	if ((esi + portals + targets + servers) > 1) {
3201a6d42e7dSPeter Dunlap 		mdb_printf("Only one of e, p, s, and t must be provided");
3202a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
3203a6d42e7dSPeter Dunlap 	}
3204a6d42e7dSPeter Dunlap 
3205a6d42e7dSPeter Dunlap 	if ((esi | portals | targets | servers) == 0) {
3206a6d42e7dSPeter Dunlap 		mdb_printf("Exactly one of e, p, s, or t must be provided");
3207a6d42e7dSPeter Dunlap 		return (DCMD_ERR);
3208a6d42e7dSPeter Dunlap 	}
3209a6d42e7dSPeter Dunlap 
3210a6d42e7dSPeter Dunlap 	idc.idc_verbose = verbose;
32115819f75eSPeter Gill 	idc.u.child.idc_rc_audit = rc_audit;
3212a6d42e7dSPeter Dunlap 
3213a6d42e7dSPeter Dunlap 	if (esi) {
3214a6d42e7dSPeter Dunlap 		return (iscsi_isns_esi(&idc));
3215a6d42e7dSPeter Dunlap 	}
3216a6d42e7dSPeter Dunlap 
3217a6d42e7dSPeter Dunlap 	if (portals) {
3218a6d42e7dSPeter Dunlap 		return (iscsi_isns_portals(&idc));
3219a6d42e7dSPeter Dunlap 	}
3220a6d42e7dSPeter Dunlap 
3221a6d42e7dSPeter Dunlap 	if (servers) {
3222a6d42e7dSPeter Dunlap 		return (iscsi_isns_servers(&idc));
3223a6d42e7dSPeter Dunlap 	}
3224a6d42e7dSPeter Dunlap 
3225a6d42e7dSPeter Dunlap 	return (iscsi_isns_targets(&idc));
3226a6d42e7dSPeter Dunlap }
3227a6d42e7dSPeter Dunlap 
32285819f75eSPeter Gill static int
3229*b1da084bSToomas Soome iscsi_ini_sess_walk_init(mdb_walk_state_t *wsp)
3230*b1da084bSToomas Soome {
32315819f75eSPeter Gill 	if (wsp->walk_addr == NULL) {
32325819f75eSPeter Gill 		mdb_warn("<iscsi_sess_t addr>::walk iscsi_ini_sess");
32335819f75eSPeter Gill 		return (WALK_ERR);
32345819f75eSPeter Gill 	}
32355819f75eSPeter Gill 
32365819f75eSPeter Gill 	wsp->walk_data = mdb_alloc(sizeof (iscsi_sess_t), UM_SLEEP|UM_GC);
32375819f75eSPeter Gill 	if (!wsp->walk_data) {
32385819f75eSPeter Gill 		mdb_warn("iscsi_ini_sess walk failed");
32395819f75eSPeter Gill 		return (WALK_ERR);
32405819f75eSPeter Gill 	}
32415819f75eSPeter Gill 
32425819f75eSPeter Gill 	return (WALK_NEXT);
32435819f75eSPeter Gill }
32445819f75eSPeter Gill 
32455819f75eSPeter Gill static int
3246*b1da084bSToomas Soome iscsi_ini_sess_step(mdb_walk_state_t *wsp)
3247*b1da084bSToomas Soome {
32485819f75eSPeter Gill 	int status;
32495819f75eSPeter Gill 
32505819f75eSPeter Gill 	if (wsp->walk_addr == NULL) {
32515819f75eSPeter Gill 		return (WALK_DONE);
32525819f75eSPeter Gill 	}
32535819f75eSPeter Gill 
32545819f75eSPeter Gill 	if (mdb_vread(wsp->walk_data, sizeof (iscsi_sess_t), wsp->walk_addr)
32555819f75eSPeter Gill 	    != sizeof (iscsi_sess_t)) {
32565819f75eSPeter Gill 		mdb_warn("failed to read iscsi_sess_t at %p", wsp->walk_addr);
32575819f75eSPeter Gill 		return (WALK_DONE);
32585819f75eSPeter Gill 	}
32595819f75eSPeter Gill 
32605819f75eSPeter Gill 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
32615819f75eSPeter Gill 	    wsp->walk_cbdata);
32625819f75eSPeter Gill 
32635819f75eSPeter Gill 	wsp->walk_addr =
32645819f75eSPeter Gill 	    (uintptr_t)(((iscsi_sess_t *)wsp->walk_data)->sess_next);
32655819f75eSPeter Gill 
32665819f75eSPeter Gill 	return (status);
32675819f75eSPeter Gill }
32685819f75eSPeter Gill 
32695819f75eSPeter Gill static int
3270*b1da084bSToomas Soome iscsi_ini_conn_walk_init(mdb_walk_state_t *wsp)
3271*b1da084bSToomas Soome {
32725819f75eSPeter Gill 	if (wsp->walk_addr == NULL) {
32735819f75eSPeter Gill 		mdb_warn("<iscsi_conn_t addr>::walk iscsi_ini_conn");
32745819f75eSPeter Gill 		return (WALK_DONE);
32755819f75eSPeter Gill 	}
32765819f75eSPeter Gill 
32775819f75eSPeter Gill 	wsp->walk_data = mdb_alloc(sizeof (iscsi_conn_t), UM_SLEEP|UM_GC);
32785819f75eSPeter Gill 	if (!wsp->walk_data) {
32795819f75eSPeter Gill 		mdb_warn("iscsi_ini_conn walk failed");
32805819f75eSPeter Gill 		return (WALK_ERR);
32815819f75eSPeter Gill 	}
32825819f75eSPeter Gill 
32835819f75eSPeter Gill 	return (WALK_NEXT);
32845819f75eSPeter Gill }
32855819f75eSPeter Gill 
32865819f75eSPeter Gill static int
3287*b1da084bSToomas Soome iscsi_ini_conn_step(mdb_walk_state_t *wsp)
3288*b1da084bSToomas Soome {
32895819f75eSPeter Gill 	int status;
32905819f75eSPeter Gill 
32915819f75eSPeter Gill 	if (wsp->walk_addr == NULL) {
32925819f75eSPeter Gill 		return (WALK_DONE);
32935819f75eSPeter Gill 	}
32945819f75eSPeter Gill 
32955819f75eSPeter Gill 	if (mdb_vread(wsp->walk_data, sizeof (iscsi_conn_t), wsp->walk_addr)
32965819f75eSPeter Gill 	    != sizeof (iscsi_conn_t)) {
32975819f75eSPeter Gill 		mdb_warn("failed to read iscsi_conn_t at %p", wsp->walk_addr);
32985819f75eSPeter Gill 		return (WALK_DONE);
32995819f75eSPeter Gill 	}
33005819f75eSPeter Gill 
33015819f75eSPeter Gill 
33025819f75eSPeter Gill 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
33035819f75eSPeter Gill 	    wsp->walk_cbdata);
33045819f75eSPeter Gill 
33055819f75eSPeter Gill 	wsp->walk_addr =
33065819f75eSPeter Gill 	    (uintptr_t)(((iscsi_conn_t *)wsp->walk_data)->conn_next);
33075819f75eSPeter Gill 
33085819f75eSPeter Gill 	return (status);
33095819f75eSPeter Gill }
33105819f75eSPeter Gill 
33115819f75eSPeter Gill static int
3312*b1da084bSToomas Soome iscsi_ini_lun_walk_init(mdb_walk_state_t *wsp)
3313*b1da084bSToomas Soome {
33145819f75eSPeter Gill 	if (wsp->walk_addr == NULL) {
33155819f75eSPeter Gill 		mdb_warn("<iscsi_lun_t addr>::walk iscsi_ini_lun");
33165819f75eSPeter Gill 		return (WALK_DONE);
33175819f75eSPeter Gill 	}
33185819f75eSPeter Gill 
33195819f75eSPeter Gill 	wsp->walk_data = mdb_alloc(sizeof (iscsi_lun_t), UM_SLEEP|UM_GC);
33205819f75eSPeter Gill 	if (!wsp->walk_data) {
33215819f75eSPeter Gill 		return (WALK_ERR);
33225819f75eSPeter Gill 	}
33235819f75eSPeter Gill 
33245819f75eSPeter Gill 	return (WALK_NEXT);
33255819f75eSPeter Gill }
33265819f75eSPeter Gill 
33275819f75eSPeter Gill static int
3328*b1da084bSToomas Soome iscsi_ini_lun_step(mdb_walk_state_t *wsp)
3329*b1da084bSToomas Soome {
33305819f75eSPeter Gill 	int status;
33315819f75eSPeter Gill 
33325819f75eSPeter Gill 	if (wsp->walk_addr == NULL) {
33335819f75eSPeter Gill 		return (WALK_DONE);
33345819f75eSPeter Gill 	}
33355819f75eSPeter Gill 
33365819f75eSPeter Gill 	if (mdb_vread(wsp->walk_data, sizeof (iscsi_lun_t), wsp->walk_addr)
33375819f75eSPeter Gill 	    != sizeof (iscsi_lun_t)) {
33385819f75eSPeter Gill 		mdb_warn("failed to read iscsi_lun_t at %p", wsp->walk_addr);
33395819f75eSPeter Gill 		return (WALK_DONE);
33405819f75eSPeter Gill 	}
33415819f75eSPeter Gill 
33425819f75eSPeter Gill 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
33435819f75eSPeter Gill 	    wsp->walk_cbdata);
33445819f75eSPeter Gill 
33455819f75eSPeter Gill 	wsp->walk_addr =
33465819f75eSPeter Gill 	    (uintptr_t)(((iscsi_lun_t *)wsp->walk_data)->lun_next);
33475819f75eSPeter Gill 
33485819f75eSPeter Gill 	return (status);
33495819f75eSPeter Gill }
33505819f75eSPeter Gill 
33515819f75eSPeter Gill static int
3352*b1da084bSToomas Soome iscsi_ini_cmd_walk_init(mdb_walk_state_t *wsp)
3353*b1da084bSToomas Soome {
33545819f75eSPeter Gill 	if (wsp->walk_addr == NULL) {
33555819f75eSPeter Gill 		mdb_warn("<iscsi_cmd_t addr>::walk iscsi_ini_cmd");
33565819f75eSPeter Gill 		return (WALK_DONE);
33575819f75eSPeter Gill 	}
33585819f75eSPeter Gill 
33595819f75eSPeter Gill 	wsp->walk_data = mdb_alloc(sizeof (iscsi_cmd_t), UM_SLEEP|UM_GC);
33605819f75eSPeter Gill 	if (!wsp->walk_data) {
33615819f75eSPeter Gill 		return (WALK_ERR);
33625819f75eSPeter Gill 	}
33635819f75eSPeter Gill 
33645819f75eSPeter Gill 	return (WALK_NEXT);
33655819f75eSPeter Gill }
33665819f75eSPeter Gill 
33675819f75eSPeter Gill static int
3368*b1da084bSToomas Soome iscsi_ini_cmd_step(mdb_walk_state_t *wsp)
3369*b1da084bSToomas Soome {
33705819f75eSPeter Gill 	int status;
33715819f75eSPeter Gill 
33725819f75eSPeter Gill 	if (wsp->walk_addr == NULL) {
33735819f75eSPeter Gill 		return (WALK_DONE);
33745819f75eSPeter Gill 	}
33755819f75eSPeter Gill 
33765819f75eSPeter Gill 	if (mdb_vread(wsp->walk_data, sizeof (iscsi_cmd_t), wsp->walk_addr)
33775819f75eSPeter Gill 	    != sizeof (iscsi_cmd_t)) {
33785819f75eSPeter Gill 		mdb_warn("failed to read iscsi_cmd_t at %p", wsp->walk_addr);
33795819f75eSPeter Gill 		return (WALK_DONE);
33805819f75eSPeter Gill 	}
33815819f75eSPeter Gill 
33825819f75eSPeter Gill 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
33835819f75eSPeter Gill 	    wsp->walk_cbdata);
33845819f75eSPeter Gill 
33855819f75eSPeter Gill 	wsp->walk_addr =
33865819f75eSPeter Gill 	    (uintptr_t)(((iscsi_cmd_t *)wsp->walk_data)->cmd_next);
33875819f75eSPeter Gill 
33885819f75eSPeter Gill 	return (status);
33895819f75eSPeter Gill }
33905819f75eSPeter Gill 
33915819f75eSPeter Gill static int
3392*b1da084bSToomas Soome iscsi_ini_cmd_walk_cb(uintptr_t addr, const void *vcmd, void *vidc)
3393*b1da084bSToomas Soome {
33945819f75eSPeter Gill 	const iscsi_cmd_t	*cmd = vcmd;
33955819f75eSPeter Gill 	iscsi_dcmd_ctrl_t	*idc = vidc;
33965819f75eSPeter Gill 	int			rc;
33975819f75eSPeter Gill 
33985819f75eSPeter Gill 	if (cmd == NULL) {
33995819f75eSPeter Gill 		mdb_warn("list walk failed. Null cmd");
34005819f75eSPeter Gill 		return (WALK_ERR);
34015819f75eSPeter Gill 	}
34025819f75eSPeter Gill 
34035819f75eSPeter Gill 	rc = iscsi_print_ini_cmd(addr, cmd, idc);
34045819f75eSPeter Gill 
34055819f75eSPeter Gill 	return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
34065819f75eSPeter Gill }
34075819f75eSPeter Gill 
34085819f75eSPeter Gill static int
3409*b1da084bSToomas Soome iscsi_ini_hba_walk_init(mdb_walk_state_t *wsp)
3410*b1da084bSToomas Soome {
34115819f75eSPeter Gill 	uintptr_t state_addr, array_addr;
34125819f75eSPeter Gill 	int array_size;
34135819f75eSPeter Gill 	struct i_ddi_soft_state *ss;
34145819f75eSPeter Gill 	idm_hba_walk_info_t *hwi;
34155819f75eSPeter Gill 
34165819f75eSPeter Gill 
34175819f75eSPeter Gill 	hwi = (idm_hba_walk_info_t *)mdb_zalloc(
3418*b1da084bSToomas Soome 	    sizeof (idm_hba_walk_info_t), UM_SLEEP|UM_GC);
34195819f75eSPeter Gill 
34205819f75eSPeter Gill 	if (!hwi) {
34215819f75eSPeter Gill 		mdb_warn("unable to allocate storage for iscsi_ini_hba walk");
34225819f75eSPeter Gill 		return (WALK_ERR);
34235819f75eSPeter Gill 	}
34245819f75eSPeter Gill 
34255819f75eSPeter Gill 	if (wsp->walk_addr != NULL) {
34265819f75eSPeter Gill 		mdb_warn("iscsi_ini_hba only supports global walk");
34275819f75eSPeter Gill 		return (WALK_ERR);
34285819f75eSPeter Gill 	} else {
34295819f75eSPeter Gill 
34305819f75eSPeter Gill 		/*
34315819f75eSPeter Gill 		 * Read in the array and setup the walk struct.
34325819f75eSPeter Gill 		 */
34335819f75eSPeter Gill 		if (mdb_readvar(&state_addr, "iscsi_state") == -1) {
34345819f75eSPeter Gill 			mdb_warn("state variable iscsi_state not found.\n");
34355819f75eSPeter Gill 			mdb_warn("Is the driver loaded ?\n");
34365819f75eSPeter Gill 			return (WALK_ERR);
34375819f75eSPeter Gill 		}
34385819f75eSPeter Gill 
34395819f75eSPeter Gill 		ss = (struct i_ddi_soft_state *)mdb_alloc(sizeof (*ss),
34405819f75eSPeter Gill 		    UM_SLEEP|UM_GC);
34415819f75eSPeter Gill 		if (mdb_vread(ss, sizeof (*ss), state_addr) != sizeof (*ss)) {
34425819f75eSPeter Gill 			mdb_warn("Cannot read softstate struct "
34435819f75eSPeter Gill 			    "(Invalid pointer?).\n");
34445819f75eSPeter Gill 			return (WALK_ERR);
34455819f75eSPeter Gill 		}
34465819f75eSPeter Gill 
34475819f75eSPeter Gill 		/* Where to get the data */
34485819f75eSPeter Gill 		array_size = ss->n_items * (sizeof (void *));
34495819f75eSPeter Gill 		array_addr = (uintptr_t)ss->array;
34505819f75eSPeter Gill 
34515819f75eSPeter Gill 		/* Where to put the data */
34525819f75eSPeter Gill 		hwi->n_elements = ss->n_items;
34535819f75eSPeter Gill 		hwi->array = mdb_alloc(array_size, UM_SLEEP|UM_GC);
34545819f75eSPeter Gill 		if (!hwi->array) {
34555819f75eSPeter Gill 			mdb_warn("list walk failed");
34565819f75eSPeter Gill 			return (WALK_ERR);
34575819f75eSPeter Gill 		}
34585819f75eSPeter Gill 		if (mdb_vread(hwi->array, array_size, array_addr) !=
34595819f75eSPeter Gill 		    array_size) {
34605819f75eSPeter Gill 			mdb_warn("Corrupted softstate struct.\n");
34615819f75eSPeter Gill 			return (WALK_ERR);
34625819f75eSPeter Gill 		}
34635819f75eSPeter Gill 		hwi->cur_element = 0;
34645819f75eSPeter Gill 		wsp->walk_data =  hwi;
34655819f75eSPeter Gill 	}
34665819f75eSPeter Gill 
34675819f75eSPeter Gill 	return (WALK_NEXT);
34685819f75eSPeter Gill }
34695819f75eSPeter Gill 
34705819f75eSPeter Gill static int
3471*b1da084bSToomas Soome iscsi_ini_hba_step(mdb_walk_state_t *wsp)
3472*b1da084bSToomas Soome {
34735819f75eSPeter Gill 	int status;
34745819f75eSPeter Gill 	idm_hba_walk_info_t *hwi = (idm_hba_walk_info_t *)wsp->walk_data;
34755819f75eSPeter Gill 
34765819f75eSPeter Gill 	for (; hwi->cur_element < hwi->n_elements; hwi->cur_element++) {
34775819f75eSPeter Gill 		if (hwi->array[hwi->cur_element] != NULL) {
34785819f75eSPeter Gill 			break;
34795819f75eSPeter Gill 		}
34805819f75eSPeter Gill 	}
34815819f75eSPeter Gill 	if (hwi->cur_element >= hwi->n_elements) {
34825819f75eSPeter Gill 		return (WALK_DONE);
34835819f75eSPeter Gill 	}
34845819f75eSPeter Gill 
34855819f75eSPeter Gill 	hwi->data = (iscsi_hba_t *)mdb_alloc(sizeof (iscsi_hba_t),
34865819f75eSPeter Gill 	    UM_SLEEP|UM_GC);
34875819f75eSPeter Gill 	if (mdb_vread(hwi->data, sizeof (iscsi_hba_t),
34885819f75eSPeter Gill 	    (uintptr_t)hwi->array[hwi->cur_element]) != sizeof (iscsi_hba_t)) {
34895819f75eSPeter Gill 		mdb_warn("failed to read iscsi_sess_t at %p", wsp->walk_addr);
34905819f75eSPeter Gill 		return (WALK_DONE);
34915819f75eSPeter Gill 	}
34925819f75eSPeter Gill 
34935819f75eSPeter Gill 
34945819f75eSPeter Gill 	status = wsp->walk_callback((uintptr_t)hwi->array[hwi->cur_element],
34955819f75eSPeter Gill 	    hwi->data, wsp->walk_cbdata);
34965819f75eSPeter Gill 
34975819f75eSPeter Gill 	/* Increment cur_element for next iteration */
34985819f75eSPeter Gill 	hwi->cur_element++;
34995819f75eSPeter Gill 
35005819f75eSPeter Gill 	return (status);
35015819f75eSPeter Gill }
35025819f75eSPeter Gill 
3503a6d42e7dSPeter Dunlap /*
350430e7468fSPeter Dunlap  * iscsi_inet_ntop -- Convert an IPv4 or IPv6 address in binary form into
3505a6d42e7dSPeter Dunlap  * printable form, and return a pointer to that string. Caller should
3506a6d42e7dSPeter Dunlap  * provide a buffer of correct length to store string into.
3507a6d42e7dSPeter Dunlap  * Note: this routine is kernel version of inet_ntop. It has similar
350830e7468fSPeter Dunlap  * format as iscsi_inet_ntop() defined in rfc2553. But it does not do
3509a6d42e7dSPeter Dunlap  * error handling operations exactly as rfc2553 defines. This function
3510a6d42e7dSPeter Dunlap  * is used by kernel inet directory routines only for debugging.
351130e7468fSPeter Dunlap  * This iscsi_inet_ntop() function, does not return NULL if third argument
3512a6d42e7dSPeter Dunlap  * is NULL. The reason is simple that we don't want kernel to panic
3513a6d42e7dSPeter Dunlap  * as the output of this function is directly fed to ip<n>dbg macro.
3514a6d42e7dSPeter Dunlap  * Instead it uses a local buffer for destination address for
3515a6d42e7dSPeter Dunlap  * those calls which purposely pass NULL ptr for the destination
3516a6d42e7dSPeter Dunlap  * buffer. This function is thread-safe when the caller passes a non-
3517a6d42e7dSPeter Dunlap  * null buffer with the third argument.
3518a6d42e7dSPeter Dunlap  */
3519a6d42e7dSPeter Dunlap /* ARGSUSED */
3520a6d42e7dSPeter Dunlap 
3521a6d42e7dSPeter Dunlap #define	OK_16PTR(p)	(!((uintptr_t)(p) & 0x1))
3522a6d42e7dSPeter Dunlap #if defined(__x86)
3523a6d42e7dSPeter Dunlap #define	OK_32PTR(p)	OK_16PTR(p)
3524a6d42e7dSPeter Dunlap #else
3525a6d42e7dSPeter Dunlap #define	OK_32PTR(p)	(!((uintptr_t)(p) & 0x3))
3526a6d42e7dSPeter Dunlap #endif
3527a6d42e7dSPeter Dunlap 
3528a6d42e7dSPeter Dunlap char *
352930e7468fSPeter Dunlap iscsi_inet_ntop(int af, const void *addr, char *buf, int addrlen)
3530a6d42e7dSPeter Dunlap {
3531a6d42e7dSPeter Dunlap 	static char local_buf[PORTAL_STR_LEN];
3532a6d42e7dSPeter Dunlap 	static char *err_buf1 = "<badaddr>";
3533a6d42e7dSPeter Dunlap 	static char *err_buf2 = "<badfamily>";
3534a6d42e7dSPeter Dunlap 	in6_addr_t	*v6addr;
3535a6d42e7dSPeter Dunlap 	uchar_t		*v4addr;
3536a6d42e7dSPeter Dunlap 	char		*caddr;
3537a6d42e7dSPeter Dunlap 
3538a6d42e7dSPeter Dunlap 	/*
353930e7468fSPeter Dunlap 	 * We don't allow thread unsafe iscsi_inet_ntop calls, they
3540a6d42e7dSPeter Dunlap 	 * must pass a non-null buffer pointer. For DEBUG mode
3541a6d42e7dSPeter Dunlap 	 * we use the ASSERT() and for non-debug kernel it will
3542a6d42e7dSPeter Dunlap 	 * silently allow it for now. Someday we should remove
3543a6d42e7dSPeter Dunlap 	 * the static buffer from this function.
3544a6d42e7dSPeter Dunlap 	 */
3545a6d42e7dSPeter Dunlap 
3546a6d42e7dSPeter Dunlap 	ASSERT(buf != NULL);
3547a6d42e7dSPeter Dunlap 	if (buf == NULL)
3548a6d42e7dSPeter Dunlap 		buf = local_buf;
3549a6d42e7dSPeter Dunlap 	buf[0] = '\0';
3550a6d42e7dSPeter Dunlap 
3551a6d42e7dSPeter Dunlap 	/* Let user know politely not to send NULL or unaligned addr */
3552a6d42e7dSPeter Dunlap 	if (addr == NULL || !(OK_32PTR(addr))) {
3553a6d42e7dSPeter Dunlap 		return (err_buf1);
3554a6d42e7dSPeter Dunlap 	}
3555a6d42e7dSPeter Dunlap 
3556a6d42e7dSPeter Dunlap 
3557a6d42e7dSPeter Dunlap #define	UC(b)	(((int)b) & 0xff)
3558a6d42e7dSPeter Dunlap 	switch (af) {
3559a6d42e7dSPeter Dunlap 	case AF_INET:
3560a6d42e7dSPeter Dunlap 		ASSERT(addrlen >= INET_ADDRSTRLEN);
3561a6d42e7dSPeter Dunlap 		v4addr = (uchar_t *)addr;
3562a6d42e7dSPeter Dunlap 		(void) mdb_snprintf(buf, INET6_ADDRSTRLEN,
3563a6d42e7dSPeter Dunlap 		    "%03d.%03d.%03d.%03d",
3564a6d42e7dSPeter Dunlap 		    UC(v4addr[0]), UC(v4addr[1]), UC(v4addr[2]), UC(v4addr[3]));
3565a6d42e7dSPeter Dunlap 		return (buf);
3566a6d42e7dSPeter Dunlap 
3567a6d42e7dSPeter Dunlap 	case AF_INET6:
3568a6d42e7dSPeter Dunlap 		ASSERT(addrlen >= INET6_ADDRSTRLEN);
3569a6d42e7dSPeter Dunlap 		v6addr = (in6_addr_t *)addr;
3570a6d42e7dSPeter Dunlap 		if (IN6_IS_ADDR_V4MAPPED(v6addr)) {
3571a6d42e7dSPeter Dunlap 			caddr = (char *)addr;
3572a6d42e7dSPeter Dunlap 			(void) mdb_snprintf(buf, INET6_ADDRSTRLEN,
3573a6d42e7dSPeter Dunlap 			    "::ffff:%d.%d.%d.%d",
3574a6d42e7dSPeter Dunlap 			    UC(caddr[12]), UC(caddr[13]),
3575a6d42e7dSPeter Dunlap 			    UC(caddr[14]), UC(caddr[15]));
3576a6d42e7dSPeter Dunlap 		} else if (IN6_IS_ADDR_V4COMPAT(v6addr)) {
3577a6d42e7dSPeter Dunlap 			caddr = (char *)addr;
3578a6d42e7dSPeter Dunlap 			(void) mdb_snprintf(buf, INET6_ADDRSTRLEN,
3579a6d42e7dSPeter Dunlap 			    "::%d.%d.%d.%d",
3580a6d42e7dSPeter Dunlap 			    UC(caddr[12]), UC(caddr[13]), UC(caddr[14]),
3581a6d42e7dSPeter Dunlap 			    UC(caddr[15]));
3582a6d42e7dSPeter Dunlap 		} else if (IN6_IS_ADDR_UNSPECIFIED(v6addr)) {
3583a6d42e7dSPeter Dunlap 			(void) mdb_snprintf(buf, INET6_ADDRSTRLEN, "::");
3584a6d42e7dSPeter Dunlap 		} else {
3585a6d42e7dSPeter Dunlap 			convert2ascii(buf, v6addr);
3586a6d42e7dSPeter Dunlap 		}
3587a6d42e7dSPeter Dunlap 		return (buf);
3588a6d42e7dSPeter Dunlap 
3589a6d42e7dSPeter Dunlap 	default:
3590a6d42e7dSPeter Dunlap 		return (err_buf2);
3591a6d42e7dSPeter Dunlap 	}
3592a6d42e7dSPeter Dunlap #undef UC
3593a6d42e7dSPeter Dunlap }
3594a6d42e7dSPeter Dunlap 
3595a6d42e7dSPeter Dunlap /*
3596a6d42e7dSPeter Dunlap  *
3597a6d42e7dSPeter Dunlap  * v6 formats supported
3598a6d42e7dSPeter Dunlap  * General format xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx
3599a6d42e7dSPeter Dunlap  * The short hand notation :: is used for COMPAT addr
3600a6d42e7dSPeter Dunlap  * Other forms : fe80::xxxx:xxxx:xxxx:xxxx
3601a6d42e7dSPeter Dunlap  */
3602a6d42e7dSPeter Dunlap static void
3603a6d42e7dSPeter Dunlap convert2ascii(char *buf, const in6_addr_t *addr)
3604a6d42e7dSPeter Dunlap {
3605a6d42e7dSPeter Dunlap 	int		hexdigits;
3606a6d42e7dSPeter Dunlap 	int		head_zero = 0;
3607a6d42e7dSPeter Dunlap 	int		tail_zero = 0;
3608a6d42e7dSPeter Dunlap 	/* tempbuf must be big enough to hold ffff:\0 */
3609a6d42e7dSPeter Dunlap 	char		tempbuf[6];
3610a6d42e7dSPeter Dunlap 	char		*ptr;
3611a6d42e7dSPeter Dunlap 	uint16_t	out_addr_component;
3612a6d42e7dSPeter Dunlap 	uint16_t	*addr_component;
3613a6d42e7dSPeter Dunlap 	size_t		len;
3614a6d42e7dSPeter Dunlap 	boolean_t	first = B_FALSE;
3615a6d42e7dSPeter Dunlap 	boolean_t	med_zero = B_FALSE;
3616a6d42e7dSPeter Dunlap 	boolean_t	end_zero = B_FALSE;
3617a6d42e7dSPeter Dunlap 
3618a6d42e7dSPeter Dunlap 	addr_component = (uint16_t *)addr;
3619a6d42e7dSPeter Dunlap 	ptr = buf;
3620a6d42e7dSPeter Dunlap 
3621a6d42e7dSPeter Dunlap 	/* First count if trailing zeroes higher in number */
3622a6d42e7dSPeter Dunlap 	for (hexdigits = 0; hexdigits < 8; hexdigits++) {
3623a6d42e7dSPeter Dunlap 		if (*addr_component == 0) {
3624a6d42e7dSPeter Dunlap 			if (hexdigits < 4)
3625a6d42e7dSPeter Dunlap 				head_zero++;
3626a6d42e7dSPeter Dunlap 			else
3627a6d42e7dSPeter Dunlap 				tail_zero++;
3628a6d42e7dSPeter Dunlap 		}
3629a6d42e7dSPeter Dunlap 		addr_component++;
3630a6d42e7dSPeter Dunlap 	}
3631a6d42e7dSPeter Dunlap 	addr_component = (uint16_t *)addr;
3632a6d42e7dSPeter Dunlap 	if (tail_zero > head_zero && (head_zero + tail_zero) != 7)
3633a6d42e7dSPeter Dunlap 		end_zero = B_TRUE;
3634a6d42e7dSPeter Dunlap 
3635a6d42e7dSPeter Dunlap 	for (hexdigits = 0; hexdigits < 8; hexdigits++) {
3636a6d42e7dSPeter Dunlap 
3637a6d42e7dSPeter Dunlap 		/* if entry is a 0 */
3638a6d42e7dSPeter Dunlap 
3639a6d42e7dSPeter Dunlap 		if (*addr_component == 0) {
3640a6d42e7dSPeter Dunlap 			if (!first && *(addr_component + 1) == 0) {
3641a6d42e7dSPeter Dunlap 				if (end_zero && (hexdigits < 4)) {
3642a6d42e7dSPeter Dunlap 					*ptr++ = '0';
3643a6d42e7dSPeter Dunlap 					*ptr++ = ':';
3644a6d42e7dSPeter Dunlap 				} else {
3645a6d42e7dSPeter Dunlap 					/*
3646a6d42e7dSPeter Dunlap 					 * address starts with 0s ..
3647a6d42e7dSPeter Dunlap 					 * stick in leading ':' of pair
3648a6d42e7dSPeter Dunlap 					 */
3649a6d42e7dSPeter Dunlap 					if (hexdigits == 0)
3650a6d42e7dSPeter Dunlap 						*ptr++ = ':';
3651a6d42e7dSPeter Dunlap 					/* add another */
3652a6d42e7dSPeter Dunlap 					*ptr++ = ':';
3653a6d42e7dSPeter Dunlap 					first = B_TRUE;
3654a6d42e7dSPeter Dunlap 					med_zero = B_TRUE;
3655a6d42e7dSPeter Dunlap 				}
3656a6d42e7dSPeter Dunlap 			} else if (first && med_zero) {
3657a6d42e7dSPeter Dunlap 				if (hexdigits == 7)
3658a6d42e7dSPeter Dunlap 					*ptr++ = ':';
3659a6d42e7dSPeter Dunlap 				addr_component++;
3660a6d42e7dSPeter Dunlap 				continue;
3661a6d42e7dSPeter Dunlap 			} else {
3662a6d42e7dSPeter Dunlap 				*ptr++ = '0';
3663a6d42e7dSPeter Dunlap 				*ptr++ = ':';
3664a6d42e7dSPeter Dunlap 			}
3665a6d42e7dSPeter Dunlap 			addr_component++;
3666a6d42e7dSPeter Dunlap 			continue;
3667a6d42e7dSPeter Dunlap 		}
3668a6d42e7dSPeter Dunlap 		if (med_zero)
3669a6d42e7dSPeter Dunlap 			med_zero = B_FALSE;
3670a6d42e7dSPeter Dunlap 
3671a6d42e7dSPeter Dunlap 		tempbuf[0] = '\0';
3672a6d42e7dSPeter Dunlap 		mdb_nhconvert(&out_addr_component, addr_component,
3673a6d42e7dSPeter Dunlap 		    sizeof (uint16_t));
3674a6d42e7dSPeter Dunlap 		(void) mdb_snprintf(tempbuf, 6, "%x:", out_addr_component);
3675a6d42e7dSPeter Dunlap 		len = strlen(tempbuf);
3676a6d42e7dSPeter Dunlap 		bcopy(tempbuf, ptr, len);
3677a6d42e7dSPeter Dunlap 		ptr = ptr + len;
3678a6d42e7dSPeter Dunlap 		addr_component++;
3679a6d42e7dSPeter Dunlap 	}
3680a6d42e7dSPeter Dunlap 	*--ptr = '\0';
3681a6d42e7dSPeter Dunlap }
3682a6d42e7dSPeter Dunlap 
3683a6d42e7dSPeter Dunlap /*
3684a6d42e7dSPeter Dunlap  * MDB module linkage information:
3685a6d42e7dSPeter Dunlap  *
3686a6d42e7dSPeter Dunlap  * We declare a list of structures describing our dcmds, a list of structures
3687a6d42e7dSPeter Dunlap  * describing our walkers and a function named _mdb_init to return a pointer
3688a6d42e7dSPeter Dunlap  * to our module information.
3689a6d42e7dSPeter Dunlap  */
3690a6d42e7dSPeter Dunlap static const mdb_dcmd_t dcmds[] = {
36915819f75eSPeter Gill 	{   "iscsi_tgt", "[-agscptbSRv]",
3692a6d42e7dSPeter Dunlap 	    "iSCSI target information", iscsi_tgt },
36935819f75eSPeter Gill 	{   "iscsi_tpgt", "[-R]",
36945819f75eSPeter Gill 	    "iSCSI target portal group tag information", iscsi_tpgt },
36955819f75eSPeter Gill 	{   "iscsi_tpg", "[-R]",
3696a6d42e7dSPeter Dunlap 	    "iSCSI target portal group information", iscsi_tpg },
36975819f75eSPeter Gill 	{   "iscsi_sess", "[-ablmtvcSRIT]",
3698a6d42e7dSPeter Dunlap 	    "iSCSI session information", iscsi_sess },
36995819f75eSPeter Gill 	{   "iscsi_conn", "[-abmtvSRIT]",
3700a6d42e7dSPeter Dunlap 	    "iSCSI connection information", iscsi_conn },
3701a6d42e7dSPeter Dunlap 	{   "iscsi_task", "[-bSRv]",
3702a6d42e7dSPeter Dunlap 	    "iSCSI task information", iscsi_task },
3703a6d42e7dSPeter Dunlap 	{   "iscsi_refcnt", "",
37045819f75eSPeter Gill 	    "print audit informtion for idm_refcnt_t", iscsi_refcnt },
3705a6d42e7dSPeter Dunlap 	{   "iscsi_states", "",
37065819f75eSPeter Gill 	    "dump events and state transitions recorded in an\t"
3707a6d42e7dSPeter Dunlap 	    "\t\tidm_sm_audit_t structure", iscsi_states },
37085819f75eSPeter Gill 	{   "iscsi_isns", "[-epstvR]",
37095819f75eSPeter Gill 	    "print iscsit iSNS information", iscsi_isns, iscsi_isns_help },
37105819f75eSPeter Gill 	{   "iscsi_svc", "[-vR]",
37115819f75eSPeter Gill 	    "iSCSI service information", iscsi_svc },
37125819f75eSPeter Gill 	{   "iscsi_portal", "[-R]",
37135819f75eSPeter Gill 	    "iSCSI portal information", iscsi_portal },
37145819f75eSPeter Gill 	{   "iscsi_cmd", "[-S]",
37155819f75eSPeter Gill 	    "iSCSI command information (initiator only)", iscsi_cmd },
3716a6d42e7dSPeter Dunlap 	{ NULL }
3717a6d42e7dSPeter Dunlap };
3718a6d42e7dSPeter Dunlap 
3719a6d42e7dSPeter Dunlap /*
37205819f75eSPeter Gill  * Basic walkers for the initiator linked lists
3721a6d42e7dSPeter Dunlap  */
37225819f75eSPeter Gill static const mdb_walker_t walkers[] = {
37235819f75eSPeter Gill 	{ "iscsi_ini_hba", "global walk of the initiator iscsi_hba_t "
37245819f75eSPeter Gill 	    "list", iscsi_ini_hba_walk_init, iscsi_ini_hba_step, NULL},
37255819f75eSPeter Gill 	{ "iscsi_ini_sess", "walk list of initiator iscsi_sess_t structures",
37265819f75eSPeter Gill 	    iscsi_ini_sess_walk_init, iscsi_ini_sess_step, NULL },
37275819f75eSPeter Gill 	{ "iscsi_ini_conn", "walk list of initiator iscsi_conn_t structures",
37285819f75eSPeter Gill 	    iscsi_ini_conn_walk_init, iscsi_ini_conn_step, NULL },
37295819f75eSPeter Gill 	{ "iscsi_ini_lun", "walk list of initiator iscsi_lun_t structures",
37305819f75eSPeter Gill 	    iscsi_ini_lun_walk_init, iscsi_ini_lun_step, NULL },
37315819f75eSPeter Gill 	{ "iscsi_ini_cmd", "walk list of initiator iscsi_cmd_t structures",
37325819f75eSPeter Gill 	    iscsi_ini_cmd_walk_init, iscsi_ini_cmd_step, NULL },
37335819f75eSPeter Gill 	{ NULL }
37345819f75eSPeter Gill };
3735a6d42e7dSPeter Dunlap 
3736a6d42e7dSPeter Dunlap static const mdb_modinfo_t modinfo = {
37375819f75eSPeter Gill 	MDB_API_VERSION, dcmds, walkers
3738a6d42e7dSPeter Dunlap };
3739a6d42e7dSPeter Dunlap 
3740a6d42e7dSPeter Dunlap const mdb_modinfo_t *
3741a6d42e7dSPeter Dunlap _mdb_init(void)
3742a6d42e7dSPeter Dunlap {
3743a6d42e7dSPeter Dunlap 	return (&modinfo);
3744a6d42e7dSPeter Dunlap }
3745