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 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 *
25 * FCP mdb module
26 */
27
28
29 #include <sys/mdb_modapi.h>
30 #include <sys/mutex.h>
31 #include <sys/modctl.h>
32 #include <sys/scsi/scsi.h>
33 #include <sys/sunndi.h>
34 #include <sys/fibre-channel/fc.h>
35 #include <sys/fibre-channel/ulp/fcpvar.h>
36
37 static struct fcp_port port;
38 static struct fcp_tgt tgt;
39 static struct fcp_lun lun;
40 static uint32_t tgt_hash_index;
41
42
43 /*
44 * Leadville fcp walker/dcmd code
45 */
46
47 static int
fcp_walk_i(mdb_walk_state_t * wsp)48 fcp_walk_i(mdb_walk_state_t *wsp)
49 {
50 if (wsp->walk_addr == NULL &&
51 mdb_readvar(&wsp->walk_addr, "fcp_port_head") == -1) {
52 mdb_warn("failed to read 'fcp_port_head'");
53 return (WALK_ERR);
54 }
55
56 wsp->walk_data = mdb_alloc(sizeof (struct fcp_port), UM_SLEEP);
57 return (WALK_NEXT);
58 }
59
60 static int
fcp_walk_s(mdb_walk_state_t * wsp)61 fcp_walk_s(mdb_walk_state_t *wsp)
62 {
63 int status;
64
65 if (wsp->walk_addr == NULL)
66 return (WALK_DONE);
67
68 if (mdb_vread(wsp->walk_data, sizeof (struct fcp_port),
69 wsp->walk_addr) == -1) {
70 mdb_warn("failed to read fcp_port at %p", wsp->walk_addr);
71 return (WALK_DONE);
72 }
73
74 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
75 wsp->walk_cbdata);
76
77 wsp->walk_addr =
78 (uintptr_t)(((struct fcp_port *)wsp->walk_data)->port_next);
79
80 return (status);
81 }
82
83 /*
84 * The walker's fini function is invoked at the end of each walk.
85 */
86 static void
fcp_walk_f(mdb_walk_state_t * wsp)87 fcp_walk_f(mdb_walk_state_t *wsp)
88 {
89 mdb_free(wsp->walk_data, sizeof (struct fcp_port));
90 }
91
92
93 static int
fcp(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)94 fcp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
95 {
96 struct fcp_port pinfo;
97
98 if (argc != 0) {
99 return (DCMD_USAGE);
100 }
101
102 if (!(flags & DCMD_ADDRSPEC)) {
103 if (mdb_walk_dcmd("fcp", "fcp",
104 argc, argv) == -1) {
105 mdb_warn("failed to walk 'fcp_port_head'");
106 return (DCMD_ERR);
107 }
108 return (DCMD_OK);
109 }
110
111 mdb_printf("FCP structure at %p\n", addr);
112
113 /*
114 * For each port, we just need to read the fc_fca_port_t struct, read
115 * the port_handle
116 */
117 if (mdb_vread(&pinfo, sizeof (struct fcp_port), addr) !=
118 sizeof (struct fcp_port)) {
119 mdb_warn("failed to read fcp_port at %p", addr);
120 return (DCMD_OK);
121 }
122
123 mdb_printf(" mutex : 0x%-08x\n", pinfo.port_mutex);
124 mdb_printf(" ipkt_list : 0x%p\n", pinfo.port_ipkt_list);
125 mdb_printf(" state : 0x%-08x\n", pinfo.port_state);
126 mdb_printf(" phys_state : 0x%-08x\n", pinfo.port_phys_state);
127 mdb_printf(" top : %u\n", pinfo.port_topology);
128 mdb_printf(" sid : 0x%-06x\n", pinfo.port_id);
129 mdb_printf(" reset_list : 0x%p\n", pinfo.port_reset_list);
130 mdb_printf(" link_cnt : %u\n", pinfo.port_link_cnt);
131 mdb_printf(" deadline : %d\n", pinfo.port_deadline);
132 mdb_printf(" port wwn : "
133 "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
134 pinfo.port_pwwn.raw_wwn[0], pinfo.port_pwwn.raw_wwn[1],
135 pinfo.port_pwwn.raw_wwn[2], pinfo.port_pwwn.raw_wwn[3],
136 pinfo.port_pwwn.raw_wwn[4], pinfo.port_pwwn.raw_wwn[5],
137 pinfo.port_pwwn.raw_wwn[6], pinfo.port_pwwn.raw_wwn[7]);
138 mdb_printf(" node wwn : "
139 "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
140 pinfo.port_nwwn.raw_wwn[0], pinfo.port_nwwn.raw_wwn[1],
141 pinfo.port_nwwn.raw_wwn[2], pinfo.port_nwwn.raw_wwn[3],
142 pinfo.port_nwwn.raw_wwn[4], pinfo.port_nwwn.raw_wwn[5],
143 pinfo.port_nwwn.raw_wwn[6], pinfo.port_nwwn.raw_wwn[7]);
144 mdb_printf(" handle : 0x%p\n", pinfo.port_fp_handle);
145 mdb_printf(" cmd_mutex : 0x%-08x\n", pinfo.port_pkt_mutex);
146 mdb_printf(" ncmds : %u\n", pinfo.port_npkts);
147 mdb_printf(" pkt_head : 0x%p\n", pinfo.port_pkt_head);
148 mdb_printf(" pkt_tail : 0x%p\n", pinfo.port_pkt_tail);
149 mdb_printf(" ipkt_cnt : %d\n", pinfo.port_ipkt_cnt);
150 mdb_printf(" instance : %u\n", pinfo.port_instance);
151 mdb_printf(" max_exch : %u\n", pinfo.port_max_exch);
152 mdb_printf(" cmds_aborted : 0x%-08x\n",
153 pinfo.port_reset_action);
154 mdb_printf(" cmds_dma_flags : 0x%-08x\n",
155 pinfo.port_cmds_dma_flags);
156 mdb_printf(" fcp_dma : 0x%-08x\n", pinfo.port_fcp_dma);
157 mdb_printf(" priv_pkt_len : %u\n", pinfo.port_priv_pkt_len);
158 mdb_printf(" data_dma_attr : 0x%-08x\n",
159 pinfo.port_data_dma_attr);
160 mdb_printf(" cmd_dma_attr : 0x%-08x\n",
161 pinfo.port_cmd_dma_attr);
162 mdb_printf(" resp_dma_attr : 0x%-08x\n",
163 pinfo.port_resp_dma_attr);
164 mdb_printf(" dma_acc_attr : 0x%-08x\n",
165 pinfo.port_dma_acc_attr);
166 mdb_printf(" tran : 0x%p\n", pinfo.port_tran);
167 mdb_printf(" dip : 0x%p\n", pinfo.port_dip);
168 mdb_printf(" reset_notify_listf: 0x%p\n",
169 pinfo.port_reset_notify_listf);
170 mdb_printf(" event_defs : 0x%p\n", pinfo.port_ndi_event_defs);
171 mdb_printf(" event_hdl : 0x%p\n", pinfo.port_ndi_event_hdl);
172 mdb_printf(" events : 0x%p\n", pinfo.port_ndi_events);
173 mdb_printf(" tgt_hash_table : 0x%p\n", pinfo.port_tgt_hash_table);
174 mdb_printf(" mpxio : %d\n", pinfo.port_mpxio);
175
176 mdb_printf("\n");
177
178 return (DCMD_OK);
179 }
180
181
182 /*
183 * Leadville cmds walker/dcmd code
184 */
185
186 static int
cmds_walk_i(mdb_walk_state_t * wsp)187 cmds_walk_i(mdb_walk_state_t *wsp)
188 {
189 if (wsp->walk_addr == NULL) {
190 mdb_warn("Can not perform global walk");
191 return (WALK_ERR);
192 }
193
194 /*
195 * Input should be a fcp_lun, so read it to get the fcp_pkt
196 * lists's head
197 */
198
199 if (mdb_vread(&lun, sizeof (struct fcp_lun), wsp->walk_addr) !=
200 sizeof (struct fcp_lun)) {
201 mdb_warn("Unable to read in the fcp_lun structure address\n");
202 return (WALK_ERR);
203 }
204
205 wsp->walk_addr = (uintptr_t)(lun.lun_pkt_head);
206 wsp->walk_data = mdb_alloc(sizeof (struct fcp_pkt), UM_SLEEP);
207
208 return (WALK_NEXT);
209 }
210
211 static int
cmds_walk_s(mdb_walk_state_t * wsp)212 cmds_walk_s(mdb_walk_state_t *wsp)
213 {
214 int status;
215
216 if (wsp->walk_addr == NULL)
217 return (WALK_DONE);
218
219 if (mdb_vread(wsp->walk_data, sizeof (struct fcp_pkt),
220 wsp->walk_addr) == -1) {
221 mdb_warn("failed to read fcp_pkt at %p", wsp->walk_addr);
222 return (WALK_DONE);
223 }
224
225 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
226 wsp->walk_cbdata);
227
228 wsp->walk_addr =
229 (uintptr_t)(((struct fcp_pkt *)wsp->walk_data)->cmd_forw);
230
231 return (status);
232 }
233
234 /*
235 * The walker's fini function is invoked at the end of each walk.
236 */
237 static void
cmds_walk_f(mdb_walk_state_t * wsp)238 cmds_walk_f(mdb_walk_state_t *wsp)
239 {
240 mdb_free(wsp->walk_data, sizeof (struct fcp_pkt));
241 }
242
243
244 /*
245 * Leadville luns walker/dcmd code
246 */
247
248 static int
luns_walk_i(mdb_walk_state_t * wsp)249 luns_walk_i(mdb_walk_state_t *wsp)
250 {
251 if (wsp->walk_addr == NULL) {
252 mdb_warn("Can not perform global walk");
253 return (WALK_ERR);
254 }
255
256 /*
257 * Input should be a fcp_tgt, so read it to get the fcp_lun
258 * lists's head
259 */
260
261 if (mdb_vread(&tgt, sizeof (struct fcp_tgt), wsp->walk_addr) !=
262 sizeof (struct fcp_tgt)) {
263 mdb_warn("Unable to read in the fcp_tgt structure address\n");
264 return (WALK_ERR);
265 }
266
267 wsp->walk_addr = (uintptr_t)(tgt.tgt_lun);
268 wsp->walk_data = mdb_alloc(sizeof (struct fcp_lun), UM_SLEEP);
269
270 return (WALK_NEXT);
271 }
272
273 static int
luns_walk_s(mdb_walk_state_t * wsp)274 luns_walk_s(mdb_walk_state_t *wsp)
275 {
276 int status;
277
278 if (wsp->walk_addr == NULL)
279 return (WALK_DONE);
280
281 if (mdb_vread(wsp->walk_data, sizeof (struct fcp_lun),
282 wsp->walk_addr) == -1) {
283 mdb_warn("failed to read fcp_pkt at %p", wsp->walk_addr);
284 return (WALK_DONE);
285 }
286
287 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
288 wsp->walk_cbdata);
289
290 wsp->walk_addr =
291 (uintptr_t)(((struct fcp_lun *)wsp->walk_data)->lun_next);
292
293 return (status);
294 }
295
296 /*
297 * The walker's fini function is invoked at the end of each walk.
298 */
299 static void
luns_walk_f(mdb_walk_state_t * wsp)300 luns_walk_f(mdb_walk_state_t *wsp)
301 {
302 mdb_free(wsp->walk_data, sizeof (struct fcp_lun));
303 }
304
305
306 /*
307 * Leadville targets walker/dcmd code
308 */
309
310 static int
targets_walk_i(mdb_walk_state_t * wsp)311 targets_walk_i(mdb_walk_state_t *wsp)
312 {
313 if (wsp->walk_addr == NULL) {
314 mdb_warn("Can not perform global walk\n");
315 return (WALK_ERR);
316 }
317
318 /*
319 * Input should be a fcp_port, so read it to get the port_tgt
320 * table's head
321 */
322
323 if (mdb_vread(&port, sizeof (struct fcp_port), wsp->walk_addr) !=
324 sizeof (struct fcp_port)) {
325 mdb_warn("Unable to read in the port structure address\n");
326 return (WALK_ERR);
327 }
328
329 tgt_hash_index = 0;
330
331 while ((port.port_tgt_hash_table[tgt_hash_index] == NULL) &&
332 (tgt_hash_index < FCP_NUM_HASH)) {
333 tgt_hash_index++;
334 }
335
336 wsp->walk_addr = (uintptr_t)(port.port_tgt_hash_table[tgt_hash_index]);
337
338 wsp->walk_data = mdb_alloc(sizeof (struct fcp_tgt), UM_SLEEP);
339
340 return (WALK_NEXT);
341 }
342
343 static int
targets_walk_s(mdb_walk_state_t * wsp)344 targets_walk_s(mdb_walk_state_t *wsp)
345 {
346 int status;
347
348 if ((wsp->walk_addr == NULL) &&
349 (tgt_hash_index >= (FCP_NUM_HASH - 1))) {
350 return (WALK_DONE);
351 }
352
353 if (mdb_vread(wsp->walk_data, sizeof (struct fcp_tgt),
354 wsp->walk_addr) == -1) {
355 mdb_warn("failed to read fcp_tgt at %p", wsp->walk_addr);
356 return (WALK_DONE);
357 }
358
359 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
360 wsp->walk_cbdata);
361
362 wsp->walk_addr =
363 (uintptr_t)(((struct fcp_tgt *)wsp->walk_data)->tgt_next);
364
365 if (wsp->walk_addr == NULL) {
366 /*
367 * locate the next hash list
368 */
369
370 tgt_hash_index++;
371
372 while ((port.port_tgt_hash_table[tgt_hash_index] == NULL) &&
373 (tgt_hash_index < FCP_NUM_HASH)) {
374 tgt_hash_index++;
375 }
376
377 if (tgt_hash_index == FCP_NUM_HASH) {
378 /* You're done */
379 return (status);
380 }
381
382 wsp->walk_addr =
383 (uintptr_t)(port.port_tgt_hash_table[tgt_hash_index]);
384 }
385
386 return (status);
387 }
388
389 /*
390 * The walker's fini function is invoked at the end of each walk.
391 */
392 static void
targets_walk_f(mdb_walk_state_t * wsp)393 targets_walk_f(mdb_walk_state_t *wsp)
394 {
395 mdb_free(wsp->walk_data, sizeof (struct fcp_tgt));
396 }
397
398
399 /*
400 * Leadville fcp_ipkt walker/dcmd code
401 */
402
403 static int
ipkt_walk_i(mdb_walk_state_t * wsp)404 ipkt_walk_i(mdb_walk_state_t *wsp)
405 {
406 if (wsp->walk_addr == NULL) {
407 mdb_warn("The address of a fcp_port"
408 " structure must be given\n");
409 return (WALK_ERR);
410 }
411
412 /*
413 * Input should be a fcp_port, so read it to get the ipkt
414 * list's head
415 */
416
417 if (mdb_vread(&port, sizeof (struct fcp_port), wsp->walk_addr) !=
418 sizeof (struct fcp_port)) {
419 mdb_warn("Failed to read in the fcp_port"
420 " at 0x%p\n", wsp->walk_addr);
421 return (WALK_ERR);
422 }
423
424 wsp->walk_addr = (uintptr_t)(port.port_ipkt_list);
425 wsp->walk_data = mdb_alloc(sizeof (struct fcp_ipkt), UM_SLEEP);
426
427 return (WALK_NEXT);
428 }
429
430 static int
ipkt_walk_s(mdb_walk_state_t * wsp)431 ipkt_walk_s(mdb_walk_state_t *wsp)
432 {
433 int status;
434
435 if (wsp->walk_addr == NULL)
436 return (WALK_DONE);
437
438 if (mdb_vread(wsp->walk_data, sizeof (struct fcp_ipkt),
439 wsp->walk_addr) == -1) {
440 mdb_warn("Failed to read in the fcp_ipkt"
441 " at 0x%p\n", wsp->walk_addr);
442 return (WALK_DONE);
443 }
444
445 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
446 wsp->walk_cbdata);
447
448 wsp->walk_addr =
449 (uintptr_t)(((struct fcp_ipkt *)wsp->walk_data)->ipkt_next);
450
451 return (status);
452 }
453
454 /*
455 * The walker's fini function is invoked at the end of each walk.
456 */
457 static void
ipkt_walk_f(mdb_walk_state_t * wsp)458 ipkt_walk_f(mdb_walk_state_t *wsp)
459 {
460 mdb_free(wsp->walk_data, sizeof (struct fcp_ipkt));
461 }
462
463 /*
464 * Leadville fcp_pkt walker/dcmd code
465 */
466
467 static int
pkt_walk_i(mdb_walk_state_t * wsp)468 pkt_walk_i(mdb_walk_state_t *wsp)
469 {
470 if (wsp->walk_addr == NULL) {
471 mdb_warn("The address of a fcp_port"
472 " structure must be given\n");
473 return (WALK_ERR);
474 }
475
476 /*
477 * Input should be an fcp_port, so read it to get the pkt
478 * list's head
479 */
480
481 if (mdb_vread(&port, sizeof (struct fcp_port), wsp->walk_addr) !=
482 sizeof (struct fcp_port)) {
483 mdb_warn("Failed to read in the fcp_port"
484 " at 0x%p\n", wsp->walk_addr);
485 return (WALK_ERR);
486 }
487
488 wsp->walk_addr = (uintptr_t)(port.port_pkt_head);
489 wsp->walk_data = mdb_alloc(sizeof (struct fcp_pkt), UM_SLEEP);
490
491 return (WALK_NEXT);
492 }
493
494 static int
pkt_walk_s(mdb_walk_state_t * wsp)495 pkt_walk_s(mdb_walk_state_t *wsp)
496 {
497 int status;
498
499 if (wsp->walk_addr == NULL)
500 return (WALK_DONE);
501
502 if (mdb_vread(wsp->walk_data, sizeof (struct fcp_pkt),
503 wsp->walk_addr) == -1) {
504 mdb_warn("Failed to read in the fcp_pkt"
505 " at 0x%p\n", wsp->walk_addr);
506 return (WALK_DONE);
507 }
508
509 status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
510 wsp->walk_cbdata);
511
512 wsp->walk_addr =
513 (uintptr_t)(((struct fcp_pkt *)wsp->walk_data)->cmd_next);
514
515 return (status);
516 }
517
518 /*
519 * The walker's fini function is invoked at the end of each walk.
520 */
521 static void
pkt_walk_f(mdb_walk_state_t * wsp)522 pkt_walk_f(mdb_walk_state_t *wsp)
523 {
524 mdb_free(wsp->walk_data, sizeof (struct fcp_pkt));
525 }
526
527 /*
528 * MDB module linkage information:
529 *
530 * We declare a list of structures describing our dcmds, a list of structures
531 * describing our walkers, and a function named _mdb_init to return a pointer
532 * to our module information.
533 */
534
535 static const mdb_dcmd_t dcmds[] = {
536 { "fcp", NULL, "Leadville fcp instances", fcp },
537 { NULL }
538 };
539
540 static const mdb_walker_t walkers[] = {
541 { "fcp", "Walk list of Leadville fcp instances",
542 fcp_walk_i, fcp_walk_s, fcp_walk_f },
543 { "cmds", "Walk list of SCSI commands in fcp's per-lun queue",
544 cmds_walk_i, cmds_walk_s, cmds_walk_f },
545 { "luns", "Walk list of LUNs in an fcp target",
546 luns_walk_i, luns_walk_s, luns_walk_f },
547 { "targets", "Walk list of fcp targets attached to the local port",
548 targets_walk_i, targets_walk_s, targets_walk_f },
549 { "fcp_ipkt", "Walk list of internal packets queued on a local port",
550 ipkt_walk_i, ipkt_walk_s, ipkt_walk_f},
551 { "fcp_pkt", "Walk list of packets queued on a local port",
552 pkt_walk_i, pkt_walk_s, pkt_walk_f},
553 { NULL }
554 };
555
556 static const mdb_modinfo_t modinfo = {
557 MDB_API_VERSION, dcmds, walkers
558 };
559
560 const mdb_modinfo_t *
_mdb_init(void)561 _mdb_init(void)
562 {
563 return (&modinfo);
564 }
565