?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / mdb / common / modules / idm / idm.c
blobc465a9b8fb01e81447e4f4a8d1e420bbaa0338f2
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 #include <mdb/mdb_modapi.h>
26 #include <mdb/mdb_ks.h>
27
28 #include <sys/cpuvar.h>
29 #include <sys/conf.h>
30 #include <sys/file.h>
31 #include <sys/types.h>
32 #include <sys/taskq.h>
33 #include <sys/sysmacros.h>
34 #include <sys/socket.h> /* networking stuff */
35 #include <sys/strsubr.h> /* networking stuff */
36 #include <sys/nvpair.h>
37 #include <sys/sunldi.h>
38 #include <sys/stmf.h>
39 #include <sys/stmf_ioctl.h>
40 #include <sys/portif.h>
41
42 #define IDM_CONN_SM_STRINGS
43 #define IDM_TASK_SM_STRINGS
44 #define ISCSIT_TGT_SM_STRINGS
45 #define ISCSIT_SESS_SM_STRINGS
46 #define ISCSIT_LOGIN_SM_STRINGS
47 #define ISCSI_SESS_SM_STRINGS
48 #define ISCSI_CMD_SM_STRINGS
49 #define ISCSI_ICS_NAMES
50 #define ISCSI_LOGIN_STATE_NAMES
51 #define IDM_CN_NOTIFY_STRINGS
52 #include <sys/idm/idm.h>
53 #include <iscsi.h>
54 #include <iscsit.h>
55 #include <iscsit_isns.h>
56 #include <sys/ib/clients/iser/iser.h>
57
58 /*
59 * We want to be able to print multiple levels of object hierarchy with a
60 * single dcmd information, and preferably also exclude intermediate
61 * levels if desired. For example some of the target objects have the
62 * following relationship:
63 *
64 * target --> session --> connection --> task
65 *
66 * The session dcmd should allow the printing of all associated tasks for the
67 * sessions without printing all the associated connections. To accomplish
68 * this the following structure contains a bit for each object type. Dcmds
69 * should invoke the functions for child objects if any bits are set
70 * in iscsi_dcmd_ctrl_t but the functions for the child object should only
71 * print data if their associated bit is set. Each object type should print
72 * a header for its first occurrence or if it is being printed as a child
73 * object for the first occurrence under each parent. For the model to follow
74 * see how idc->idc_header is handled in iscsi_sess_impl.
75 *
76 * Each dcmd should provide an external interface with the standard MDB API
77 * and an internal interface that accepts iscsi_dcmd_ctrl_t. To display
78 * child objects the dcmd calls the internal interface for the child object
79 * directly. Dcmds invoked from the command line will, of course, call the
80 * external interface. See iscsi_conn() and iscsi_conn_impl().
81 */
82
83 typedef struct {
84 union {
85 uint32_t idc_children;
86 struct {
87 uint32_t idc_tgt:1,
88 idc_tpg:1,
89 idc_tpgt:1,
90 idc_portal:1,
91 idc_sess:1,
92 idc_conn:1,
93 idc_svc:1,
94 idc_print_ip:1,
95 idc_task:1,
96 idc_buffer:1,
97 idc_states:1,
98 idc_rc_audit:1,
99 idc_lun:1,
100 idc_hba:1,
101 idc_cmd:1;
102 } child;
103 } u;
104 boolean_t idc_ini;
105 boolean_t idc_tgt;
106 boolean_t idc_verbose;
107 boolean_t idc_header;
108 /*
109 * Our connection dcmd code works off the global connection lists
110 * in IDM since we want to know about connections even when they
111 * have not progressed to the point that they have an associated
112 * session. If we use "::iscsi_sess [-c]" then we only want to
113 * see connections associated with particular session. To avoid
114 * writing a separate set of code to print session-specific connection
115 * the session code should set the sessions kernel address in the
116 * following field. The connection code will then only print
117 * connections that match.
118 */
119 uintptr_t idc_assoc_session;
120 } iscsi_dcmd_ctrl_t;
121
122 typedef struct idm_hba_walk_info {
123 void **array;
124 int n_elements;
125 int cur_element;
126 void *data;
127 } idm_hba_walk_info_t;
128
129 static int iscsi_walk_all_sess(iscsi_dcmd_ctrl_t *idc);
130 static int iscsi_walk_all_conn(iscsi_dcmd_ctrl_t *idc);
131 static int iscsi_tgt_walk_cb(uintptr_t addr, const void *list_walker_data,
132 void *idc_void);
133 static int iscsi_tpgt_walk_cb(uintptr_t addr, const void *list_walker_data,
134 void *idc_void);
135 static int iscsi_tpg_walk_cb(uintptr_t addr, const void *list_walker_data,
136 void *idc_void);
137 static int iscsi_portal_walk_cb(uintptr_t addr, const void *list_walker_data,
138 void *idc_void);
139 static int iscsi_sess_walk_cb(uintptr_t addr, const void *list_walker_data,
140 void *idc_void);
141 static int iscsi_conn_walk_cb(uintptr_t addr, const void *list_walker_data,
142 void *idc_void);
143 static int iscsi_buffer_walk_cb(uintptr_t addr, const void *list_walker_data,
144 void *idc_void);
145 static int iscsi_svc_walk_cb(uintptr_t addr, const void *list_walker_data,
146 void *idc_void);
147 static int iscsi_ini_hba_walk_cb(uintptr_t addr, const void *vhba,
148 void *idc_void);
149 static int iscsi_ini_sess_walk_cb(uintptr_t addr, const void *vsess,
150 void *idc);
151 static int iscsi_ini_conn_walk_cb(uintptr_t addr, const void *vconn,
152 void *idc_void);
153 static int iscsi_ini_lun_walk_cb(uintptr_t addr, const void *vlun,
154 void *idc_void);
155 static int iscsi_ini_cmd_walk_cb(uintptr_t addr, const void *vcmd,
156 void *idc);
157 static int iscsi_tgt_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
158 static int iscsi_tpgt_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
159 static int iscsi_tpg_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
160 static int iscsi_portal_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
161 static int iscsi_sess_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
162 static int iscsi_conn_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
163 static void iscsi_print_iscsit_conn_data(idm_conn_t *ict);
164 static void iscsi_print_ini_conn_data(idm_conn_t *ict);
165 static void iscsi_print_idm_conn_data(idm_conn_t *ict);
166 static int iscsi_task_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
167 static void iscsi_print_iscsit_task_data(idm_task_t *idt);
168 static int iscsi_buffer_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
169 static idm_conn_type_t idm_conn_type(uintptr_t addr);
170 static int iscsi_i_task_impl(idm_task_t *idt, uintptr_t addr,
171 iscsi_dcmd_ctrl_t *idc);
172 static int iscsi_refcnt_impl(uintptr_t addr);
173 static int iscsi_sm_audit_impl(uintptr_t addr);
174 static int iscsi_isns(uintptr_t addr, uint_t flags, int argc,
175 const mdb_arg_t *argv);
176 static int iscsi_svc_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
177 static int iscsi_ini_hba_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc);
178 static int iscsi_print_ini_sess(uintptr_t addr, iscsi_sess_t *sess,
179 iscsi_dcmd_ctrl_t *idc);
180 static int iscsi_print_ini_lun(uintptr_t addr, const iscsi_lun_t *lun,
181 iscsi_dcmd_ctrl_t *idc);
182 static int iscsi_print_ini_cmd(uintptr_t addr, const iscsi_cmd_t *cmd,
183 iscsi_dcmd_ctrl_t *idc);
184 static int iscsi_ini_sess_walk_init(mdb_walk_state_t *wsp);
185 static int iscsi_ini_sess_step(mdb_walk_state_t *wsp);
186 static int iscsi_ini_conn_walk_init(mdb_walk_state_t *wsp);
187 static int iscsi_ini_conn_step(mdb_walk_state_t *wsp);
188 static int iscsi_ini_lun_walk_init(mdb_walk_state_t *wsp);
189 static int iscsi_ini_lun_step(mdb_walk_state_t *wsp);
190 static int iscsi_ini_cmd_walk_init(mdb_walk_state_t *wsp);
191 static int iscsi_ini_cmd_step(mdb_walk_state_t *wsp);
192 static const char *iscsi_idm_conn_event(unsigned int event);
193 static const char *iscsi_iscsit_tgt_event(unsigned int event);
194 static const char *iscsi_iscsit_sess_event(unsigned int event);
195 static const char *iscsi_iscsit_login_event(unsigned int event);
196 static const char *iscsi_iscsi_cmd_event(unsigned int event);
197 static const char *iscsi_iscsi_sess_event(unsigned int event);
198 static const char *iscsi_idm_conn_state(unsigned int state);
199 static const char *iscsi_idm_task_state(unsigned int state);
200 static const char *iscsi_iscsit_tgt_state(unsigned int state);
201 static const char *iscsi_iscsit_sess_state(unsigned int state);
202 static const char *iscsi_iscsit_login_state(unsigned int state);
203 static const char *iscsi_iscsi_cmd_state(unsigned int state);
204 static const char *iscsi_iscsi_sess_state(unsigned int state);
205 static const char *iscsi_iscsi_conn_state(unsigned int state);
206 static const char *iscsi_iscsi_conn_event(unsigned int event);
207 static const char *iscsi_iscsi_login_state(unsigned int state);
208
209 static void iscsi_format_timestamp(char *ts_str, int strlen,
210 timespec_t *ts);
211 static char *iscsi_inet_ntop(int af, const void *addr, char *buf, int addrlen);
212 static void convert2ascii(char *, const in6_addr_t *);
213 static int sa_to_str(struct sockaddr_storage *sa, char *addr);
214 static int iscsi_isns_esi_cb(uintptr_t addr, const void *walker_data,
215 void *data);
216 static int iscsi_isns_portal_cb(uintptr_t addr, const void *walker_data,
217 void *data);
218
219 #define PORTAL_STR_LEN (INET6_ADDRSTRLEN + 7)
220
221 /*
222 * ::iscsi_tgt [-scatgpbSRv]
223 *
224 * iscsi_tgt - Print out information associated with an iscsit target instance
225 *
226 * s Print associated session information
227 * c Print associated connection information
228 * a Print IP addresses with connection information
229 * t Print associated task information
230 * g Print associated TPG information
231 * p Print portals with TPG information
232 * b Print associated buffer information
233 * S Print recent state events and transitions
234 * R Print reference count audit data
235 * v Verbose output about the connection
236 */
237 /*ARGSUSED*/
238 static int
239 iscsi_tgt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
240 {
241 iscsi_dcmd_ctrl_t idc;
242 int buffer = 0, task = 0, print_ip = 0;
243 int tpgt = 0, conn = 0, sess = 0, portal = 0;
244 int states = 0, rc_audit = 0;
245 uintptr_t iscsit_global_addr, avl_addr, list_addr;
246 GElf_Sym sym;
247
248 bzero(&idc, sizeof (idc));
249 if (mdb_getopts(argc, argv,
250 'a', MDB_OPT_SETBITS, TRUE, &print_ip,
251 'g', MDB_OPT_SETBITS, TRUE, &tpgt,
252 's', MDB_OPT_SETBITS, TRUE, &sess,
253 'c', MDB_OPT_SETBITS, TRUE, &conn,
254 't', MDB_OPT_SETBITS, TRUE, &task,
255 'b', MDB_OPT_SETBITS, TRUE, &buffer,
256 'p', MDB_OPT_SETBITS, TRUE, &portal,
257 'S', MDB_OPT_SETBITS, TRUE, &states,
258 'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
259 'v', MDB_OPT_SETBITS, TRUE, &idc.idc_verbose,
260 NULL) != argc)
261 return (DCMD_USAGE);
262
263 idc.u.child.idc_tgt = 1;
264 idc.u.child.idc_print_ip = print_ip;
265 idc.u.child.idc_tpgt = tpgt;
266 idc.u.child.idc_portal = portal;
267 idc.u.child.idc_sess = sess;
268 idc.u.child.idc_conn = conn;
269 idc.u.child.idc_task = task;
270 idc.u.child.idc_buffer = buffer;
271 idc.u.child.idc_states = states;
272 idc.u.child.idc_rc_audit = rc_audit;
273
274 if (DCMD_HDRSPEC(flags))
275 idc.idc_header = 1;
276
277 /*
278 * If no address was specified on the command line, we
279 * print out all tgtions
280 */
281 if (!(flags & DCMD_ADDRSPEC)) {
282 if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
283 mdb_warn("failed to find symbol 'iscsit_global'");
284 return (DCMD_ERR);
285 }
286 iscsit_global_addr = (uintptr_t)sym.st_value;
287 avl_addr = iscsit_global_addr +
288 offsetof(iscsit_global_t, global_target_list);
289 if (mdb_pwalk("avl", iscsi_tgt_walk_cb, &idc, avl_addr) == -1) {
290 mdb_warn("avl walk failed for global target tree");
291 return (DCMD_ERR);
292 }
293 list_addr = iscsit_global_addr +
294 offsetof(iscsit_global_t, global_deleted_target_list);
295 if (mdb_pwalk("list", iscsi_tgt_walk_cb,
296 &idc, list_addr) == -1) {
297 mdb_warn("list walk failed for deleted target list");
298 return (DCMD_ERR);
299 }
300 return (DCMD_OK);
301 }
302 return (iscsi_tgt_impl(addr, &idc));
303 }
304
305 static int
306 iscsi_tpg(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
307 {
308 iscsi_dcmd_ctrl_t idc;
309 uintptr_t iscsit_global_addr, avl_addr;
310 GElf_Sym sym;
311 int rc_audit = 0;
312
313 bzero(&idc, sizeof (idc));
314 if (mdb_getopts(argc, argv,
315 'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
316 NULL) != argc)
317 return (DCMD_USAGE);
318
319 /* Always print tpgs and portals */
320 idc.u.child.idc_tpg = 1;
321 idc.u.child.idc_portal = 1;
322 idc.u.child.idc_rc_audit = rc_audit;
323 if (DCMD_HDRSPEC(flags))
324 idc.idc_header = 1;
325
326 /*
327 * If no address was specified on the command line, we
328 * print out all tgtions
329 */
330 if (!(flags & DCMD_ADDRSPEC)) {
331 if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
332 mdb_warn("failed to find symbol 'iscsit_global'");
333 return (DCMD_ERR);
334 }
335 iscsit_global_addr = (uintptr_t)sym.st_value;
336 avl_addr = iscsit_global_addr +
337 offsetof(iscsit_global_t, global_tpg_list);
338 if (mdb_pwalk("avl", iscsi_tpg_walk_cb, &idc, avl_addr) == -1) {
339 mdb_warn("avl walk failed for global target tree");
340 return (DCMD_ERR);
341 }
342 return (DCMD_OK);
343 }
344 return (iscsi_tpg_impl(addr, &idc));
345 }
346
347 /*
348 * ::iscsi_tpgt [-pR]
349 *
350 * Print tpgt information.
351 * R Print reference count audit data
352 * p Print portal data
353 */
354 static int
355 iscsi_tpgt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
356 {
357 iscsi_dcmd_ctrl_t idc;
358 uintptr_t iscsit_global_addr, avl_addr, list_addr;
359 GElf_Sym sym;
360 int rc_audit = 0, portal = 0;
361
362 bzero(&idc, sizeof (idc));
363 if (mdb_getopts(argc, argv,
364 'p', MDB_OPT_SETBITS, TRUE, &portal,
365 'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
366 NULL) != argc)
367 return (DCMD_USAGE);
368
369 idc.u.child.idc_tpgt = 1;
370 idc.u.child.idc_portal = portal;
371 idc.u.child.idc_rc_audit = rc_audit;
372 if (DCMD_HDRSPEC(flags))
373 idc.idc_header = 1;
374
375 /*
376 * If no address was specified on the command line,
377 * print out all tpgts
378 */
379 if (!(flags & DCMD_ADDRSPEC)) {
380 if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
381 mdb_warn("failed to find symbol 'iscsit_global'");
382 return (DCMD_ERR);
383 }
384 iscsit_global_addr = (uintptr_t)sym.st_value;
385 avl_addr = iscsit_global_addr +
386 offsetof(iscsit_global_t, global_target_list);
387 if (mdb_pwalk("avl", iscsi_tgt_walk_cb, &idc, avl_addr) == -1) {
388 mdb_warn("avl walk failed for global target tree");
389 return (DCMD_ERR);
390 }
391 list_addr = iscsit_global_addr +
392 offsetof(iscsit_global_t, global_deleted_target_list);
393 if (mdb_pwalk("list", iscsi_tgt_walk_cb,
394 &idc, list_addr) == -1) {
395 mdb_warn("list walk failed for deleted target list");
396 return (DCMD_ERR);
397 }
398 return (DCMD_OK);
399 }
400 return (iscsi_tpgt_impl(addr, &idc));
401 }
402
403 /*
404 * ::iscsi_sess [-ablmtvcSRIT]
405 *
406 * iscsi_sess - Print out information associated with an iSCSI session
407 *
408 * I Print only initiator sessions
409 * T Print only target sessions
410 * c Print associated connection information
411 * a Print IP addresses with connection information
412 * t Print associated task information
413 * l Print associated lun information (with -I)
414 * m Print associated initiator command information (with -I)
415 * b Print associated buffer information
416 * S Print recent state events and transitions
417 * R Print reference count audit data
418 * v Verbose output about the connection
419 */
420 /*ARGSUSED*/
421 static int
422 iscsi_sess(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
423 {
424 iscsi_dcmd_ctrl_t idc;
425 int buffer = 0, task = 0, conn = 0, print_ip = 0;
426 int states = 0, rc_audit = 0, commands = 0;
427 int luns = 0;
428
429 bzero(&idc, sizeof (idc));
430 if (mdb_getopts(argc, argv,
431 'I', MDB_OPT_SETBITS, TRUE, &idc.idc_ini,
432 'T', MDB_OPT_SETBITS, TRUE, &idc.idc_tgt,
433 'a', MDB_OPT_SETBITS, TRUE, &print_ip,
434 'c', MDB_OPT_SETBITS, TRUE, &conn,
435 't', MDB_OPT_SETBITS, TRUE, &task,
436 'l', MDB_OPT_SETBITS, TRUE, &luns,
437 'm', MDB_OPT_SETBITS, TRUE, &commands,
438 'b', MDB_OPT_SETBITS, TRUE, &buffer,
439 'S', MDB_OPT_SETBITS, TRUE, &states,
440 'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
441 'v', MDB_OPT_SETBITS, TRUE, &idc.idc_verbose,
442 NULL) != argc)
443 return (DCMD_USAGE);
444
445 idc.u.child.idc_sess = 1;
446 idc.u.child.idc_print_ip = print_ip;
447 idc.u.child.idc_conn = conn;
448 idc.u.child.idc_task = task;
449 idc.u.child.idc_cmd = commands;
450 idc.u.child.idc_lun = luns;
451 idc.u.child.idc_buffer = buffer;
452 idc.u.child.idc_states = states;
453 idc.u.child.idc_rc_audit = rc_audit;
454 if (DCMD_HDRSPEC(flags))
455 idc.idc_header = 1;
456
457 /*
458 * If no address was specified on the command line, we
459 * print out all sessions
460 */
461 if (!(flags & DCMD_ADDRSPEC)) {
462 return (iscsi_walk_all_sess(&idc));
463 }
464 return (iscsi_sess_impl(addr, &idc));
465 }
466
467
468
469 /*
470 * ::iscsi_conn [-abmtvSRIT]
471 *
472 * iscsi_conn - Print out information associated with an iSCSI connection
473 *
474 * I Print only initiator connections
475 * T Print only target connections
476 * a Print IP addresses with connection information
477 * t Print associated task information
478 * b Print associated buffer information
479 * m Print associated initiator commands (with -I)
480 * S Print recent state events and transitions
481 * R Print reference count audit data
482 * v Verbose output about the connection
483 */
484 /*ARGSUSED*/
485 static int
486 iscsi_conn(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
487 {
488 iscsi_dcmd_ctrl_t idc;
489 int buffer = 0, task = 0, print_ip = 0;
490 int states = 0, rc_audit = 0, commands = 0;
491
492 bzero(&idc, sizeof (idc));
493 if (mdb_getopts(argc, argv,
494 'I', MDB_OPT_SETBITS, TRUE, &idc.idc_ini,
495 'T', MDB_OPT_SETBITS, TRUE, &idc.idc_tgt,
496 'a', MDB_OPT_SETBITS, TRUE, &print_ip,
497 't', MDB_OPT_SETBITS, TRUE, &task,
498 'b', MDB_OPT_SETBITS, TRUE, &buffer,
499 'm', MDB_OPT_SETBITS, TRUE, &commands,
500 'S', MDB_OPT_SETBITS, TRUE, &states,
501 'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
502 'v', MDB_OPT_SETBITS, TRUE, &idc.idc_verbose,
503 NULL) != argc)
504 return (DCMD_USAGE);
505
506 idc.u.child.idc_conn = 1;
507 idc.u.child.idc_print_ip = print_ip;
508 idc.u.child.idc_task = task;
509 idc.u.child.idc_buffer = buffer;
510 idc.u.child.idc_cmd = commands;
511 idc.u.child.idc_states = states;
512 idc.u.child.idc_rc_audit = rc_audit;
513 if (DCMD_HDRSPEC(flags))
514 idc.idc_header = 1;
515
516 /*
517 * If no address was specified on the command line, we
518 * print out all connections
519 */
520 if (!(flags & DCMD_ADDRSPEC)) {
521 return (iscsi_walk_all_conn(&idc));
522 }
523 return (iscsi_conn_impl(addr, &idc));
524 }
525
526
527 /*
528 * ::iscsi_svc [-vR]
529 *
530 * iscsi_svc - Print out information associated with an iSCSI svc
531 *
532 * R Print reference count audit data
533 * v Verbose output about the service
534 */
535 static int
536 iscsi_svc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
537 {
538 iscsi_dcmd_ctrl_t idc;
539 GElf_Sym sym;
540 uintptr_t idm_addr;
541 uintptr_t svc_list_addr;
542 int rc_audit = 0;
543
544 bzero(&idc, sizeof (iscsi_dcmd_ctrl_t));
545
546 if (mdb_getopts(argc, argv,
547 'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
548 'v', MDB_OPT_SETBITS, TRUE, &idc.idc_verbose,
549 NULL) != argc)
550 return (DCMD_USAGE);
551
552 idc.u.child.idc_svc = 1;
553 idc.u.child.idc_rc_audit = rc_audit;
554 if (DCMD_HDRSPEC(flags)) {
555 idc.idc_header = 1;
556 }
557
558 if (!(flags & DCMD_ADDRSPEC)) {
559 if (mdb_lookup_by_name("idm", &sym) == -1) {
560 mdb_warn("failed to find symbol 'idm'");
561 return (DCMD_ERR);
562 }
563 idm_addr = (uintptr_t)sym.st_value;
564 svc_list_addr = idm_addr + offsetof(idm_global_t,
565 idm_tgt_svc_list);
566
567 if (mdb_pwalk("list", iscsi_svc_walk_cb, &idc,
568 svc_list_addr) == -1) {
569 mdb_warn("list walk failed for idm services");
570 return (DCMD_ERR);
571 }
572 return (DCMD_OK);
573 }
574 return (iscsi_svc_impl(addr, &idc));
575 }
576
577 /*
578 * ::iscsi_portal -R
579 *
580 * iscsi_portal - Print out information associated with an iSCSI portal
581 *
582 * R Print reference count audit data
583 */
584 static int
585 iscsi_portal(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
586 {
587 iscsi_dcmd_ctrl_t idc;
588 GElf_Sym sym;
589 iscsit_global_t iscsit_global;
590 uintptr_t iscsit_global_addr;
591 uintptr_t tpg_avl_addr;
592 int rc_audit = 0;
593
594 bzero(&idc, sizeof (iscsi_dcmd_ctrl_t));
595
596 if (mdb_getopts(argc, argv,
597 'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
598 NULL) != argc)
599 return (DCMD_USAGE);
600
601 idc.u.child.idc_rc_audit = rc_audit;
602 idc.u.child.idc_portal = 1;
603 if (DCMD_HDRSPEC(flags)) {
604 idc.idc_header = 1;
605 }
606
607 if (!(flags & DCMD_ADDRSPEC)) {
608 if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
609 mdb_warn("failed to find symbol 'iscsit_global'");
610 return (DCMD_ERR);
611 }
612
613 iscsit_global_addr = (uintptr_t)sym.st_value;
614
615 /* get and print the global default tpg */
616 if (mdb_vread(&iscsit_global, sizeof (iscsit_global_t),
617 iscsit_global_addr) != sizeof (iscsit_global_t)) {
618 mdb_warn("failed to read iscsit_global_t");
619 return (DCMD_ERR);
620 }
621 if (iscsi_tpg_impl((uintptr_t)iscsit_global.global_default_tpg,
622 &idc) != DCMD_OK) {
623 return (DCMD_ERR);
624 }
625
626 /* Walk the tpgs for the rest of the portals */
627 tpg_avl_addr = iscsit_global_addr + offsetof(iscsit_global_t,
628 global_tpg_list);
629 if (mdb_pwalk("avl", iscsi_tpg_walk_cb, &idc,
630 tpg_avl_addr) == -1) {
631 mdb_warn("list walk failed for global tpg tree");
632 return (DCMD_ERR);
633 }
634 return (DCMD_OK);
635 }
636 return (iscsi_portal_impl(addr, &idc));
637 }
638
639
640 /*
641 * ::iscsi_cmd -S
642 *
643 * iscsi_cmd - Print out information associated with an iSCSI cmd
644 *
645 * S Print state audit data
646 */
647 static int
648 iscsi_cmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
649 {
650 iscsi_dcmd_ctrl_t idc;
651 iscsi_cmd_t cmd;
652 int states = 0;
653
654 bzero(&idc, sizeof (iscsi_dcmd_ctrl_t));
655
656 if (mdb_getopts(argc, argv,
657 'S', MDB_OPT_SETBITS, TRUE, &states,
658 NULL) != argc)
659 return (DCMD_USAGE);
660
661 idc.u.child.idc_states = states;
662 idc.u.child.idc_cmd = 1;
663 idc.idc_ini = 1;
664 if (DCMD_HDRSPEC(flags)) {
665 idc.idc_header = 1;
666 }
667
668 if (!(flags & DCMD_ADDRSPEC)) {
669 if (mdb_pwalk("iscsi_ini_hba", iscsi_ini_hba_walk_cb,
670 &idc, NULL) == -1) {
671 mdb_warn("iscsi cmd hba list walk failed");
672 return (DCMD_ERR);
673 }
674 } else {
675 if (mdb_vread(&cmd, sizeof (iscsi_cmd_t), addr) !=
676 sizeof (iscsi_cmd_t)) {
677 return (DCMD_ERR);
678 }
679 return (iscsi_print_ini_cmd(addr, &cmd, &idc));
680 }
681 return (DCMD_OK);
682 }
683
684
685 static int
686 iscsi_ini_hba_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc) {
687 iscsi_hba_t ih;
688
689 if (mdb_vread(&ih, sizeof (ih), addr) != sizeof (ih)) {
690 mdb_warn("Invalid HBA\n");
691 return (DCMD_ERR);
692 }
693
694 if (idc->u.child.idc_hba) {
695 mdb_printf("iscsi_hba %p sessions: \n", addr);
696 }
697
698 if (mdb_pwalk("iscsi_ini_sess", iscsi_ini_sess_walk_cb, idc,
699 (uintptr_t)ih.hba_sess_list) == -1) {
700 mdb_warn("iscsi_sess_t walk failed");
701 return (DCMD_ERR);
702 }
703 return (DCMD_OK);
704 }
705
706 /*
707 * ::iscsi_task [-bv]
708 *
709 * iscsi_task - Print out information associated with an iSCSI task
710 *
711 * b Print associated buffer information
712 * S Print recent state events and transitions
713 * R Print reference count audit data
714 * v Verbose output about the connection
715 */
716 /*ARGSUSED*/
717 static int
718 iscsi_task(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
719 {
720 iscsi_dcmd_ctrl_t idc;
721 int buffer = 0;
722 int states = 0, rc_audit = 0;
723
724 bzero(&idc, sizeof (idc));
725 if (mdb_getopts(argc, argv,
726 'b', MDB_OPT_SETBITS, TRUE, &buffer,
727 'S', MDB_OPT_SETBITS, TRUE, &states,
728 'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
729 'v', MDB_OPT_SETBITS, TRUE, &idc.idc_verbose,
730 NULL) != argc)
731 return (DCMD_USAGE);
732
733 idc.u.child.idc_conn = 0;
734 idc.u.child.idc_task = 1;
735 idc.u.child.idc_buffer = buffer;
736 idc.u.child.idc_states = states;
737 idc.u.child.idc_rc_audit = rc_audit;
738 if (DCMD_HDRSPEC(flags))
739 idc.idc_header = 1;
740
741 /*
742 * If no address was specified on the command line, we
743 * print out all connections
744 */
745 if (!(flags & DCMD_ADDRSPEC)) {
746 return (iscsi_walk_all_conn(&idc));
747 }
748 return (iscsi_task_impl(addr, &idc));
749 }
750
751 /*
752 * ::iscsi_refcnt
753 *
754 * iscsi_refcnt - Dump an idm_refcnt_t structure
755 *
756 */
757 /*ARGSUSED*/
758 static int
759 iscsi_refcnt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
760 {
761 if (!(flags & DCMD_ADDRSPEC)) {
762 return (DCMD_ERR);
763 }
764 return (iscsi_refcnt_impl(addr));
765 }
766
767 /*
768 * ::iscsi_states
769 *
770 * iscsi_states - Dump events and state transitions recoreded in an
771 * idm_sm_audit_t structure
772 *
773 */
774 /*ARGSUSED*/
775 static int
776 iscsi_states(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
777 {
778 if (!(flags & DCMD_ADDRSPEC)) {
779 return (DCMD_ERR);
780 }
781 return (iscsi_sm_audit_impl(addr));
782 }
783
784
785 static int
786 iscsi_walk_all_sess(iscsi_dcmd_ctrl_t *idc)
787 {
788 uintptr_t iscsit_global_addr;
789 uintptr_t avl_addr;
790 uintptr_t list_addr;
791 GElf_Sym sym;
792
793 /* Initiator sessions */
794 if (idc->idc_ini) {
795 /* Always print hba info on this path */
796 idc->u.child.idc_hba = 1;
797 if (mdb_pwalk("iscsi_ini_hba", iscsi_ini_hba_walk_cb,
798 idc, NULL) == -1) {
799 mdb_warn("iscsi cmd hba list walk failed");
800 return (DCMD_ERR);
801 }
802 return (DCMD_OK);
803 }
804
805 /* Target sessions */
806 /* Walk discovery sessions */
807 if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
808 mdb_warn("failed to find symbol 'iscsit_global'");
809 return (DCMD_ERR);
810 }
811 iscsit_global_addr = (uintptr_t)sym.st_value;
812 avl_addr = iscsit_global_addr +
813 offsetof(iscsit_global_t, global_discovery_sessions);
814 if (mdb_pwalk("avl", iscsi_sess_walk_cb, idc, avl_addr) == -1) {
815 mdb_warn("avl walk failed for discovery sessions");
816 return (DCMD_ERR);
817 }
818
819 /* Walk targets printing all session info */
820 avl_addr = iscsit_global_addr +
821 offsetof(iscsit_global_t, global_target_list);
822 if (mdb_pwalk("avl", iscsi_tgt_walk_cb, idc, avl_addr) == -1) {
823 mdb_warn("avl walk failed for target/session tree");
824 return (DCMD_ERR);
825 }
826
827 /* Walk deleting targets printing all session info */
828 list_addr = iscsit_global_addr +
829 offsetof(iscsit_global_t, global_deleted_target_list);
830 if (mdb_pwalk("list", iscsi_tgt_walk_cb, idc, list_addr) == -1) {
831 mdb_warn("list walk failed for deleted target list");
832 return (DCMD_ERR);
833 }
834
835 return (DCMD_OK);
836 }
837
838 static int
839 iscsi_walk_all_conn(iscsi_dcmd_ctrl_t *idc)
840 {
841 uintptr_t idm_global_addr;
842 uintptr_t list_addr;
843 GElf_Sym sym;
844
845 /* Walk initiator connections */
846 if (mdb_lookup_by_name("idm", &sym) == -1) {
847 mdb_warn("failed to find symbol 'idm'");
848 return (DCMD_ERR);
849 }
850 idm_global_addr = (uintptr_t)sym.st_value;
851 /* Walk connection list associated with the initiator */
852 list_addr = idm_global_addr + offsetof(idm_global_t, idm_ini_conn_list);
853 if (mdb_pwalk("list", iscsi_conn_walk_cb, idc, list_addr) == -1) {
854 mdb_warn("list walk failed for initiator connections");
855 return (DCMD_ERR);
856 }
857
858 /* Walk connection list associated with the target */
859 list_addr = idm_global_addr + offsetof(idm_global_t, idm_tgt_conn_list);
860 if (mdb_pwalk("list", iscsi_conn_walk_cb, idc, list_addr) == -1) {
861 mdb_warn("list walk failed for target service instances");
862 return (DCMD_ERR);
863 }
864
865 return (DCMD_OK);
866 }
867
868 /*ARGSUSED*/
869 static int
870 iscsi_tpg_walk_cb(uintptr_t addr, const void *list_walker_data,
871 void *idc_void)
872 {
873 /* We don't particularly care about the list walker data */
874 iscsi_dcmd_ctrl_t *idc = idc_void;
875 int rc;
876
877 rc = iscsi_tpg_impl(addr, idc);
878
879 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
880 }
881
882 /*ARGSUSED*/
883 static int
884 iscsi_tgt_walk_cb(uintptr_t addr, const void *list_walker_data,
885 void *idc_void)
886 {
887 /* We don't particularly care about the list walker data */
888 iscsi_dcmd_ctrl_t *idc = idc_void;
889 int rc;
890
891 rc = iscsi_tgt_impl(addr, idc);
892
893 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
894 }
895
896 /*ARGSUSED*/
897 static int
898 iscsi_tpgt_walk_cb(uintptr_t addr, const void *list_walker_data,
899 void *idc_void)
900 {
901 /* We don't particularly care about the list walker data */
902 iscsi_dcmd_ctrl_t *idc = idc_void;
903 int rc;
904
905 rc = iscsi_tpgt_impl(addr, idc);
906
907 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
908 }
909
910 /*ARGSUSED*/
911 static int
912 iscsi_portal_walk_cb(uintptr_t addr, const void *list_walker_data,
913 void *idc_void)
914 {
915 /* We don't particularly care about the list walker data */
916 iscsi_dcmd_ctrl_t *idc = idc_void;
917 int rc;
918
919 rc = iscsi_portal_impl(addr, idc);
920
921 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
922 }
923
924 /*ARGSUSED*/
925 static int
926 iscsi_sess_walk_cb(uintptr_t addr, const void *list_walker_data,
927 void *idc_void)
928 {
929 /* We don't particularly care about the list walker data */
930 iscsi_dcmd_ctrl_t *idc = idc_void;
931 int rc;
932
933 rc = iscsi_sess_impl(addr, idc);
934
935 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
936 }
937
938 /*ARGSUSED*/
939 static int
940 iscsi_sess_conn_walk_cb(uintptr_t addr, const void *list_walker_data,
941 void *idc_void)
942 {
943 /* We don't particularly care about the list walker data */
944 iscsi_dcmd_ctrl_t *idc = idc_void;
945 iscsit_conn_t ict;
946 int rc;
947
948 /*
949 * This function is different from iscsi_conn_walk_cb because
950 * we get an iscsit_conn_t instead of an idm_conn_t
951 *
952 * Read iscsit_conn_t, use to get idm_conn_t pointer
953 */
954 if (mdb_vread(&ict, sizeof (iscsit_conn_t), addr) !=
955 sizeof (iscsit_conn_t)) {
956 return (DCMD_ERR);
957 }
958 rc = iscsi_conn_impl((uintptr_t)ict.ict_ic, idc);
959
960 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
961 }
962
963 /*ARGSUSED*/
964 static int
965 iscsi_conn_walk_cb(uintptr_t addr, const void *list_walker_data,
966 void *idc_void)
967 {
968 /* We don't particularly care about the list walker data */
969 iscsi_dcmd_ctrl_t *idc = idc_void;
970 int rc;
971
972 rc = iscsi_conn_impl(addr, idc);
973
974 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
975 }
976
977 /*ARGSUSED*/
978 static int
979 iscsi_buffer_walk_cb(uintptr_t addr, const void *list_walker_data,
980 void *idc_void)
981 {
982 /* We don't particularly care about the list walker data */
983 iscsi_dcmd_ctrl_t *idc = idc_void;
984 int rc;
985
986 rc = iscsi_buffer_impl(addr, idc);
987
988 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
989 }
990
991 /*ARGSUSED*/
992 static int
993 iscsi_svc_walk_cb(uintptr_t addr, const void *list_walker_data,
994 void *idc_void)
995 {
996 iscsi_dcmd_ctrl_t *idc = idc_void;
997 int rc;
998
999 rc = iscsi_svc_impl(addr, idc);
1000
1001 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
1002 }
1003
1004 /*ARGSUSED*/
1005 static int
1006 iscsi_ini_hba_walk_cb(uintptr_t addr, const void *vhba,
1007 void *idc_void) {
1008
1009 iscsi_dcmd_ctrl_t *idc = idc_void;
1010 int rc;
1011
1012 rc = iscsi_ini_hba_impl(addr, idc);
1013
1014 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
1015 }
1016
1017 static int
1018 iscsi_ini_sess_walk_cb(uintptr_t addr, const void *vsess, void *idc_void)
1019 {
1020 int rc;
1021
1022 if (vsess == NULL) {
1023 return (WALK_ERR);
1024 }
1025
1026 rc = iscsi_print_ini_sess(addr, (iscsi_sess_t *)vsess,
1027 (iscsi_dcmd_ctrl_t *)idc_void);
1028
1029 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
1030 }
1031
1032 /*ARGSUSED*/
1033 static int
1034 iscsi_ini_conn_walk_cb(uintptr_t addr, const void *vconn, void *idc_void)
1035 {
1036 const iscsi_conn_t *ict = vconn;
1037 int rc;
1038
1039 if (vconn == NULL) {
1040 return (WALK_ERR);
1041 }
1042
1043 /*
1044 * Look up the idm_conn_t in the iscsi_conn_t and call the general
1045 * connection handler.
1046 */
1047 rc = iscsi_conn_impl((uintptr_t)ict->conn_ic,
1048 (iscsi_dcmd_ctrl_t *)idc_void);
1049
1050 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
1051 }
1052
1053 static int
1054 iscsi_ini_lun_walk_cb(uintptr_t addr, const void *vlun, void *idc_void)
1055 {
1056 int rc;
1057
1058 if (vlun == NULL) {
1059 return (WALK_ERR);
1060 }
1061
1062 rc = iscsi_print_ini_lun(addr, (iscsi_lun_t *)vlun,
1063 (iscsi_dcmd_ctrl_t *)idc_void);
1064
1065 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
1066 }
1067
1068
1069 static int
1070 iscsi_tgt_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1071 {
1072 iscsit_tgt_t tgt;
1073 uintptr_t avl_addr, rc_addr, states_addr;
1074 char tgt_name[MAX_ISCSI_NODENAMELEN];
1075 int verbose, states, rc_audit;
1076
1077 /*
1078 * Read iscsit_tgt_t
1079 */
1080 if (mdb_vread(&tgt, sizeof (iscsit_tgt_t), addr) !=
1081 sizeof (iscsit_tgt_t)) {
1082 return (DCMD_ERR);
1083 }
1084
1085 /*
1086 * Read target name if available
1087 */
1088 if ((tgt.target_name == NULL) ||
1089 (mdb_readstr(tgt_name, sizeof (tgt_name),
1090 (uintptr_t)tgt.target_name) == -1)) {
1091 strcpy(tgt_name, "N/A");
1092 }
1093
1094 /*
1095 * Brief output
1096 *
1097 * iscsit_tgt_t pointer
1098 * iscsit_tgt_t.target_stmf_state
1099 * iscsit_tgt_t.target_sess_list.avl_numnodes (session count)
1100 * iscsit_tgt_t.target_name;
1101 */
1102
1103 verbose = idc->idc_verbose;
1104 states = idc->u.child.idc_states;
1105 rc_audit = idc->u.child.idc_rc_audit;
1106
1107 /* For now we will ignore the verbose flag */
1108 if (idc->u.child.idc_tgt) {
1109 /* Print target data */
1110 if (idc->idc_header) {
1111 mdb_printf("%<u>%-19s %-4s %-8s%</u>\n",
1112 "iscsit_tgt_t", "Sess", "State");
1113 }
1114 mdb_printf("%-19p %-4d %-8d\n", addr,
1115 tgt.target_sess_list.avl_numnodes,
1116 tgt.target_state);
1117 mdb_printf(" %s\n", tgt_name);
1118
1119 /* Indent and disable verbose for any child structures */
1120 mdb_inc_indent(4);
1121 idc->idc_verbose = 0;
1122 }
1123
1124 /*
1125 * Print states if requested
1126 */
1127 if (idc->u.child.idc_tgt && states) {
1128 states_addr = addr + offsetof(iscsit_tgt_t, target_state_audit);
1129
1130 mdb_printf("State History(target_state_audit):\n");
1131 if (iscsi_sm_audit_impl(states_addr) != DCMD_OK)
1132 return (DCMD_ERR);
1133 idc->u.child.idc_states = 0;
1134 }
1135
1136 /*
1137 * Print refcnt audit data if requested
1138 */
1139 if (idc->u.child.idc_tgt && rc_audit) {
1140 mdb_printf("Reference History(target_sess_refcnt):\n");
1141 rc_addr = addr +
1142 offsetof(iscsit_tgt_t, target_sess_refcnt);
1143 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
1144 return (DCMD_ERR);
1145
1146 mdb_printf("Reference History(target_refcnt):\n");
1147 rc_addr = addr +
1148 offsetof(iscsit_tgt_t, target_refcnt);
1149
1150 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
1151 return (DCMD_ERR);
1152 idc->u.child.idc_rc_audit = 0;
1153 }
1154
1155 /* Any child objects to walk? */
1156 if (idc->u.child.idc_tpgt || idc->u.child.idc_portal) {
1157
1158 if (idc->u.child.idc_tgt) {
1159 idc->idc_header = 1;
1160 }
1161
1162 /* Walk TPGT tree */
1163 avl_addr = addr +
1164 offsetof(iscsit_tgt_t, target_tpgt_list);
1165 if (mdb_pwalk("avl", iscsi_tpgt_walk_cb, idc,
1166 avl_addr) == -1) {
1167 mdb_warn("target tpgt list walk failed");
1168 (void) mdb_dec_indent(4);
1169 return (DCMD_ERR);
1170 }
1171 }
1172
1173 if (idc->u.child.idc_sess || idc->u.child.idc_conn ||
1174 idc->u.child.idc_task || idc->u.child.idc_buffer) {
1175
1176 if (idc->u.child.idc_tgt || idc->u.child.idc_tpgt ||
1177 idc->u.child.idc_portal) {
1178 idc->idc_header = 1;
1179 }
1180
1181 /* Walk sess tree */
1182 avl_addr = addr + offsetof(iscsit_tgt_t, target_sess_list);
1183 if (mdb_pwalk("avl", iscsi_sess_walk_cb, idc,
1184 avl_addr) == -1) {
1185 mdb_warn("target sess list walk failed");
1186 (void) mdb_dec_indent(4);
1187 return (DCMD_ERR);
1188 }
1189 }
1190
1191 /* If tgts were handled decrease indent and reset header */
1192 if (idc->u.child.idc_tgt) {
1193 idc->idc_header = 0;
1194 mdb_dec_indent(4);
1195 }
1196
1197 idc->idc_verbose = verbose;
1198 idc->u.child.idc_states = states;
1199 idc->u.child.idc_rc_audit = rc_audit;
1200 return (DCMD_OK);
1201 }
1202
1203 static int
1204 iscsi_tpgt_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1205 {
1206 iscsit_tpgt_t tpgt;
1207 iscsit_tpg_t tpg;
1208 uintptr_t avl_addr, tpg_addr, rc_addr;
1209 int rc_audit;
1210
1211 /*
1212 * Read iscsit_tpgt_t
1213 */
1214 if (mdb_vread(&tpgt, sizeof (iscsit_tpgt_t), addr) !=
1215 sizeof (iscsit_tpgt_t)) {
1216 return (DCMD_ERR);
1217 }
1218
1219 tpg_addr = (uintptr_t)tpgt.tpgt_tpg;
1220
1221 /*
1222 * Read iscsit_tpg_t
1223 */
1224 if (mdb_vread(&tpg, sizeof (iscsit_tpg_t), tpg_addr) !=
1225 sizeof (iscsit_tpg_t)) {
1226 return (DCMD_ERR);
1227 }
1228
1229 rc_audit = idc->u.child.idc_rc_audit;
1230
1231 /*
1232 * Brief output
1233 *
1234 * iscsit_tpgt_t pointer
1235 * iscsit_tpg_t pointer
1236 * iscsit_tpg_t.tpg_name
1237 * iscsit_tpgt_t.tpgt_tag;
1238 */
1239
1240 /* For now we will ignore the verbose flag */
1241 if (idc->u.child.idc_tpgt) {
1242 /* Print target data */
1243 if (idc->idc_header) {
1244 mdb_printf("%<u>%-?s %-?s %-18s %-6s%</u>\n",
1245 "iscsit_tpgt_t", "iscsit_tpg_t", "Name", "Tag");
1246 }
1247 mdb_printf("%?p %?p %-18s 0x%04x\n", addr, tpgt.tpgt_tpg,
1248 tpg.tpg_name, tpgt.tpgt_tag);
1249
1250 if (rc_audit) {
1251 (void) mdb_inc_indent(4);
1252
1253 mdb_printf("Reference History(tpgt_refcnt):\n");
1254 rc_addr = addr + offsetof(iscsit_tpgt_t, tpgt_refcnt);
1255 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
1256 return (DCMD_ERR);
1257
1258 idc->u.child.idc_rc_audit = 0;
1259 (void) mdb_dec_indent(4);
1260 }
1261 }
1262
1263 /*
1264 * Assume for now that anyone interested in TPGT wants to see the
1265 * portals as well. Enable idc_header for the portals.
1266 */
1267 idc->idc_header = 1;
1268 (void) mdb_inc_indent(4);
1269 avl_addr = tpg_addr + offsetof(iscsit_tpg_t, tpg_portal_list);
1270 if (mdb_pwalk("avl", iscsi_portal_walk_cb, idc, avl_addr) == -1) {
1271 mdb_warn("portal list walk failed");
1272 (void) mdb_dec_indent(4);
1273 return (DCMD_ERR);
1274 }
1275 (void) mdb_dec_indent(4);
1276 idc->idc_header = 0;
1277
1278 idc->u.child.idc_rc_audit = rc_audit;
1279 return (DCMD_OK);
1280 }
1281
1282 static int
1283 iscsi_tpg_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1284 {
1285 iscsit_tpg_t tpg;
1286 uintptr_t avl_addr, rc_addr;
1287 int rc_audit = 0;
1288
1289 rc_audit = idc->u.child.idc_rc_audit;
1290
1291 /*
1292 * Read iscsit_tpg_t
1293 */
1294 if (mdb_vread(&tpg, sizeof (iscsit_tpg_t), addr) !=
1295 sizeof (iscsit_tpg_t)) {
1296 return (DCMD_ERR);
1297 }
1298
1299 /*
1300 * Brief output
1301 *
1302 * iscsit_tpgt_t pointer
1303 * iscsit_tpg_t pointer
1304 * iscsit_tpg_t.tpg_name
1305 * iscsit_tpgt_t.tpgt_tag;
1306 */
1307
1308 /* Print tpg data */
1309 if (idc->u.child.idc_tpg) {
1310 if (idc->idc_header) {
1311 mdb_printf("%<u>%-?s %-18s%</u>\n",
1312 "iscsit_tpg_t", "Name");
1313 }
1314 mdb_printf("%?p %-18s\n", addr, tpg.tpg_name);
1315
1316 (void) mdb_inc_indent(4);
1317
1318 if (rc_audit) {
1319 mdb_printf("Reference History(tpg_refcnt):\n");
1320 rc_addr = addr + offsetof(iscsit_tpg_t, tpg_refcnt);
1321 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
1322 return (DCMD_ERR);
1323 }
1324 idc->u.child.idc_rc_audit = 0;
1325 }
1326 }
1327
1328 if (idc->u.child.idc_portal) {
1329 if (idc->u.child.idc_tpg) {
1330 idc->idc_header = 1;
1331 }
1332
1333 avl_addr = addr + offsetof(iscsit_tpg_t, tpg_portal_list);
1334 if (mdb_pwalk("avl", iscsi_portal_walk_cb, idc,
1335 avl_addr) == -1) {
1336 mdb_warn("portal list walk failed");
1337 if (idc->u.child.idc_tpg) {
1338 (void) mdb_dec_indent(4);
1339 }
1340 return (DCMD_ERR);
1341 }
1342 }
1343
1344 if (idc->u.child.idc_tpg) {
1345 (void) mdb_dec_indent(4);
1346 idc->idc_header = 0;
1347 }
1348
1349 idc->u.child.idc_rc_audit = rc_audit;
1350 return (DCMD_OK);
1351 }
1352
1353 static int
1354 iscsi_portal_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1355 {
1356 iscsit_portal_t portal;
1357 char portal_addr[PORTAL_STR_LEN];
1358 uintptr_t rc_addr;
1359
1360 if (idc->u.child.idc_portal) {
1361 /*
1362 * Read iscsit_portal_t
1363 */
1364 if (mdb_vread(&portal, sizeof (iscsit_portal_t), addr) !=
1365 sizeof (iscsit_portal_t)) {
1366 return (DCMD_ERR);
1367 }
1368
1369 /* Print portal data */
1370 if (idc->idc_header) {
1371 mdb_printf("%<u>%-?s %-?s %-30s%</u>\n",
1372 "iscsit_portal_t", "idm_svc_t", "IP:Port");
1373 idc->idc_header = 0;
1374 }
1375 sa_to_str(&portal.portal_addr, portal_addr);
1376 mdb_printf("%?p %?p %s\n", addr, portal.portal_svc,
1377 portal.portal_default ? "(Default)" : portal_addr);
1378
1379 if (idc->u.child.idc_rc_audit) {
1380 (void) mdb_inc_indent(4);
1381 mdb_printf("Reference History(portal_refcnt):\n");
1382 rc_addr = addr + offsetof(iscsit_portal_t,
1383 portal_refcnt);
1384 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
1385 return (DCMD_ERR);
1386 }
1387 (void) mdb_dec_indent(4);
1388 }
1389 }
1390
1391 return (DCMD_OK);
1392 }
1393
1394 static int
1395 iscsi_sess_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1396 {
1397 iscsit_sess_t ist;
1398 iscsi_sess_t ini_sess;
1399 uintptr_t list_addr, states_addr, rc_addr;
1400 char ini_name[80];
1401 char tgt_name[80];
1402 int verbose, states, rc_audit;
1403
1404 if (idc->idc_ini) {
1405 if ((mdb_vread(&ini_sess, sizeof (iscsi_sess_t),
1406 (uintptr_t)addr)) != sizeof (iscsi_sess_t)) {
1407 mdb_warn("Failed to read initiator session\n");
1408 return (DCMD_ERR);
1409 }
1410 if (iscsi_print_ini_sess(addr, &ini_sess, idc) != DCMD_OK) {
1411 return (DCMD_ERR);
1412 }
1413 return (DCMD_OK);
1414 }
1415 /*
1416 * Read iscsit_sess_t
1417 */
1418 if (mdb_vread(&ist, sizeof (iscsit_sess_t), addr) !=
1419 sizeof (iscsit_sess_t)) {
1420 return (DCMD_ERR);
1421 }
1422
1423 /*
1424 * Brief output
1425 *
1426 * iscsit_sess_t pointer
1427 * iscsit_sess_t.ist_state/iscsit_sess_t.ist_ffp_conn_count
1428 * iscsit_sess_t.ist_tsih
1429 * iscsit_sess_t.ist_initiator_name
1430 */
1431
1432 verbose = idc->idc_verbose;
1433 states = idc->u.child.idc_states;
1434 rc_audit = idc->u.child.idc_rc_audit;
1435
1436 if (idc->u.child.idc_sess) {
1437 if (verbose) {
1438 /*
1439 * Read initiator name if available
1440 */
1441 if ((ist.ist_initiator_name == NULL) ||
1442 (mdb_readstr(ini_name, sizeof (ini_name),
1443 (uintptr_t)ist.ist_initiator_name) == -1)) {
1444 strcpy(ini_name, "N/A");
1445 }
1446
1447 /*
1448 * Read target name if available
1449 */
1450 if ((ist.ist_target_name == NULL) ||
1451 (mdb_readstr(tgt_name, sizeof (tgt_name),
1452 (uintptr_t)ist.ist_target_name) == -1)) {
1453 strcpy(tgt_name, "N/A");
1454 }
1455
1456 mdb_printf("Session %p\n", addr);
1457 mdb_printf("%16s: %d\n", "State",
1458 ist.ist_state);
1459 mdb_printf("%16s: %d\n", "Last State",
1460 ist.ist_last_state);
1461 mdb_printf("%16s: %d\n", "FFP Connections",
1462 ist.ist_ffp_conn_count);
1463 mdb_printf("%16s: %02x%02x%02x%02x%02x%02x\n", "ISID",
1464 ist.ist_isid[0], ist.ist_isid[1], ist.ist_isid[2],
1465 ist.ist_isid[3], ist.ist_isid[4], ist.ist_isid[5]);
1466 mdb_printf("%16s: 0x%04x\n", "TSIH",
1467 ist.ist_tsih);
1468 mdb_printf("%16s: %s\n", "Initiator IQN",
1469 ini_name);
1470 mdb_printf("%16s: %s\n", "Target IQN",
1471 tgt_name);
1472 mdb_printf("%16s: %08x\n", "ExpCmdSN",
1473 ist.ist_expcmdsn);
1474 mdb_printf("%16s: %08x\n", "MaxCmdSN",
1475 ist.ist_maxcmdsn);
1476
1477 idc->idc_verbose = 0;
1478 } else {
1479 /* Print session data */
1480 if (idc->idc_header) {
1481 mdb_printf("%<u>%-?s %10s %-12s %-6s%</u>\n",
1482 "iscsit_sess_t", "State/Conn", "ISID",
1483 "TSIH");
1484 }
1485 mdb_printf("%?p %4d/%-4d %02x%02x%02x%02x%02x%02x "
1486 "0x%04x\n", addr,
1487 ist.ist_state, ist.ist_ffp_conn_count,
1488 ist.ist_isid[0], ist.ist_isid[1], ist.ist_isid[2],
1489 ist.ist_isid[3], ist.ist_isid[4], ist.ist_isid[5],
1490 ist.ist_tsih);
1491 }
1492
1493 /*
1494 * Indent for any child structures
1495 */
1496 (void) mdb_inc_indent(4);
1497 }
1498
1499 /*
1500 * Print states if requested
1501 */
1502 if (idc->u.child.idc_sess && states) {
1503 states_addr = addr + offsetof(iscsit_sess_t, ist_state_audit);
1504
1505 mdb_printf("State History(ist_state_audit):\n");
1506 if (iscsi_sm_audit_impl(states_addr) != DCMD_OK)
1507 return (DCMD_ERR);
1508
1509 /* Don't print state history for child objects */
1510 idc->u.child.idc_states = 0;
1511 }
1512
1513 /*
1514 * Print refcnt audit data if requested
1515 */
1516 if (idc->u.child.idc_sess && rc_audit) {
1517 mdb_printf("Reference History(ist_refcnt):\n");
1518 rc_addr = addr +
1519 offsetof(iscsit_sess_t, ist_refcnt);
1520 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
1521 return (DCMD_ERR);
1522
1523 /* Don't print audit data for child objects */
1524 idc->u.child.idc_rc_audit = 0;
1525 }
1526
1527 /* Any child objects to walk? */
1528 if (idc->u.child.idc_conn || idc->u.child.idc_task ||
1529 idc->u.child.idc_buffer) {
1530 /*
1531 * If a session has been printed enable headers for
1532 * any child structs.
1533 */
1534 if (idc->u.child.idc_sess) {
1535 idc->idc_header = 1;
1536 }
1537
1538 /* Walk conn list */
1539 list_addr = addr + offsetof(iscsit_sess_t, ist_conn_list);
1540 if (mdb_pwalk("list", iscsi_sess_conn_walk_cb, idc,
1541 list_addr) == -1) {
1542 mdb_warn("session conn list walk failed");
1543 (void) mdb_dec_indent(4);
1544 return (DCMD_ERR);
1545 }
1546 }
1547
1548 /* If a session was handled decrease indent and reset header. */
1549 if (idc->u.child.idc_sess) {
1550 idc->idc_header = 0;
1551 mdb_dec_indent(4);
1552 }
1553
1554 idc->idc_verbose = verbose;
1555 idc->u.child.idc_states = states;
1556 idc->u.child.idc_rc_audit = rc_audit;
1557
1558 return (DCMD_OK);
1559 }
1560
1561 static int
1562 iscsi_print_ini_sess(uintptr_t addr, iscsi_sess_t *sess,
1563 iscsi_dcmd_ctrl_t *idc)
1564 {
1565
1566 int verbose, states;
1567 uintptr_t states_addr;
1568
1569 verbose = idc->idc_verbose;
1570 states = idc->u.child.idc_states;
1571
1572
1573 if (idc->u.child.idc_sess) {
1574 if (!idc->idc_verbose) {
1575 if (idc->idc_header) {
1576 mdb_printf("%<u>%-?s %-4s %-8s%</u>\n",
1577 "iscsi_sess_t", "Type", "State");
1578 }
1579 mdb_printf("%-19p %-4d %-8d\n", addr,
1580 sess->sess_type, sess->sess_state);
1581 } else {
1582 mdb_printf("Session %p\n", addr);
1583 mdb_printf("%22s: %d\n", "State",
1584 sess->sess_state);
1585 mdb_printf("%22s: %d\n", "Last State",
1586 sess->sess_prev_state);
1587 mdb_printf("%22s: %s\n", "Session Name",
1588 sess->sess_name);
1589 mdb_printf("%22s: %s\n", "Alias",
1590 sess->sess_alias);
1591 mdb_printf("%22s: %08x\n", "CmdSN",
1592 sess->sess_cmdsn);
1593 mdb_printf("%22s: %08x\n", "ExpCmdSN",
1594 sess->sess_expcmdsn);
1595 mdb_printf("%22s: %08x\n", "MaxCmdSN",
1596 sess->sess_maxcmdsn);
1597 mdb_printf("%22s: %p\n", "Pending Queue Head",
1598 sess->sess_queue_pending.head);
1599 mdb_printf("%22s: %p\n", "Completion Queue Head",
1600 sess->sess_queue_completion.head);
1601 mdb_printf("%22s: %p\n", "Connnection List Head",
1602 sess->sess_conn_list);
1603
1604 idc->idc_verbose = 0;
1605 }
1606
1607 /* Indent for any child structures */
1608 mdb_inc_indent(4);
1609
1610 if (idc->u.child.idc_states) {
1611 states_addr = (uintptr_t)addr +
1612 offsetof(iscsi_sess_t, sess_state_audit);
1613
1614 mdb_printf("State History(sess_state_audit):\n");
1615 if (iscsi_sm_audit_impl(states_addr) != DCMD_OK) {
1616 (void) mdb_dec_indent(4);
1617 return (DCMD_ERR);
1618 }
1619 idc->u.child.idc_states = 0;
1620 }
1621 }
1622
1623 if (idc->u.child.idc_lun && sess->sess_lun_list) {
1624 if (idc->u.child.idc_sess) {
1625 idc->idc_header = 1;
1626 }
1627
1628 if (mdb_pwalk("iscsi_ini_lun", iscsi_ini_lun_walk_cb, idc,
1629 (uintptr_t)sess->sess_lun_list) == -1) {
1630 mdb_warn("iscsi_ini_lun walk failed");
1631 (void) mdb_dec_indent(4);
1632 return (DCMD_ERR);
1633 }
1634 }
1635
1636
1637 /* If requested print the cmds in the session queue */
1638 if (idc->u.child.idc_cmd) {
1639
1640 /* If any other structs printed enable header */
1641 if (idc->u.child.idc_sess || idc->u.child.idc_lun) {
1642 idc->idc_header = 1;
1643 }
1644
1645 if (sess->sess_queue_pending.head) {
1646 if (mdb_pwalk("iscsi_ini_cmd", iscsi_ini_cmd_walk_cb,
1647 idc, (uintptr_t)sess->sess_queue_pending.head)
1648 == -1) {
1649 mdb_warn("list walk failed for iscsi cmds");
1650 }
1651 }
1652 if (sess->sess_queue_completion.head) {
1653 if (mdb_pwalk("iscsi_ini_cmd", iscsi_ini_cmd_walk_cb,
1654 idc, (uintptr_t)sess->sess_queue_completion.head)
1655 == -1) {
1656 mdb_warn("list walk failed for iscsi cmds");
1657 }
1658 }
1659 }
1660
1661 /* If connections or cmds requested walk the connections */
1662 if (idc->u.child.idc_conn || idc->u.child.idc_cmd) {
1663 /*
1664 * If idc_conn is not set don't enable header or the
1665 * commands may get extraneous headers.
1666 */
1667 if (idc->u.child.idc_conn) {
1668 idc->idc_header = 1;
1669 }
1670 if (mdb_pwalk("iscsi_ini_conn", iscsi_ini_conn_walk_cb, idc,
1671 (uintptr_t)sess->sess_conn_list) == -1) {
1672 mdb_warn("iscsi_ini_conn walk failed");
1673 return (DCMD_ERR);
1674 }
1675 }
1676
1677 /* If sessions were handled decrease indent and reset header */
1678 if (idc->u.child.idc_sess) {
1679 idc->idc_header = 0;
1680 mdb_dec_indent(4);
1681 }
1682
1683 idc->u.child.idc_states = states;
1684 idc->idc_verbose = verbose;
1685 return (DCMD_OK);
1686 }
1687
1688
1689 static int
1690 iscsi_conn_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1691 {
1692 uintptr_t idm_global_addr, states_addr, rc_addr;
1693 uintptr_t task_addr, task_ptr;
1694 GElf_Sym sym;
1695 idm_task_t idt;
1696 idm_conn_t ic;
1697 iscsit_conn_t ict;
1698 iscsi_conn_t ini_conn;
1699 char *conn_type;
1700 int task_idx;
1701 char laddr[PORTAL_STR_LEN];
1702 char raddr[PORTAL_STR_LEN];
1703 int verbose, states, rc_audit;
1704
1705 /*
1706 * Get pointer to task table
1707 */
1708
1709 if (mdb_lookup_by_name("idm", &sym) == -1) {
1710 mdb_warn("failed to find symbol 'idm'");
1711 return (DCMD_ERR);
1712 }
1713
1714 idm_global_addr = (uintptr_t)sym.st_value;
1715
1716 if (mdb_vread(&task_ptr, sizeof (uintptr_t),
1717 idm_global_addr + offsetof(idm_global_t, idm_taskid_table)) !=
1718 sizeof (uintptr_t)) {
1719 mdb_warn("Failed to read address of task table");
1720 return (DCMD_ERR);
1721 }
1722
1723 /*
1724 * Read idm_conn_t
1725 */
1726 if (mdb_vread(&ic, sizeof (idm_conn_t), addr) != sizeof (idm_conn_t)) {
1727 return (DCMD_ERR);
1728 }
1729
1730 /*
1731 * If filter bits are set to only print targets or only initiators
1732 * skip entries of the other type.
1733 */
1734 if (!(idc->idc_ini && idc->idc_tgt) &&
1735 ((idc->idc_ini && (ic.ic_conn_type != CONN_TYPE_INI)) ||
1736 (idc->idc_tgt && (ic.ic_conn_type != CONN_TYPE_TGT)))) {
1737 return (DCMD_OK);
1738 }
1739
1740
1741 conn_type = (ic.ic_conn_type == CONN_TYPE_INI) ? "Ini" :
1742 (ic.ic_conn_type == CONN_TYPE_TGT) ? "Tgt" : "Unk";
1743
1744 /*
1745 * Brief output
1746 *
1747 * idm_conn_t pointer
1748 * idm_conn_t.ic_conn_type
1749 * idm_conn_t.ic_statet+idm_conn_t.ic_ffp
1750 */
1751
1752 verbose = idc->idc_verbose;
1753 states = idc->u.child.idc_states;
1754 rc_audit = idc->u.child.idc_rc_audit;
1755
1756 /*
1757 * If targets(-T) and/or initiators (-I) are specifically requested,
1758 * fetch the iscsit_conn_t and/or iscsi_conn_t struct as a sanity
1759 * check and for use below.
1760 */
1761 if (idc->idc_tgt && IDM_CONN_ISTGT(&ic)) {
1762 if (mdb_vread(&ict, sizeof (iscsit_conn_t),
1763 (uintptr_t)ic.ic_handle) !=
1764 sizeof (iscsit_conn_t)) {
1765 mdb_printf("Failed to read target connection "
1766 "handle data\n");
1767 return (DCMD_ERR);
1768 }
1769 }
1770
1771 if (idc->idc_ini && IDM_CONN_ISINI(&ic)) {
1772 if (mdb_vread(&ini_conn, sizeof (iscsi_conn_t),
1773 (uintptr_t)ic.ic_handle) !=
1774 sizeof (iscsi_conn_t)) {
1775 mdb_printf("Failed to read initiator "
1776 "connection handle data\n");
1777 return (DCMD_ERR);
1778 }
1779 }
1780
1781 if (idc->u.child.idc_conn) {
1782 if (idc->idc_verbose) {
1783 mdb_printf("IDM Conn %p\n", addr);
1784 if (ic.ic_conn_type == CONN_TYPE_TGT) {
1785 iscsi_print_iscsit_conn_data(&ic);
1786 } else {
1787 iscsi_print_ini_conn_data(&ic);
1788 }
1789 idc->idc_verbose = 0;
1790 } else {
1791 /* Print connection data */
1792 if (idc->idc_header) {
1793 mdb_printf("%<u>%-?s %-6s %-10s %12s%</u>\n",
1794 "idm_conn_t", "Type", "Transport",
1795 "State/FFP");
1796 }
1797 mdb_printf("%?p %-6s %-10s %6d/%-6d\n", addr, conn_type,
1798 (ic.ic_transport_type ==
1799 IDM_TRANSPORT_TYPE_ISER) ? "ISER_IB" :
1800 (ic.ic_transport_type ==
1801 IDM_TRANSPORT_TYPE_SOCKETS) ? "SOCKETS" :
1802 "N/A",
1803 ic.ic_state, ic.ic_ffp);
1804 if (idc->u.child.idc_print_ip) {
1805 sa_to_str(&ic.ic_laddr, laddr);
1806 sa_to_str(&ic.ic_raddr, raddr);
1807 mdb_printf(" L%s R%s\n",
1808 laddr, raddr);
1809 }
1810 }
1811
1812 /* Indent for any child structs */
1813 mdb_inc_indent(4);
1814 }
1815
1816 /*
1817 * Print states if requested
1818 */
1819 if (idc->u.child.idc_conn && states) {
1820 states_addr = addr + offsetof(idm_conn_t, ic_state_audit);
1821
1822 mdb_printf("State History(ic_state_audit):\n");
1823 if (iscsi_sm_audit_impl(states_addr) != DCMD_OK)
1824 return (DCMD_ERR);
1825
1826 /*
1827 * If targets are specifically requested show the
1828 * state audit for the target specific connection struct
1829 */
1830 if (idc->idc_tgt && IDM_CONN_ISTGT(&ic)) {
1831 states_addr = (uintptr_t)ic.ic_handle +
1832 offsetof(iscsit_conn_t, ict_login_sm) +
1833 offsetof(iscsit_conn_login_t, icl_state_audit);
1834
1835 mdb_printf("State History(icl_state_audit):\n");
1836 if (iscsi_sm_audit_impl(states_addr) != DCMD_OK) {
1837 return (DCMD_ERR);
1838 }
1839 }
1840
1841 /*
1842 * If initiators are specifically requested show the
1843 * state audit for the initiator specific connection struct
1844 */
1845 if (idc->idc_ini && IDM_CONN_ISINI(&ic)) {
1846 states_addr = (uintptr_t)ic.ic_handle +
1847 offsetof(iscsi_conn_t, conn_state_audit);
1848
1849 mdb_printf("State History(iscsi_conn_t "
1850 "conn_state_audit):\n");
1851 if (iscsi_sm_audit_impl(states_addr) != DCMD_OK) {
1852 return (DCMD_ERR);
1853 }
1854 }
1855
1856 /* Don't print state history for child objects */
1857 idc->u.child.idc_states = 0;
1858 }
1859
1860 /*
1861 * Print refcnt audit data for the connection struct if requested.
1862 */
1863 if (idc->u.child.idc_conn && rc_audit) {
1864 mdb_printf("Reference History(ic_refcnt):\n");
1865 rc_addr = addr + offsetof(idm_conn_t, ic_refcnt);
1866 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
1867 return (DCMD_ERR);
1868
1869 /*
1870 * If targets are specifically requested show the
1871 * Refcounts for the target specific connection struct
1872 */
1873 if (idc->idc_tgt && IDM_CONN_ISTGT(&ic)) {
1874 mdb_printf("Reference History(ict_refcnt):\n");
1875 rc_addr = (uintptr_t)ic.ic_handle +
1876 offsetof(iscsit_conn_t, ict_refcnt);
1877 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
1878 return (DCMD_ERR);
1879 }
1880
1881 mdb_printf("Reference History(ict_dispatch_refcnt):\n");
1882 rc_addr = (uintptr_t)ic.ic_handle +
1883 offsetof(iscsit_conn_t, ict_dispatch_refcnt);
1884 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
1885 return (DCMD_ERR);
1886 }
1887 }
1888
1889 /* Don't print audit data for child objects */
1890 idc->u.child.idc_rc_audit = 0;
1891 }
1892
1893 task_idx = 0;
1894
1895 if (idc->u.child.idc_task || idc->u.child.idc_buffer) {
1896
1897 if (idc->u.child.idc_conn) {
1898 idc->idc_header = 1;
1899 }
1900
1901 while (task_idx < IDM_TASKIDS_MAX) {
1902 /*
1903 * Read the next idm_task_t
1904 */
1905 if (mdb_vread(&task_addr, sizeof (uintptr_t),
1906 task_ptr) != sizeof (uintptr_t)) {
1907 mdb_warn("Failed to read task pointer");
1908 return (DCMD_ERR);
1909 }
1910
1911 if (task_addr == NULL) {
1912 task_ptr += sizeof (uintptr_t);
1913 task_idx++;
1914 continue;
1915 }
1916
1917 if (mdb_vread(&idt, sizeof (idm_task_t), task_addr)
1918 != sizeof (idm_task_t)) {
1919 mdb_warn("Failed to read task pointer");
1920 return (DCMD_ERR);
1921 }
1922
1923 if (((uintptr_t)idt.idt_ic == addr) &&
1924 (idt.idt_state != TASK_IDLE)) {
1925 if (iscsi_i_task_impl(&idt, task_addr, idc)
1926 == -1) {
1927 mdb_warn("Failed to walk connection "
1928 "task tree");
1929 return (DCMD_ERR);
1930 }
1931 }
1932
1933 task_ptr += sizeof (uintptr_t);
1934 task_idx++;
1935 }
1936 }
1937
1938 if (idc->idc_ini && IDM_CONN_ISINI(&ic) && idc->u.child.idc_cmd) {
1939 if (idc->u.child.idc_conn || idc->u.child.idc_task) {
1940 idc->idc_header = 1;
1941 }
1942 if (ini_conn.conn_queue_active.head &&
1943 (mdb_pwalk("iscsi_ini_cmd", iscsi_ini_cmd_walk_cb, idc,
1944 (uintptr_t)ini_conn.conn_queue_active.head) == -1)) {
1945 mdb_warn("list walk failed for iscsi cmds");
1946 }
1947 if (ini_conn.conn_queue_idm_aborting.head &&
1948 (mdb_pwalk("iscsi_ini_cmd", iscsi_ini_cmd_walk_cb, idc,
1949 (uintptr_t)ini_conn.conn_queue_idm_aborting.head) == -1)) {
1950 mdb_warn("list walk failed for iscsi cmds");
1951 }
1952 }
1953
1954 /*
1955 * If connection information was handled unset header and
1956 * decrease indent
1957 */
1958 if (idc->u.child.idc_conn) {
1959 idc->idc_header = 0;
1960 mdb_dec_indent(4);
1961 }
1962
1963 idc->idc_verbose = verbose;
1964 idc->u.child.idc_states = states;
1965 idc->u.child.idc_rc_audit = rc_audit;
1966
1967 return (DCMD_OK);
1968 }
1969
1970 static int
1971 iscsi_svc_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
1972 {
1973 idm_svc_t svc;
1974 iser_svc_t iser_svc;
1975 uintptr_t rc_addr;
1976
1977 if (mdb_vread(&svc, sizeof (idm_svc_t), addr) !=
1978 sizeof (idm_svc_t)) {
1979 return (DCMD_ERR);
1980 }
1981
1982 if (idc->u.child.idc_svc) {
1983 if (idc->idc_verbose) {
1984 mdb_printf("Service %p\n", addr);
1985 mdb_printf("%20s: %d\n", "Port",
1986 svc.is_svc_req.sr_port);
1987 mdb_printf("%20s: %d\n", "Online",
1988 svc.is_online);
1989 mdb_printf("%20s: %p\n", "Socket Service",
1990 svc.is_so_svc);
1991 mdb_printf("%20s: %p\n", "iSER Service",
1992 svc.is_iser_svc);
1993 } else {
1994 if (idc->idc_header) {
1995 mdb_printf("%<u>%-?s %-8s %-8s%</u>\n",
1996 "idm_svc_t", "Port", "Online");
1997 idc->idc_header = 0;
1998 }
1999
2000 mdb_printf("%?p %-8d %-8d\n", addr,
2001 svc.is_svc_req.sr_port, svc.is_online);
2002 }
2003
2004 if (idc->u.child.idc_rc_audit) {
2005 (void) mdb_inc_indent(4);
2006 mdb_printf("Reference History(is_refcnt):\n");
2007 rc_addr = addr + offsetof(idm_svc_t, is_refcnt);
2008 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
2009 (void) mdb_dec_indent(4);
2010 return (DCMD_ERR);
2011 }
2012
2013 if (svc.is_iser_svc != NULL) {
2014 mdb_printf("Reference History"
2015 "(iser_svc is_refcnt):\n");
2016
2017 /* Sanity check the iser svc struct */
2018 if (mdb_vread(&iser_svc, sizeof (iser_svc_t),
2019 (uintptr_t)svc.is_iser_svc) !=
2020 sizeof (iser_svc_t)) {
2021 return (DCMD_ERR);
2022 }
2023
2024 rc_addr = (uintptr_t)svc.is_iser_svc +
2025 offsetof(iser_svc_t, is_refcnt);
2026
2027 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK) {
2028 return (DCMD_ERR);
2029 }
2030 }
2031 (void) mdb_dec_indent(4);
2032 }
2033 }
2034 return (DCMD_OK);
2035 }
2036
2037 static void
2038 iscsi_print_iscsit_conn_data(idm_conn_t *ic)
2039 {
2040 iscsit_conn_t ict;
2041 char *csg;
2042 char *nsg;
2043
2044 iscsi_print_idm_conn_data(ic);
2045
2046 if (mdb_vread(&ict, sizeof (iscsit_conn_t),
2047 (uintptr_t)ic->ic_handle) != sizeof (iscsit_conn_t)) {
2048 mdb_printf("**Failed to read conn private data\n");
2049 return;
2050 }
2051
2052 mdb_printf("%20s: %p\n", "iSCSIT TGT Conn",
2053 ic->ic_handle);
2054
2055 if (ict.ict_login_sm.icl_login_state != ILS_LOGIN_DONE) {
2056 switch (ict.ict_login_sm.icl_login_csg) {
2057 case ISCSI_SECURITY_NEGOTIATION_STAGE:
2058 csg = "Security";
2059 break;
2060 case ISCSI_OP_PARMS_NEGOTIATION_STAGE:
2061 csg = "Operational";
2062 break;
2063 case ISCSI_FULL_FEATURE_PHASE:
2064 csg = "FFP";
2065 break;
2066 default:
2067 csg = "Unknown";
2068 }
2069 switch (ict.ict_login_sm.icl_login_nsg) {
2070 case ISCSI_SECURITY_NEGOTIATION_STAGE:
2071 nsg = "Security";
2072 break;
2073 case ISCSI_OP_PARMS_NEGOTIATION_STAGE:
2074 nsg = "Operational";
2075 break;
2076 case ISCSI_FULL_FEATURE_PHASE:
2077 nsg = "FFP";
2078 break;
2079 default:
2080 nsg = "Unknown";
2081 }
2082 mdb_printf("%20s: %d\n", "Login State",
2083 ict.ict_login_sm.icl_login_state);
2084 mdb_printf("%20s: %d\n", "Login Last State",
2085 ict.ict_login_sm.icl_login_last_state);
2086 mdb_printf("%20s: %s\n", "CSG", csg);
2087 mdb_printf("%20s: %s\n", "NSG", nsg);
2088 mdb_printf("%20s: %d\n", "Transit",
2089 ict.ict_login_sm.icl_login_transit >> 7);
2090 mdb_printf("%20s: %p\n", "Request nvlist",
2091 ict.ict_login_sm.icl_request_nvlist);
2092 mdb_printf("%20s: %p\n", "Response nvlist",
2093 ict.ict_login_sm.icl_response_nvlist);
2094 mdb_printf("%20s: %p\n", "Negotiated nvlist",
2095 ict.ict_login_sm.icl_negotiated_values);
2096 if (ict.ict_login_sm.icl_login_state == ILS_LOGIN_ERROR) {
2097 mdb_printf("%20s: 0x%02x\n", "Error Class",
2098 ict.ict_login_sm.icl_login_resp_err_class);
2099 mdb_printf("%20s: 0x%02x\n", "Error Detail",
2100 ict.ict_login_sm.icl_login_resp_err_detail);
2101 }
2102 }
2103 mdb_printf("%20s: 0x%04x\n", "CID", ict.ict_cid);
2104 mdb_printf("%20s: 0x%08x\n", "StatSN", ict.ict_statsn);
2105 }
2106
2107 static void
2108 iscsi_print_ini_conn_data(idm_conn_t *ic)
2109 {
2110 iscsi_conn_t ini_conn;
2111
2112 iscsi_print_idm_conn_data(ic);
2113
2114 if (mdb_vread(&ini_conn, sizeof (iscsi_conn_t),
2115 (uintptr_t)ic->ic_handle) != sizeof (iscsi_conn_t)) {
2116 mdb_printf("Failed to read conn private data\n");
2117 return;
2118 }
2119
2120 mdb_printf("%20s: %p\n", "iSCSI Ini Conn",
2121 ic->ic_handle);
2122 mdb_printf("%20s: %p\n", "Parent Session",
2123 ini_conn.conn_sess);
2124 mdb_printf("%20s: %d\n", "Conn State",
2125 ini_conn.conn_state);
2126 mdb_printf("%20s: %d\n", "Last Conn State",
2127 ini_conn.conn_prev_state);
2128
2129 mdb_printf("%20s: %d\n", "Login Stage",
2130 ini_conn.conn_current_stage);
2131 mdb_printf("%20s: %d\n", "Next Login Stage",
2132 ini_conn.conn_next_stage);
2133
2134 mdb_printf("%20s: 0x%08x\n", "Expected StatSN",
2135 ini_conn.conn_expstatsn);
2136 mdb_printf("%20s: %p\n", "Active Queue Head",
2137 ini_conn.conn_queue_active.head);
2138 mdb_printf("%20s: %d\n", "Abort Queue Head",
2139 ini_conn.conn_queue_idm_aborting.head);
2140 }
2141
2142 static void
2143 iscsi_print_idm_conn_data(idm_conn_t *ic)
2144 {
2145 char laddr[PORTAL_STR_LEN];
2146 char raddr[PORTAL_STR_LEN];
2147
2148 sa_to_str(&ic->ic_laddr, laddr);
2149 sa_to_str(&ic->ic_raddr, raddr);
2150
2151 mdb_printf("%20s: %s\n", "Conn Type",
2152 ((ic->ic_conn_type == CONN_TYPE_TGT) ? "Target" :
2153 ((ic->ic_conn_type == CONN_TYPE_INI) ? "Initiator" :
2154 "Unknown")));
2155 if (ic->ic_conn_type == CONN_TYPE_TGT) {
2156 mdb_printf("%20s: %p\n", "Svc. Binding",
2157 ic->ic_svc_binding);
2158 }
2159 mdb_printf("%20s: %s\n", "Transport",
2160 (ic->ic_transport_type == IDM_TRANSPORT_TYPE_ISER) ? "ISER_IB" :
2161 (ic->ic_transport_type == IDM_TRANSPORT_TYPE_SOCKETS) ? "SOCKETS" :
2162 "N/A");
2163
2164 mdb_printf("%20s: %s\n", "Local IP", laddr);
2165 mdb_printf("%20s: %s\n", "Remote IP", raddr);
2166 mdb_printf("%20s: %d\n", "State",
2167 ic->ic_state);
2168 mdb_printf("%20s: %d\n", "Last State",
2169 ic->ic_last_state);
2170 mdb_printf("%20s: %d %s\n", "Refcount",
2171 ic->ic_refcnt.ir_refcnt,
2172 (ic->ic_refcnt.ir_waiting == REF_NOWAIT) ? "" :
2173 ((ic->ic_refcnt.ir_waiting == REF_WAIT_SYNC) ? "REF_WAIT_SYNC" :
2174 ((ic->ic_refcnt.ir_waiting == REF_WAIT_ASYNC) ? "REF_WAIT_ASYNC" :
2175 "UNKNOWN")));
2176 }
2177
2178 static int
2179 iscsi_i_task_impl(idm_task_t *idt, uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
2180 {
2181 uintptr_t list_addr, rc_addr;
2182 idm_conn_type_t conn_type;
2183 int verbose, states, rc_audit;
2184
2185 conn_type = idm_conn_type((uintptr_t)idt->idt_ic);
2186
2187 verbose = idc->idc_verbose;
2188 states = idc->u.child.idc_states;
2189 rc_audit = idc->u.child.idc_rc_audit;
2190
2191 if (idc->u.child.idc_task) {
2192 if (verbose) {
2193 mdb_printf("Task %p\n", addr);
2194 (void) mdb_inc_indent(2);
2195 if (conn_type == CONN_TYPE_TGT) {
2196 iscsi_print_iscsit_task_data(idt);
2197 }
2198 (void) mdb_dec_indent(2);
2199 } else {
2200 /* Print task data */
2201 if (idc->idc_header) {
2202 mdb_printf(
2203 "%<u>%-?s %-16s %-4s %-8s %-8s%</u>\n",
2204 "Tasks:", "State", "Ref",
2205 (conn_type == CONN_TYPE_TGT ? "TTT" :
2206 (conn_type == CONN_TYPE_INI ? "ITT" :
2207 "TT")), "Handle");
2208 }
2209 mdb_printf("%?p %-16s %04x %08x %08x\n", addr,
2210 idm_ts_name[idt->idt_state],
2211 idt->idt_refcnt.ir_refcnt,
2212 idt->idt_tt, idt->idt_client_handle);
2213 }
2214 }
2215 idc->idc_header = 0;
2216 idc->idc_verbose = 0;
2217
2218 /*
2219 * Print states if requested
2220 */
2221 #if 0
2222 if (states) {
2223 states_addr = addr + offsetof(idm_task_t, idt_state_audit);
2224
2225 (void) mdb_inc_indent(4);
2226 mdb_printf("State History(idt_state_audit):\n");
2227 if (iscsi_sm_audit_impl(states_addr) != DCMD_OK)
2228 return (DCMD_ERR);
2229
2230 /* Don't print state history for child objects */
2231 idc->u.child.idc_states = 0;
2232 (void) mdb_dec_indent(4);
2233 }
2234 #endif
2235
2236 /*
2237 * Print refcnt audit data if requested
2238 */
2239 if (rc_audit) {
2240 (void) mdb_inc_indent(4);
2241 mdb_printf("Reference History(idt_refcnt):\n");
2242 rc_addr = addr +
2243 offsetof(idm_task_t, idt_refcnt);
2244 if (iscsi_refcnt_impl(rc_addr) != DCMD_OK)
2245 return (DCMD_ERR);
2246
2247 /* Don't print audit data for child objects */
2248 idc->u.child.idc_rc_audit = 0;
2249 (void) mdb_dec_indent(4);
2250 }
2251
2252
2253 /*
2254 * Buffers are leaf objects and always get headers so the
2255 * user can discern between in and out buffers.
2256 */
2257 if (idc->u.child.idc_buffer) {
2258 /* Walk in buffer list */
2259 (void) mdb_inc_indent(2);
2260 mdb_printf("In buffers:\n");
2261 idc->idc_header = 1;
2262 (void) mdb_inc_indent(2);
2263 list_addr = addr + offsetof(idm_task_t, idt_inbufv);
2264 if (mdb_pwalk("list", iscsi_buffer_walk_cb, idc, list_addr) ==
2265 -1) {
2266 mdb_warn("list walk failed for task in buffers");
2267 (void) mdb_dec_indent(4);
2268 return (DCMD_ERR);
2269 }
2270 (void) mdb_dec_indent(2);
2271 /* Walk out buffer list */
2272 mdb_printf("Out buffers:\n");
2273 idc->idc_header = 1;
2274 (void) mdb_inc_indent(2);
2275 list_addr = addr + offsetof(idm_task_t, idt_outbufv);
2276 if (mdb_pwalk("list", iscsi_buffer_walk_cb, idc, list_addr) ==
2277 -1) {
2278 mdb_warn("list walk failed for task out buffers\n");
2279 (void) mdb_dec_indent(2);
2280 return (DCMD_ERR);
2281 }
2282 (void) mdb_dec_indent(4);
2283 }
2284
2285 idc->idc_verbose = verbose;
2286 idc->u.child.idc_states = states;
2287 idc->u.child.idc_rc_audit = rc_audit;
2288
2289 return (DCMD_OK);
2290 }
2291
2292 static int
2293 iscsi_task_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
2294 {
2295 idm_task_t idt;
2296
2297 /*
2298 * Read idm_conn_t
2299 */
2300 if (mdb_vread(&idt, sizeof (idm_task_t), addr) != sizeof (idm_task_t)) {
2301 return (DCMD_ERR);
2302 }
2303
2304 return (iscsi_i_task_impl(&idt, addr, idc));
2305 }
2306
2307 #define ISCSI_CDB_INDENT 16
2308
2309 static void
2310 iscsi_print_iscsit_task_data(idm_task_t *idt)
2311 {
2312 iscsit_task_t itask;
2313 boolean_t good_scsi_task = B_TRUE;
2314 scsi_task_t scsi_task;
2315
2316 if (mdb_vread(&itask, sizeof (iscsit_task_t),
2317 (uintptr_t)idt->idt_private) != sizeof (iscsit_task_t)) {
2318 mdb_printf("**Failed to read idt_private data\n");
2319 return;
2320 }
2321
2322 if (mdb_vread(&scsi_task, sizeof (scsi_task_t),
2323 (uintptr_t)itask.it_stmf_task) != sizeof (scsi_task_t)) {
2324 good_scsi_task = B_FALSE;
2325 }
2326
2327 mdb_printf("%20s: %s(%d)\n", "State",
2328 idt->idt_state > TASK_MAX_STATE ?
2329 "UNKNOWN" : idm_ts_name[idt->idt_state],
2330 idt->idt_state);
2331 mdb_printf("%20s: %d/%d\n", "STMF abort/IDM aborted",
2332 itask.it_stmf_abort, itask.it_aborted);
2333 mdb_printf("%20s: %p/%p/%p%s\n",
2334 "iscsit/STMF/LU", idt->idt_private,
2335 itask.it_stmf_task, good_scsi_task ? scsi_task.task_lu_private : 0,
2336 good_scsi_task ? "" : "**");
2337 if (good_scsi_task) {
2338 mdb_printf("%20s: %08x/%08x\n", "ITT/TTT",
2339 itask.it_itt, itask.it_ttt);
2340 mdb_printf("%20s: %08x\n", "CmdSN",
2341 itask.it_cmdsn);
2342 mdb_printf("%20s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
2343 "LU number",
2344 scsi_task.task_lun_no[0], scsi_task.task_lun_no[1],
2345 scsi_task.task_lun_no[2], scsi_task.task_lun_no[3],
2346 scsi_task.task_lun_no[4], scsi_task.task_lun_no[5],
2347 scsi_task.task_lun_no[6], scsi_task.task_lun_no[7]);
2348 mdb_printf(" CDB (%d bytes):\n",
2349 scsi_task.task_cdb_length);
2350 (void) mdb_inc_indent(ISCSI_CDB_INDENT);
2351 if (mdb_dumpptr((uintptr_t)scsi_task.task_cdb,
2352 scsi_task.task_cdb_length,
2353 MDB_DUMP_RELATIVE | MDB_DUMP_TRIM |
2354 MDB_DUMP_GROUP(1),
2355 (mdb_dumpptr_cb_t)mdb_vread, NULL)) {
2356 mdb_printf("** Invalid CDB addr (%p)\n",
2357 scsi_task.task_cdb);
2358 }
2359 (void) mdb_dec_indent(ISCSI_CDB_INDENT);
2360 mdb_printf("%20s: %d/%d\n", "STMF cur/max bufs",
2361 scsi_task.task_cur_nbufs,
2362 scsi_task.task_max_nbufs);
2363 mdb_printf("%20s: 0x%08x/0x%08x/0x%08x\n", "Bytes Exp/Cmd/Done",
2364 scsi_task.task_expected_xfer_length,
2365 scsi_task.task_cmd_xfer_length,
2366 scsi_task.task_nbytes_transferred);
2367 mdb_printf("%20s: 0x%x/0x%x\n", "TX-ini start/done",
2368 idt->idt_tx_to_ini_start,
2369 idt->idt_tx_to_ini_done);
2370 mdb_printf("%20s: 0x%x/0x%x\n", "RX-ini start/done",
2371 idt->idt_rx_from_ini_start,
2372 idt->idt_rx_from_ini_done);
2373 }
2374 }
2375
2376 static int
2377 iscsi_print_ini_lun(uintptr_t addr, const iscsi_lun_t *lun,
2378 iscsi_dcmd_ctrl_t *idc)
2379 {
2380
2381 if (idc->u.child.idc_lun) {
2382 if (idc->idc_header) {
2383 mdb_printf("%<u>%-?s %-5s %-10s%</u>\n",
2384 "iscsi_lun_t", "State", "Lun Number");
2385 idc->idc_header = 0;
2386 }
2387 mdb_printf("%?p %-5d %-10d\n", addr,
2388 lun->lun_state, lun->lun_num);
2389 }
2390 return (DCMD_OK);
2391 }
2392
2393 static int
2394 iscsi_print_ini_cmd(uintptr_t addr, const iscsi_cmd_t *cmd,
2395 iscsi_dcmd_ctrl_t *idc) {
2396
2397 uintptr_t states_addr;
2398
2399 if (idc->idc_header) {
2400 mdb_printf("%<u>%-?s %-?s %4s %6s/%-6s %-?s%</u>\n",
2401 "iscsi_cmd_t", "idm_task_t", "Type",
2402 "State", "Prev", "iscsi_lun_t");
2403 idc->idc_header = 0;
2404 }
2405
2406 mdb_printf("%?p %?p %4d %6d/%-6d %?p\n",
2407 addr, cmd->cmd_itp, cmd->cmd_type, cmd->cmd_state,
2408 cmd->cmd_prev_state, cmd->cmd_lun);
2409
2410 /*
2411 * Print states if requested
2412 */
2413 if (idc->u.child.idc_states) {
2414 states_addr = addr + offsetof(iscsi_cmd_t, cmd_state_audit);
2415
2416 (void) mdb_inc_indent(4);
2417 mdb_printf("State History(cmd_state_audit):\n");
2418 if (iscsi_sm_audit_impl(states_addr) != DCMD_OK)
2419 return (DCMD_ERR);
2420 idc->u.child.idc_states = 0;
2421 (void) mdb_dec_indent(4);
2422 }
2423 return (DCMD_OK);
2424 }
2425
2426 static int
2427 iscsi_buffer_impl(uintptr_t addr, iscsi_dcmd_ctrl_t *idc)
2428 {
2429 idm_buf_t idb;
2430
2431 /*
2432 * Read idm_buf_t
2433 */
2434 if (mdb_vread(&idb, sizeof (idm_buf_t), addr) != sizeof (idm_buf_t)) {
2435 return (DCMD_ERR);
2436 }
2437
2438
2439 if (idc->idc_header) {
2440 mdb_printf("%<u>%-?s %?s/%-8s %8s %8s %8s%</u>\n",
2441 "idm_buf_t", "Mem Rgn", "Length",
2442 "Rel Off", "Xfer Len", "Exp. Off");
2443 idc->idc_header = 0;
2444 }
2445
2446 /* Print buffer data */
2447 mdb_printf("%?p %?p/%08x %8x %8x %08x\n", addr,
2448 idb.idb_buf, idb.idb_buflen,
2449 idb.idb_bufoffset, idb.idb_xfer_len,
2450 idb.idb_exp_offset);
2451
2452
2453 /* Buffers are leaf objects */
2454
2455 return (DCMD_OK);
2456 }
2457
2458 static int
2459 iscsi_refcnt_impl(uintptr_t addr)
2460 {
2461 idm_refcnt_t refcnt;
2462 refcnt_audit_buf_t *anb;
2463 int ctr;
2464
2465 /*
2466 * Print refcnt info
2467 */
2468 if (mdb_vread(&refcnt, sizeof (idm_refcnt_t), addr) !=
2469 sizeof (idm_refcnt_t)) {
2470 mdb_warn("read refcnt failed");
2471 return (DCMD_ERR);
2472 }
2473
2474 anb = &refcnt.ir_audit_buf;
2475
2476 ctr = anb->anb_max_index + 1;
2477 anb->anb_index--;
2478 anb->anb_index &= anb->anb_max_index;
2479
2480 while (ctr) {
2481 refcnt_audit_record_t *anr;
2482
2483 anr = anb->anb_records + anb->anb_index;
2484
2485 if (anr->anr_depth) {
2486 char c[MDB_SYM_NAMLEN];
2487 GElf_Sym sym;
2488 int i;
2489
2490 mdb_printf("\nRefCnt: %u\t", anr->anr_refcnt);
2491
2492 for (i = 0; i < anr->anr_depth; i++) {
2493 if (mdb_lookup_by_addr(anr->anr_stack[i],
2494 MDB_SYM_FUZZY, c, sizeof (c),
2495 &sym) == -1) {
2496 continue;
2497 }
2498 mdb_printf("%s+0x%1x", c,
2499 anr->anr_stack[i] -
2500 (uintptr_t)sym.st_value);
2501 ++i;
2502 break;
2503 }
2504
2505 while (i < anr->anr_depth) {
2506 if (mdb_lookup_by_addr(anr->anr_stack[i],
2507 MDB_SYM_FUZZY, c, sizeof (c),
2508 &sym) == -1) {
2509 ++i;
2510 continue;
2511 }
2512 mdb_printf("\n\t\t%s+0x%1x", c,
2513 anr->anr_stack[i] -
2514 (uintptr_t)sym.st_value);
2515 ++i;
2516 }
2517 mdb_printf("\n");
2518 }
2519 anb->anb_index--;
2520 anb->anb_index &= anb->anb_max_index;
2521 ctr--;
2522 }
2523
2524 return (DCMD_OK);
2525 }
2526
2527 static int
2528 iscsi_sm_audit_impl(uintptr_t addr)
2529 {
2530 sm_audit_buf_t audit_buf;
2531 int ctr;
2532 const char *event_name;
2533 const char *state_name;
2534 const char *new_state_name;
2535 char ts_string[40];
2536 /*
2537 * Print refcnt info
2538 */
2539 if (mdb_vread(&audit_buf, sizeof (sm_audit_buf_t), addr) !=
2540 sizeof (sm_audit_buf_t)) {
2541 mdb_warn("failed to read audit buf");
2542 return (DCMD_ERR);
2543 }
2544
2545 ctr = audit_buf.sab_max_index + 1;
2546 audit_buf.sab_index++;
2547 audit_buf.sab_index &= audit_buf.sab_max_index;
2548
2549 while (ctr) {
2550 sm_audit_record_t *sar;
2551
2552 sar = audit_buf.sab_records + audit_buf.sab_index;
2553
2554 iscsi_format_timestamp(ts_string, 40, &sar->sar_timestamp);
2555
2556 switch (sar->sar_type) {
2557 case SAR_STATE_EVENT:
2558 switch (sar->sar_sm_type) {
2559 case SAS_IDM_CONN:
2560 state_name =
2561 iscsi_idm_conn_state(sar->sar_state);
2562 event_name =
2563 iscsi_idm_conn_event(sar->sar_event);
2564 break;
2565 case SAS_ISCSIT_TGT:
2566 state_name =
2567 iscsi_iscsit_tgt_state(sar->sar_state);
2568 event_name =
2569 iscsi_iscsit_tgt_event(sar->sar_event);
2570 break;
2571 case SAS_ISCSIT_SESS:
2572 state_name =
2573 iscsi_iscsit_sess_state(sar->sar_state);
2574 event_name =
2575 iscsi_iscsit_sess_event(sar->sar_event);
2576 break;
2577 case SAS_ISCSIT_LOGIN:
2578 state_name =
2579 iscsi_iscsit_login_state(sar->sar_state);
2580 event_name =
2581 iscsi_iscsit_login_event(sar->sar_event);
2582 break;
2583 case SAS_ISCSI_CMD:
2584 state_name =
2585 iscsi_iscsi_cmd_state(sar->sar_state);
2586 event_name=
2587 iscsi_iscsi_cmd_event(sar->sar_event);
2588 break;
2589 case SAS_ISCSI_SESS:
2590 state_name =
2591 iscsi_iscsi_sess_state(sar->sar_state);
2592 event_name=
2593 iscsi_iscsi_sess_event(sar->sar_event);
2594 break;
2595 case SAS_ISCSI_CONN:
2596 state_name =
2597 iscsi_iscsi_conn_state(sar->sar_state);
2598 event_name=
2599 iscsi_iscsi_conn_event(sar->sar_event);
2600 break;
2601 default:
2602 state_name = event_name = "N/A";
2603 break;
2604 }
2605 mdb_printf("%s|%s (%d)\n\t%9s %s (%d) %p\n",
2606 ts_string, state_name, sar->sar_state,
2607 "Event", event_name,
2608 sar->sar_event, sar->sar_event_info);
2609
2610 break;
2611 case SAR_STATE_CHANGE:
2612 switch (sar->sar_sm_type) {
2613 case SAS_IDM_CONN:
2614 state_name =
2615 iscsi_idm_conn_state(sar->sar_state);
2616 new_state_name =
2617 iscsi_idm_conn_state(sar->sar_new_state);
2618 break;
2619 case SAS_IDM_TASK:
2620 state_name =
2621 iscsi_idm_task_state(sar->sar_state);
2622 new_state_name =
2623 iscsi_idm_task_state(sar->sar_new_state);
2624 break;
2625 case SAS_ISCSIT_TGT:
2626 state_name =
2627 iscsi_iscsit_tgt_state(sar->sar_state);
2628 new_state_name =
2629 iscsi_iscsit_tgt_state(sar->sar_new_state);
2630 break;
2631 case SAS_ISCSIT_SESS:
2632 state_name =
2633 iscsi_iscsit_sess_state(sar->sar_state);
2634 new_state_name =
2635 iscsi_iscsit_sess_state(sar->sar_new_state);
2636 break;
2637 case SAS_ISCSIT_LOGIN:
2638 state_name =
2639 iscsi_iscsit_login_state(sar->sar_state);
2640 new_state_name =
2641 iscsi_iscsit_login_state(
2642 sar->sar_new_state);
2643 break;
2644 case SAS_ISCSI_CMD:
2645 state_name =
2646 iscsi_iscsi_cmd_state(sar->sar_state);
2647 new_state_name=
2648 iscsi_iscsi_cmd_state(sar->sar_new_state);
2649 break;
2650 case SAS_ISCSI_SESS:
2651 state_name =
2652 iscsi_iscsi_sess_state(sar->sar_state);
2653 new_state_name=
2654 iscsi_iscsi_sess_state(sar->sar_new_state);
2655 break;
2656 case SAS_ISCSI_CONN:
2657 state_name =
2658 iscsi_iscsi_conn_state(sar->sar_state);
2659 new_state_name=
2660 iscsi_iscsi_conn_state(sar->sar_new_state);
2661 break;
2662 case SAS_ISCSI_LOGIN:
2663 state_name =
2664 iscsi_iscsi_login_state(sar->sar_state);
2665 new_state_name=
2666 iscsi_iscsi_login_state(sar->sar_new_state);
2667 break;
2668 default:
2669 break;
2670 }
2671 mdb_printf("%s|%s (%d)\n\t%9s %s (%d)\n",
2672 ts_string, state_name, sar->sar_state,
2673 "New State", new_state_name, sar->sar_new_state);
2674 default:
2675 state_name = new_state_name = "N/A";
2676 break;
2677 }
2678
2679 audit_buf.sab_index++;
2680 audit_buf.sab_index &= audit_buf.sab_max_index;
2681 ctr--;
2682 }
2683
2684 return (DCMD_OK);
2685 }
2686
2687 static const char *
2688 iscsi_idm_conn_event(unsigned int event)
2689 {
2690 return ((event < CE_MAX_EVENT) ? idm_ce_name[event] : "N/A");
2691 }
2692
2693 static const char *
2694 iscsi_iscsit_tgt_event(unsigned int event)
2695 {
2696 return ((event < TE_MAX_EVENT) ? iscsit_te_name[event] : "N/A");
2697 }
2698
2699 static const char *
2700 iscsi_iscsit_sess_event(unsigned int event)
2701 {
2702 return ((event < SE_MAX_EVENT) ? iscsit_se_name[event] : "N/A");
2703 }
2704
2705 static const char *
2706 iscsi_iscsit_login_event(unsigned int event)
2707 {
2708 return ((event < ILE_MAX_EVENT) ? iscsit_ile_name[event] : "N/A");
2709 }
2710
2711 static const char *
2712 iscsi_iscsi_cmd_event(unsigned int event)
2713 {
2714 return ((event < ISCSI_CMD_EVENT_MAX) ?
2715 iscsi_cmd_event_names[event] : "N/A");
2716 }
2717
2718 static const char *
2719 iscsi_iscsi_sess_event(unsigned int event)
2720 {
2721
2722 return ((event < ISCSI_SESS_EVENT_MAX) ?
2723 iscsi_sess_event_names[event] : "N/A");
2724 }
2725
2726 static const char *
2727 iscsi_idm_conn_state(unsigned int state)
2728 {
2729 return ((state < CS_MAX_STATE) ? idm_cs_name[state] : "N/A");
2730 }
2731
2732 static const char *
2733 iscsi_iscsi_conn_event(unsigned int event)
2734 {
2735
2736 return ((event < CN_MAX) ? idm_cn_strings[event] : "N/A");
2737 }
2738
2739 /*ARGSUSED*/
2740 static const char *
2741 iscsi_idm_task_state(unsigned int state)
2742 {
2743 return ("N/A");
2744 }
2745
2746 static const char *
2747 iscsi_iscsit_tgt_state(unsigned int state)
2748 {
2749 return ((state < TS_MAX_STATE) ? iscsit_ts_name[state] : "N/A");
2750 }
2751
2752 static const char *
2753 iscsi_iscsit_sess_state(unsigned int state)
2754 {
2755 return ((state < SS_MAX_STATE) ? iscsit_ss_name[state] : "N/A");
2756 }
2757
2758 static const char *
2759 iscsi_iscsit_login_state(unsigned int state)
2760 {
2761 return ((state < ILS_MAX_STATE) ? iscsit_ils_name[state] : "N/A");
2762 }
2763
2764 static const char *
2765 iscsi_iscsi_cmd_state(unsigned int state)
2766 {
2767 return ((state < ISCSI_CMD_STATE_MAX) ?
2768 iscsi_cmd_state_names[state] : "N/A");
2769 }
2770
2771 static const char *
2772 iscsi_iscsi_sess_state(unsigned int state)
2773 {
2774 return ((state < ISCSI_SESS_STATE_MAX) ?
2775 iscsi_sess_state_names[state] : "N/A");
2776 }
2777
2778 static const char *
2779 iscsi_iscsi_conn_state(unsigned int state)
2780 {
2781 return ((state < ISCSI_CONN_STATE_MAX) ? iscsi_ics_name[state] : "N/A");
2782 }
2783
2784 static const char *
2785 iscsi_iscsi_login_state(unsigned int state)
2786 {
2787 return ((state < LOGIN_MAX) ? iscsi_login_state_names[state] : "N/A");
2788 }
2789
2790
2791 /*
2792 * Retrieve connection type given a kernel address
2793 */
2794 static idm_conn_type_t
2795 idm_conn_type(uintptr_t addr)
2796 {
2797 idm_conn_type_t result = 0; /* Unknown */
2798 uintptr_t idm_conn_type_addr;
2799
2800 idm_conn_type_addr = addr + offsetof(idm_conn_t, ic_conn_type);
2801 (void) mdb_vread(&result, sizeof (result), idm_conn_type_addr);
2802
2803 return (result);
2804 }
2805
2806 /*
2807 * Convert a sockaddr to the string representation, suitable for
2808 * storing in an nvlist or printing out in a list.
2809 */
2810 static int
2811 sa_to_str(struct sockaddr_storage *sa, char *buf)
2812 {
2813 char pbuf[7];
2814 const char *bufp;
2815 struct sockaddr_in *sin;
2816 struct sockaddr_in6 *sin6;
2817 uint16_t port;
2818
2819 if (!sa || !buf) {
2820 return (EINVAL);
2821 }
2822
2823 buf[0] = '\0';
2824
2825 if (sa->ss_family == AF_INET) {
2826 sin = (struct sockaddr_in *)sa;
2827 bufp = iscsi_inet_ntop(AF_INET,
2828 (const void *)&(sin->sin_addr.s_addr),
2829 buf, PORTAL_STR_LEN);
2830 if (bufp == NULL) {
2831 return (-1);
2832 }
2833 mdb_nhconvert(&port, &sin->sin_port, sizeof (uint16_t));
2834 } else if (sa->ss_family == AF_INET6) {
2835 strlcat(buf, "[", sizeof (buf));
2836 sin6 = (struct sockaddr_in6 *)sa;
2837 bufp = iscsi_inet_ntop(AF_INET6,
2838 (const void *)&sin6->sin6_addr.s6_addr,
2839 &buf[1], PORTAL_STR_LEN - 1);
2840 if (bufp == NULL) {
2841 return (-1);
2842 }
2843 strlcat(buf, "]", PORTAL_STR_LEN);
2844 mdb_nhconvert(&port, &sin6->sin6_port, sizeof (uint16_t));
2845 } else {
2846 return (EINVAL);
2847 }
2848
2849
2850 mdb_snprintf(pbuf, sizeof (pbuf), ":%u", port);
2851 strlcat(buf, pbuf, PORTAL_STR_LEN);
2852
2853 return (0);
2854 }
2855
2856
2857 static void
2858 iscsi_format_timestamp(char *ts_str, int strlen, timespec_t *ts)
2859 {
2860 mdb_snprintf(ts_str, strlen, "%Y:%03d:%03d:%03d", ts->tv_sec,
2861 (ts->tv_nsec / 1000000) % 1000, (ts->tv_nsec / 1000) % 1000,
2862 ts->tv_nsec % 1000);
2863 }
2864
2865 /*
2866 * Help information for the iscsi_isns dcmd
2867 */
2868 static void
2869 iscsi_isns_help(void)
2870 {
2871 mdb_printf("iscsi_isns:\n");
2872 mdb_inc_indent(4);
2873 mdb_printf("-e: Print ESI information\n");
2874 mdb_printf("-p: Print portal information\n");
2875 mdb_printf("-s: Print iSNS server information\n");
2876 mdb_printf("-t: Print target information\n");
2877 mdb_printf("-v: Add verbosity to the other options' output\n");
2878 mdb_printf("-R: Add Refcount information to '-t' output\n");
2879 mdb_dec_indent(4);
2880 }
2881
2882 /* ARGSUSED */
2883 static int
2884 iscsi_isns_esi_cb(uintptr_t addr, const void *walker_data, void *data)
2885 {
2886 isns_esi_tinfo_t tinfo;
2887
2888 if (mdb_vread(&tinfo, sizeof (isns_esi_tinfo_t), addr) !=
2889 sizeof (isns_esi_tinfo_t)) {
2890 return (WALK_ERR);
2891 }
2892
2893 mdb_printf("ESI thread/thr did : 0x%p / %d\n", tinfo.esi_thread,
2894 tinfo.esi_thread_did);
2895 mdb_printf("ESI sonode : 0x%p\n", tinfo.esi_so);
2896 mdb_printf("ESI port : %d\n", tinfo.esi_port);
2897 mdb_printf("ESI thread running : %s\n",
2898 (tinfo.esi_thread_running) ? "Yes" : "No");
2899
2900 return (WALK_NEXT);
2901 }
2902
2903 static int
2904 iscsi_isns_esi(iscsi_dcmd_ctrl_t *idc)
2905 {
2906 GElf_Sym sym;
2907 uintptr_t addr;
2908
2909 if (mdb_lookup_by_name("esi", &sym) == -1) {
2910 mdb_warn("failed to find symbol 'esi_list'");
2911 return (DCMD_ERR);
2912 }
2913 addr = (uintptr_t)sym.st_value;
2914
2915 idc->idc_header = 1;
2916 (void) iscsi_isns_esi_cb(addr, NULL, idc);
2917
2918 return (0);
2919 }
2920
2921 /* ARGSUSED */
2922 static int
2923 iscsi_isns_portal_cb(uintptr_t addr, const void *walker_data, void *data)
2924 {
2925 iscsi_dcmd_ctrl_t *idc = (iscsi_dcmd_ctrl_t *)data;
2926 isns_portal_t portal;
2927 char portal_addr[PORTAL_STR_LEN];
2928 struct sockaddr_storage *ss;
2929 char ts_string[40];
2930
2931 if (mdb_vread(&portal, sizeof (isns_portal_t), addr) !=
2932 sizeof (isns_portal_t)) {
2933 return (WALK_ERR);
2934 }
2935
2936 ss = &portal.portal_addr;
2937 sa_to_str(ss, portal_addr);
2938 mdb_printf("Portal IP address ");
2939
2940 if (ss->ss_family == AF_INET) {
2941 mdb_printf("(v4): %s", portal_addr);
2942 } else {
2943 mdb_printf("(v6): %s", portal_addr);
2944 }
2945
2946 if (portal.portal_default == B_TRUE) {
2947 mdb_printf(" (Default portal)\n");
2948 } else {
2949 mdb_printf("\n");
2950 }
2951 if (portal.portal_iscsit != NULL) {
2952 mdb_printf("(Part of TPG: 0x%p)\n", portal.portal_iscsit);
2953 }
2954
2955 iscsi_format_timestamp(ts_string, 40, &portal.portal_esi_timestamp);
2956 mdb_printf("Portal ESI timestamp: %s\n\n", ts_string);
2957
2958 if ((portal.portal_iscsit != NULL) && (idc->idc_verbose)) {
2959 mdb_inc_indent(4);
2960 iscsi_portal_impl((uintptr_t)portal.portal_iscsit, idc);
2961 mdb_dec_indent(4);
2962 }
2963
2964
2965 return (WALK_NEXT);
2966 }
2967
2968 static int
2969 iscsi_isns_portals(iscsi_dcmd_ctrl_t *idc)
2970 {
2971 GElf_Sym sym;
2972 uintptr_t portal_list;
2973
2974 mdb_printf("All Active Portals:\n");
2975
2976 if (mdb_lookup_by_name("isns_all_portals", &sym) == -1) {
2977 mdb_warn("failed to find symbol 'isns_all_portals'");
2978 return (DCMD_ERR);
2979 }
2980
2981 portal_list = (uintptr_t)sym.st_value;
2982 idc->idc_header = 1;
2983
2984 if (mdb_pwalk("avl", iscsi_isns_portal_cb, idc, portal_list) == -1) {
2985 mdb_warn("avl walk failed for isns_all_portals");
2986 return (DCMD_ERR);
2987 }
2988 mdb_printf("\nPortals from TPGs:\n");
2989
2990 if (mdb_lookup_by_name("isns_tpg_portals", &sym) == -1) {
2991 mdb_warn("failed to find symbol 'isns_tpg_portals'");
2992 return (DCMD_ERR);
2993 }
2994
2995 portal_list = (uintptr_t)sym.st_value;
2996 idc->idc_header = 1;
2997
2998 if (mdb_pwalk("avl", iscsi_isns_portal_cb, idc, portal_list) == -1) {
2999 mdb_warn("avl walk failed for isns_tpg_portals");
3000 return (DCMD_ERR);
3001 }
3002
3003
3004 return (0);
3005 }
3006
3007 /* ARGSUSED */
3008 static int
3009 iscsi_isns_targets_cb(uintptr_t addr, const void *walker_data, void *data)
3010 {
3011 iscsi_dcmd_ctrl_t *idc = (iscsi_dcmd_ctrl_t *)data;
3012 isns_target_t itarget;
3013 int rc = 0;
3014 int rc_audit = 0;
3015 uintptr_t rc_addr;
3016
3017 if (mdb_vread(&itarget, sizeof (isns_target_t), addr) !=
3018 sizeof (isns_target_t)) {
3019 return (WALK_ERR);
3020 }
3021
3022 idc->idc_header = 1;
3023 rc_audit = idc->u.child.idc_rc_audit;
3024
3025 mdb_printf("Target: %p\n", addr);
3026 mdb_inc_indent(4);
3027 mdb_printf("Registered: %s\n",
3028 (itarget.target_registered) ? "Yes" : "No");
3029 mdb_printf("Update needed: %s\n",
3030 (itarget.target_update_needed) ? "Yes" : "No");
3031 mdb_printf("Target Info: %p\n", itarget.target_info);
3032
3033 /* Prevent target refcounts from showing through this path */
3034 idc->u.child.idc_rc_audit = 0;
3035 rc = iscsi_tgt_impl((uintptr_t)itarget.target, idc);
3036
3037 idc->u.child.idc_rc_audit = rc_audit;
3038 if (idc->u.child.idc_rc_audit) {
3039 rc_addr = (uintptr_t)itarget.target_info +
3040 offsetof(isns_target_info_t, ti_refcnt);
3041
3042 mdb_printf("Reference History(isns_target_info ti_refcnt):\n");
3043 if (iscsi_refcnt_impl(rc_addr) != 0) {
3044 return (WALK_ERR);
3045 }
3046 }
3047
3048 mdb_dec_indent(4);
3049
3050 if (rc == DCMD_OK) {
3051 return (WALK_NEXT);
3052 }
3053
3054 return (WALK_ERR);
3055 }
3056
3057 static int
3058 iscsi_isns_targets(iscsi_dcmd_ctrl_t *idc)
3059 {
3060 GElf_Sym sym;
3061 uintptr_t isns_target_list;
3062
3063 if (mdb_lookup_by_name("isns_target_list", &sym) == -1) {
3064 mdb_warn("failed to find symbol 'isns_target_list'");
3065 return (DCMD_ERR);
3066 }
3067
3068 isns_target_list = (uintptr_t)sym.st_value;
3069 idc->idc_header = 1;
3070 idc->u.child.idc_tgt = 1;
3071
3072 if (mdb_pwalk("avl", iscsi_isns_targets_cb, idc,
3073 isns_target_list) == -1) {
3074 mdb_warn("avl walk failed for isns_target_list");
3075 return (DCMD_ERR);
3076 }
3077
3078 return (0);
3079 }
3080
3081 /* ARGSUSED */
3082 static int
3083 iscsi_isns_servers_cb(uintptr_t addr, const void *walker_data, void *data)
3084 {
3085 iscsit_isns_svr_t server;
3086 char server_addr[PORTAL_STR_LEN];
3087 struct sockaddr_storage *ss;
3088 clock_t lbolt;
3089 iscsi_dcmd_ctrl_t *idc = (iscsi_dcmd_ctrl_t *)data;
3090 uintptr_t avl_addr;
3091
3092 if (mdb_vread(&server, sizeof (iscsit_isns_svr_t), addr) !=
3093 sizeof (iscsit_isns_svr_t)) {
3094 return (WALK_ERR);
3095 }
3096
3097 if ((lbolt = (clock_t)mdb_get_lbolt()) == -1)
3098 return (WALK_ERR);
3099
3100 mdb_printf("iSNS server %p:\n", addr);
3101 mdb_inc_indent(4);
3102 ss = &server.svr_sa;
3103 sa_to_str(ss, server_addr);
3104
3105 mdb_printf("IP address ");
3106 if (ss->ss_family == AF_INET) {
3107 mdb_printf("(v4): %s\n", server_addr);
3108 } else {
3109 mdb_printf("(v6): %s\n", server_addr);
3110 }
3111
3112 mdb_printf("ESI Interval: %d seconds\n",
3113 server.svr_esi_interval);
3114 mdb_printf("Last message: %d seconds ago\n",
3115 ((lbolt - server.svr_last_msg) / 100));
3116 mdb_printf("Client registered: %s\n",
3117 (server.svr_registered) ? "Yes" : "No");
3118 mdb_printf("Retry Count: %d\n",
3119 server.svr_retry_count);
3120 mdb_printf("Targets Changes Pending: %s\n",
3121 (server.svr_targets_changed) ? "Yes" : "No");
3122 mdb_printf("Delete Pending: %s\n",
3123 (server.svr_delete_needed) ? "Yes" : "No");
3124 mdb_printf("Replace-All Needed: %s\n",
3125 (server.svr_reset_needed) ? "Yes" : "No");
3126
3127 if (idc->idc_verbose) {
3128 idc->idc_header = 1;
3129 idc->u.child.idc_tgt = 1;
3130
3131 mdb_inc_indent(2);
3132 avl_addr = addr + offsetof(iscsit_isns_svr_t,
3133 svr_target_list);
3134 if (mdb_pwalk("avl", iscsi_isns_targets_cb, idc,
3135 avl_addr) == -1) {
3136 mdb_warn("avl walk failed for svr_target_list");
3137 return (WALK_ERR);
3138 }
3139 mdb_dec_indent(2);
3140 }
3141
3142 mdb_dec_indent(4);
3143
3144 return (WALK_NEXT);
3145 }
3146
3147 static int
3148 iscsi_isns_servers(iscsi_dcmd_ctrl_t *idc)
3149 {
3150 uintptr_t iscsit_global_addr;
3151 uintptr_t list_addr;
3152 GElf_Sym sym;
3153
3154 if (mdb_lookup_by_name("iscsit_global", &sym) == -1) {
3155 mdb_warn("failed to find symbol 'iscsit_global'");
3156 return (DCMD_ERR);
3157 }
3158
3159 iscsit_global_addr = (uintptr_t)sym.st_value;
3160 idc->idc_header = 1;
3161 list_addr = iscsit_global_addr +
3162 offsetof(iscsit_global_t, global_isns_cfg.isns_svrs);
3163
3164 if (mdb_pwalk("list", iscsi_isns_servers_cb, idc, list_addr) == -1) {
3165 mdb_warn("list walk failed for iSNS servers");
3166 return (DCMD_ERR);
3167 }
3168
3169 return (0);
3170 }
3171
3172 /* ARGSUSED */
3173 static int
3174 iscsi_isns(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3175 {
3176 iscsi_dcmd_ctrl_t idc;
3177 int portals = 0, esi = 0, targets = 0, verbose = 0, servers = 0;
3178 int rc_audit = 0;
3179
3180 if (flags & DCMD_ADDRSPEC) {
3181 mdb_warn("iscsi_isns is only a global dcmd.");
3182 return (DCMD_ERR);
3183 }
3184
3185 bzero(&idc, sizeof (idc));
3186 if (mdb_getopts(argc, argv,
3187 'e', MDB_OPT_SETBITS, TRUE, &esi,
3188 'p', MDB_OPT_SETBITS, TRUE, &portals,
3189 's', MDB_OPT_SETBITS, TRUE, &servers,
3190 't', MDB_OPT_SETBITS, TRUE, &targets,
3191 'v', MDB_OPT_SETBITS, TRUE, &verbose,
3192 'R', MDB_OPT_SETBITS, TRUE, &rc_audit,
3193 NULL) != argc)
3194 return (DCMD_USAGE);
3195
3196 if ((esi + portals + targets + servers) > 1) {
3197 mdb_printf("Only one of e, p, s, and t must be provided");
3198 return (DCMD_ERR);
3199 }
3200
3201 if ((esi | portals | targets | servers) == 0) {
3202 mdb_printf("Exactly one of e, p, s, or t must be provided");
3203 return (DCMD_ERR);
3204 }
3205
3206 idc.idc_verbose = verbose;
3207 idc.u.child.idc_rc_audit = rc_audit;
3208
3209 if (esi) {
3210 return (iscsi_isns_esi(&idc));
3211 }
3212
3213 if (portals) {
3214 return (iscsi_isns_portals(&idc));
3215 }
3216
3217 if (servers) {
3218 return (iscsi_isns_servers(&idc));
3219 }
3220
3221 return (iscsi_isns_targets(&idc));
3222 }
3223
3224 static int
3225 iscsi_ini_sess_walk_init(mdb_walk_state_t *wsp) {
3226
3227
3228 if (wsp->walk_addr == NULL) {
3229 mdb_warn("<iscsi_sess_t addr>::walk iscsi_ini_sess");
3230 return (WALK_ERR);
3231 }
3232
3233 wsp->walk_data = mdb_alloc(sizeof (iscsi_sess_t), UM_SLEEP|UM_GC);
3234 if (!wsp->walk_data) {
3235 mdb_warn("iscsi_ini_sess walk failed");
3236 return (WALK_ERR);
3237 }
3238
3239 return (WALK_NEXT);
3240 }
3241
3242 static int
3243 iscsi_ini_sess_step(mdb_walk_state_t *wsp) {
3244 int status;
3245
3246 if (wsp->walk_addr == NULL) {
3247 return (WALK_DONE);
3248 }
3249
3250 if (mdb_vread(wsp->walk_data, sizeof (iscsi_sess_t), wsp->walk_addr)
3251 != sizeof (iscsi_sess_t)) {
3252 mdb_warn("failed to read iscsi_sess_t at %p", wsp->walk_addr);
3253 return (WALK_DONE);
3254 }
3255
3256 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
3257 wsp->walk_cbdata);
3258
3259 wsp->walk_addr =
3260 (uintptr_t)(((iscsi_sess_t *)wsp->walk_data)->sess_next);
3261
3262 return (status);
3263 }
3264
3265 static int
3266 iscsi_ini_conn_walk_init(mdb_walk_state_t *wsp) {
3267
3268 if (wsp->walk_addr == NULL) {
3269 mdb_warn("<iscsi_conn_t addr>::walk iscsi_ini_conn");
3270 return (WALK_DONE);
3271 }
3272
3273 wsp->walk_data = mdb_alloc(sizeof (iscsi_conn_t), UM_SLEEP|UM_GC);
3274 if (!wsp->walk_data) {
3275 mdb_warn("iscsi_ini_conn walk failed");
3276 return (WALK_ERR);
3277 }
3278
3279 return (WALK_NEXT);
3280 }
3281
3282 static int
3283 iscsi_ini_conn_step(mdb_walk_state_t *wsp) {
3284 int status;
3285
3286 if (wsp->walk_addr == NULL) {
3287 return (WALK_DONE);
3288 }
3289
3290 if (mdb_vread(wsp->walk_data, sizeof (iscsi_conn_t), wsp->walk_addr)
3291 != sizeof (iscsi_conn_t)) {
3292 mdb_warn("failed to read iscsi_conn_t at %p", wsp->walk_addr);
3293 return (WALK_DONE);
3294 }
3295
3296
3297 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
3298 wsp->walk_cbdata);
3299
3300 wsp->walk_addr =
3301 (uintptr_t)(((iscsi_conn_t *)wsp->walk_data)->conn_next);
3302
3303 return (status);
3304 }
3305
3306 static int
3307 iscsi_ini_lun_walk_init(mdb_walk_state_t *wsp) {
3308
3309 if (wsp->walk_addr == NULL) {
3310 mdb_warn("<iscsi_lun_t addr>::walk iscsi_ini_lun");
3311 return (WALK_DONE);
3312 }
3313
3314 wsp->walk_data = mdb_alloc(sizeof (iscsi_lun_t), UM_SLEEP|UM_GC);
3315 if (!wsp->walk_data) {
3316 return (WALK_ERR);
3317 }
3318
3319 return (WALK_NEXT);
3320 }
3321
3322 static int
3323 iscsi_ini_lun_step(mdb_walk_state_t *wsp) {
3324 int status;
3325
3326 if (wsp->walk_addr == NULL) {
3327 return (WALK_DONE);
3328 }
3329
3330 if (mdb_vread(wsp->walk_data, sizeof (iscsi_lun_t), wsp->walk_addr)
3331 != sizeof (iscsi_lun_t)) {
3332 mdb_warn("failed to read iscsi_lun_t at %p", wsp->walk_addr);
3333 return (WALK_DONE);
3334 }
3335
3336 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
3337 wsp->walk_cbdata);
3338
3339 wsp->walk_addr =
3340 (uintptr_t)(((iscsi_lun_t *)wsp->walk_data)->lun_next);
3341
3342 return (status);
3343 }
3344
3345 static int
3346 iscsi_ini_cmd_walk_init(mdb_walk_state_t *wsp) {
3347
3348 if (wsp->walk_addr == NULL) {
3349 mdb_warn("<iscsi_cmd_t addr>::walk iscsi_ini_cmd");
3350 return (WALK_DONE);
3351 }
3352
3353 wsp->walk_data = mdb_alloc(sizeof (iscsi_cmd_t), UM_SLEEP|UM_GC);
3354 if (!wsp->walk_data) {
3355 return (WALK_ERR);
3356 }
3357
3358 return (WALK_NEXT);
3359 }
3360
3361 static int
3362 iscsi_ini_cmd_step(mdb_walk_state_t *wsp) {
3363 int status;
3364
3365 if (wsp->walk_addr == NULL) {
3366 return (WALK_DONE);
3367 }
3368
3369 if (mdb_vread(wsp->walk_data, sizeof (iscsi_cmd_t), wsp->walk_addr)
3370 != sizeof (iscsi_cmd_t)) {
3371 mdb_warn("failed to read iscsi_cmd_t at %p", wsp->walk_addr);
3372 return (WALK_DONE);
3373 }
3374
3375 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
3376 wsp->walk_cbdata);
3377
3378 wsp->walk_addr =
3379 (uintptr_t)(((iscsi_cmd_t *)wsp->walk_data)->cmd_next);
3380
3381 return (status);
3382 }
3383
3384 static int
3385 iscsi_ini_cmd_walk_cb(uintptr_t addr, const void *vcmd,
3386 void *vidc) {
3387
3388 const iscsi_cmd_t *cmd = vcmd;
3389 iscsi_dcmd_ctrl_t *idc = vidc;
3390 int rc;
3391
3392 if (cmd == NULL) {
3393 mdb_warn("list walk failed. Null cmd");
3394 return (WALK_ERR);
3395 }
3396
3397 rc = iscsi_print_ini_cmd(addr, cmd, idc);
3398
3399 return ((rc == DCMD_OK) ? WALK_NEXT : WALK_ERR);
3400 }
3401
3402 static int
3403 iscsi_ini_hba_walk_init(mdb_walk_state_t *wsp) {
3404 uintptr_t state_addr, array_addr;
3405 int array_size;
3406 struct i_ddi_soft_state *ss;
3407 idm_hba_walk_info_t *hwi;
3408
3409
3410 hwi = (idm_hba_walk_info_t *)mdb_zalloc(
3411 sizeof (idm_hba_walk_info_t), UM_SLEEP|UM_GC);
3412
3413 if (!hwi) {
3414 mdb_warn("unable to allocate storage for iscsi_ini_hba walk");
3415 return (WALK_ERR);
3416 }
3417
3418 if (wsp->walk_addr != NULL) {
3419 mdb_warn("iscsi_ini_hba only supports global walk");
3420 return (WALK_ERR);
3421 } else {
3422
3423 /*
3424 * Read in the array and setup the walk struct.
3425 */
3426 if (mdb_readvar(&state_addr, "iscsi_state") == -1) {
3427 mdb_warn("state variable iscsi_state not found.\n");
3428 mdb_warn("Is the driver loaded ?\n");
3429 return (WALK_ERR);
3430 }
3431
3432 ss = (struct i_ddi_soft_state *)mdb_alloc(sizeof (*ss),
3433 UM_SLEEP|UM_GC);
3434 if (mdb_vread(ss, sizeof (*ss), state_addr) != sizeof (*ss)) {
3435 mdb_warn("Cannot read softstate struct "
3436 "(Invalid pointer?).\n");
3437 return (WALK_ERR);
3438 }
3439
3440 /* Where to get the data */
3441 array_size = ss->n_items * (sizeof (void *));
3442 array_addr = (uintptr_t)ss->array;
3443
3444 /* Where to put the data */
3445 hwi->n_elements = ss->n_items;
3446 hwi->array = mdb_alloc(array_size, UM_SLEEP|UM_GC);
3447 if (!hwi->array) {
3448 mdb_warn("list walk failed");
3449 return (WALK_ERR);
3450 }
3451 if (mdb_vread(hwi->array, array_size, array_addr) !=
3452 array_size) {
3453 mdb_warn("Corrupted softstate struct.\n");
3454 return (WALK_ERR);
3455 }
3456 hwi->cur_element = 0;
3457 wsp->walk_data = hwi;
3458 }
3459
3460 return (WALK_NEXT);
3461 }
3462
3463 static int
3464 iscsi_ini_hba_step(mdb_walk_state_t *wsp) {
3465 int status;
3466 idm_hba_walk_info_t *hwi = (idm_hba_walk_info_t *)wsp->walk_data;
3467
3468 for (; hwi->cur_element < hwi->n_elements; hwi->cur_element++) {
3469 if (hwi->array[hwi->cur_element] != NULL) {
3470 break;
3471 }
3472 }
3473 if (hwi->cur_element >= hwi->n_elements) {
3474 return (WALK_DONE);
3475 }
3476
3477 hwi->data = (iscsi_hba_t *)mdb_alloc(sizeof (iscsi_hba_t),
3478 UM_SLEEP|UM_GC);
3479 if (mdb_vread(hwi->data, sizeof (iscsi_hba_t),
3480 (uintptr_t)hwi->array[hwi->cur_element]) != sizeof (iscsi_hba_t)) {
3481 mdb_warn("failed to read iscsi_sess_t at %p", wsp->walk_addr);
3482 return (WALK_DONE);
3483 }
3484
3485
3486 status = wsp->walk_callback((uintptr_t)hwi->array[hwi->cur_element],
3487 hwi->data, wsp->walk_cbdata);
3488
3489 /* Increment cur_element for next iteration */
3490 hwi->cur_element++;
3491
3492 return (status);
3493 }
3494
3495 /*
3496 * iscsi_inet_ntop -- Convert an IPv4 or IPv6 address in binary form into
3497 * printable form, and return a pointer to that string. Caller should
3498 * provide a buffer of correct length to store string into.
3499 * Note: this routine is kernel version of inet_ntop. It has similar
3500 * format as iscsi_inet_ntop() defined in rfc2553. But it does not do
3501 * error handling operations exactly as rfc2553 defines. This function
3502 * is used by kernel inet directory routines only for debugging.
3503 * This iscsi_inet_ntop() function, does not return NULL if third argument
3504 * is NULL. The reason is simple that we don't want kernel to panic
3505 * as the output of this function is directly fed to ip<n>dbg macro.
3506 * Instead it uses a local buffer for destination address for
3507 * those calls which purposely pass NULL ptr for the destination
3508 * buffer. This function is thread-safe when the caller passes a non-
3509 * null buffer with the third argument.
3510 */
3511 /* ARGSUSED */
3512
3513 #define OK_16PTR(p) (!((uintptr_t)(p) & 0x1))
3514 #if defined(__x86)
3515 #define OK_32PTR(p) OK_16PTR(p)
3516 #else
3517 #define OK_32PTR(p) (!((uintptr_t)(p) & 0x3))
3518 #endif
3519
3520 char *
3521 iscsi_inet_ntop(int af, const void *addr, char *buf, int addrlen)
3522 {
3523 static char local_buf[PORTAL_STR_LEN];
3524 static char *err_buf1 = "<badaddr>";
3525 static char *err_buf2 = "<badfamily>";
3526 in6_addr_t *v6addr;
3527 uchar_t *v4addr;
3528 char *caddr;
3529
3530 /*
3531 * We don't allow thread unsafe iscsi_inet_ntop calls, they
3532 * must pass a non-null buffer pointer. For DEBUG mode
3533 * we use the ASSERT() and for non-debug kernel it will
3534 * silently allow it for now. Someday we should remove
3535 * the static buffer from this function.
3536 */
3537
3538 ASSERT(buf != NULL);
3539 if (buf == NULL)
3540 buf = local_buf;
3541 buf[0] = '\0';
3542
3543 /* Let user know politely not to send NULL or unaligned addr */
3544 if (addr == NULL || !(OK_32PTR(addr))) {
3545 return (err_buf1);
3546 }
3547
3548
3549 #define UC(b) (((int)b) & 0xff)
3550 switch (af) {
3551 case AF_INET:
3552 ASSERT(addrlen >= INET_ADDRSTRLEN);
3553 v4addr = (uchar_t *)addr;
3554 (void) mdb_snprintf(buf, INET6_ADDRSTRLEN,
3555 "%03d.%03d.%03d.%03d",
3556 UC(v4addr[0]), UC(v4addr[1]), UC(v4addr[2]), UC(v4addr[3]));
3557 return (buf);
3558
3559 case AF_INET6:
3560 ASSERT(addrlen >= INET6_ADDRSTRLEN);
3561 v6addr = (in6_addr_t *)addr;
3562 if (IN6_IS_ADDR_V4MAPPED(v6addr)) {
3563 caddr = (char *)addr;
3564 (void) mdb_snprintf(buf, INET6_ADDRSTRLEN,
3565 "::ffff:%d.%d.%d.%d",
3566 UC(caddr[12]), UC(caddr[13]),
3567 UC(caddr[14]), UC(caddr[15]));
3568 } else if (IN6_IS_ADDR_V4COMPAT(v6addr)) {
3569 caddr = (char *)addr;
3570 (void) mdb_snprintf(buf, INET6_ADDRSTRLEN,
3571 "::%d.%d.%d.%d",
3572 UC(caddr[12]), UC(caddr[13]), UC(caddr[14]),
3573 UC(caddr[15]));
3574 } else if (IN6_IS_ADDR_UNSPECIFIED(v6addr)) {
3575 (void) mdb_snprintf(buf, INET6_ADDRSTRLEN, "::");
3576 } else {
3577 convert2ascii(buf, v6addr);
3578 }
3579 return (buf);
3580
3581 default:
3582 return (err_buf2);
3583 }
3584 #undef UC
3585 }
3586
3587 /*
3588 *
3589 * v6 formats supported
3590 * General format xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx
3591 * The short hand notation :: is used for COMPAT addr
3592 * Other forms : fe80::xxxx:xxxx:xxxx:xxxx
3593 */
3594 static void
3595 convert2ascii(char *buf, const in6_addr_t *addr)
3596 {
3597 int hexdigits;
3598 int head_zero = 0;
3599 int tail_zero = 0;
3600 /* tempbuf must be big enough to hold ffff:\0 */
3601 char tempbuf[6];
3602 char *ptr;
3603 uint16_t out_addr_component;
3604 uint16_t *addr_component;
3605 size_t len;
3606 boolean_t first = B_FALSE;
3607 boolean_t med_zero = B_FALSE;
3608 boolean_t end_zero = B_FALSE;
3609
3610 addr_component = (uint16_t *)addr;
3611 ptr = buf;
3612
3613 /* First count if trailing zeroes higher in number */
3614 for (hexdigits = 0; hexdigits < 8; hexdigits++) {
3615 if (*addr_component == 0) {
3616 if (hexdigits < 4)
3617 head_zero++;
3618 else
3619 tail_zero++;
3620 }
3621 addr_component++;
3622 }
3623 addr_component = (uint16_t *)addr;
3624 if (tail_zero > head_zero && (head_zero + tail_zero) != 7)
3625 end_zero = B_TRUE;
3626
3627 for (hexdigits = 0; hexdigits < 8; hexdigits++) {
3628
3629 /* if entry is a 0 */
3630
3631 if (*addr_component == 0) {
3632 if (!first && *(addr_component + 1) == 0) {
3633 if (end_zero && (hexdigits < 4)) {
3634 *ptr++ = '0';
3635 *ptr++ = ':';
3636 } else {
3637 /*
3638 * address starts with 0s ..
3639 * stick in leading ':' of pair
3640 */
3641 if (hexdigits == 0)
3642 *ptr++ = ':';
3643 /* add another */
3644 *ptr++ = ':';
3645 first = B_TRUE;
3646 med_zero = B_TRUE;
3647 }
3648 } else if (first && med_zero) {
3649 if (hexdigits == 7)
3650 *ptr++ = ':';
3651 addr_component++;
3652 continue;
3653 } else {
3654 *ptr++ = '0';
3655 *ptr++ = ':';
3656 }
3657 addr_component++;
3658 continue;
3659 }
3660 if (med_zero)
3661 med_zero = B_FALSE;
3662
3663 tempbuf[0] = '\0';
3664 mdb_nhconvert(&out_addr_component, addr_component,
3665 sizeof (uint16_t));
3666 (void) mdb_snprintf(tempbuf, 6, "%x:", out_addr_component);
3667 len = strlen(tempbuf);
3668 bcopy(tempbuf, ptr, len);
3669 ptr = ptr + len;
3670 addr_component++;
3671 }
3672 *--ptr = '\0';
3673 }
3674
3675 /*
3676 * MDB module linkage information:
3677 *
3678 * We declare a list of structures describing our dcmds, a list of structures
3679 * describing our walkers and a function named _mdb_init to return a pointer
3680 * to our module information.
3681 */
3682 static const mdb_dcmd_t dcmds[] = {
3683 { "iscsi_tgt", "[-agscptbSRv]",
3684 "iSCSI target information", iscsi_tgt },
3685 { "iscsi_tpgt", "[-R]",
3686 "iSCSI target portal group tag information", iscsi_tpgt },
3687 { "iscsi_tpg", "[-R]",
3688 "iSCSI target portal group information", iscsi_tpg },
3689 { "iscsi_sess", "[-ablmtvcSRIT]",
3690 "iSCSI session information", iscsi_sess },
3691 { "iscsi_conn", "[-abmtvSRIT]",
3692 "iSCSI connection information", iscsi_conn },
3693 { "iscsi_task", "[-bSRv]",
3694 "iSCSI task information", iscsi_task },
3695 { "iscsi_refcnt", "",
3696 "print audit informtion for idm_refcnt_t", iscsi_refcnt },
3697 { "iscsi_states", "",
3698 "dump events and state transitions recorded in an\t"
3699 "\t\tidm_sm_audit_t structure", iscsi_states },
3700 { "iscsi_isns", "[-epstvR]",
3701 "print iscsit iSNS information", iscsi_isns, iscsi_isns_help },
3702 { "iscsi_svc", "[-vR]",
3703 "iSCSI service information", iscsi_svc },
3704 { "iscsi_portal", "[-R]",
3705 "iSCSI portal information", iscsi_portal },
3706 { "iscsi_cmd", "[-S]",
3707 "iSCSI command information (initiator only)", iscsi_cmd },
3708 { NULL }
3709 };
3710
3711 /*
3712 * Basic walkers for the initiator linked lists
3713 */
3714 static const mdb_walker_t walkers[] = {
3715 { "iscsi_ini_hba", "global walk of the initiator iscsi_hba_t "
3716 "list", iscsi_ini_hba_walk_init, iscsi_ini_hba_step, NULL},
3717 { "iscsi_ini_sess", "walk list of initiator iscsi_sess_t structures",
3718 iscsi_ini_sess_walk_init, iscsi_ini_sess_step, NULL },
3719 { "iscsi_ini_conn", "walk list of initiator iscsi_conn_t structures",
3720 iscsi_ini_conn_walk_init, iscsi_ini_conn_step, NULL },
3721 { "iscsi_ini_lun", "walk list of initiator iscsi_lun_t structures",
3722 iscsi_ini_lun_walk_init, iscsi_ini_lun_step, NULL },
3723 { "iscsi_ini_cmd", "walk list of initiator iscsi_cmd_t structures",
3724 iscsi_ini_cmd_walk_init, iscsi_ini_cmd_step, NULL },
3725 { NULL }
3726 };
3727
3728 static const mdb_modinfo_t modinfo = {
3729 MDB_API_VERSION, dcmds, walkers
3730 };
3731
3732 const mdb_modinfo_t *
3733 _mdb_init(void)
3734 {
3735 return (&modinfo);
3736 }
unleashed repo fork