xref: /illumos-gate/usr/src/cmd/mdb/common/modules/fctl/fctl.c (revision d75f3745ad3c36431063bb316666f4d316eabc8c)
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 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Copyright (c) 2018, Joyent, Inc.
28  */
29 
30 #include <sys/mdb_modapi.h>
31 #include <sys/mutex.h>
32 #include <sys/modctl.h>
33 #include <time.h>
34 #include <sys/fibre-channel/fc.h>
35 #include <sys/fibre-channel/impl/fctl_private.h>
36 #include <sys/fibre-channel/impl/fc_ulpif.h>
37 #include <sys/fibre-channel/impl/fc_portif.h>
38 #include <sys/fibre-channel/impl/fc_fcaif.h>
39 
40 
41 /*
42  * If we #include <string.h> then other definitions fail. This is
43  * the easiest way of getting access to the function
44  */
45 extern char *strtok(char *string, const char *sepset);
46 
47 /* we need 26 bytes for the cftime() call */
48 #define	TIMESTAMPSIZE	26 * sizeof (char)
49 
50 /* for backward compatibility */
51 typedef struct fc_trace_dmsgv1 {
52 	int			id_size;
53 	int			id_flag;
54 	time_t			id_time;
55 	caddr_t			id_buf;
56 	struct fc_trace_dmsgv1	*id_next;
57 } fc_trace_dmsgv1_t;
58 
59 static struct pwwn_hash *fp_pwwn_table;
60 static struct d_id_hash *fp_did_table;
61 static uint32_t pd_hash_index;
62 struct fc_local_port port;
63 
64 /*
65  * Leadville port walker/dcmd code
66  */
67 
68 /*
69  * Initialize the fc_fca_port_t walker by either using the given starting
70  * address, or reading the value of the kernel's fctl_fca_portlist pointer.
71  * We also allocate a fc_fca_port_t for storage, and save this using the
72  * walk_data pointer.
73  */
74 static int
75 port_walk_i(mdb_walk_state_t *wsp)
76 {
77 	if (wsp->walk_addr == NULL &&
78 	    mdb_readvar(&wsp->walk_addr, "fctl_fca_portlist") == -1) {
79 		mdb_warn("failed to read 'fctl_fca_portlist'");
80 		return (WALK_ERR);
81 	}
82 
83 	wsp->walk_data = mdb_alloc(sizeof (fc_fca_port_t), UM_SLEEP);
84 	return (WALK_NEXT);
85 }
86 
87 /*
88  * At each step, read a fc_fca_port_t into our private storage, and then invoke
89  * the callback function.  We terminate when we reach a NULL p_next pointer.
90  */
91 static int
92 port_walk_s(mdb_walk_state_t *wsp)
93 {
94 	int status;
95 
96 	if (wsp->walk_addr == NULL)
97 		return (WALK_DONE);
98 
99 	if (mdb_vread(wsp->walk_data, sizeof (fc_fca_port_t), wsp->walk_addr)
100 	    == -1) {
101 		mdb_warn("failed to read fc_fca_port_t at %p", wsp->walk_addr);
102 		return (WALK_DONE);
103 	}
104 
105 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
106 	    wsp->walk_cbdata);
107 
108 	wsp->walk_addr =
109 	    (uintptr_t)(((fc_fca_port_t *)wsp->walk_data)->port_next);
110 
111 	return (status);
112 }
113 
114 /*
115  * The walker's fini function is invoked at the end of each walk.  Since we
116  * dynamically allocated a fc_fca_port_t in port_walk_i, we must free it now.
117  */
118 static void
119 port_walk_f(mdb_walk_state_t *wsp)
120 {
121 	mdb_free(wsp->walk_data, sizeof (fc_fca_port_t));
122 }
123 
124 
125 static int
126 ports(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
127 {
128 	fc_fca_port_t	portlist;
129 	fc_local_port_t port;
130 	int		longlist = FALSE;
131 
132 	if (argc > 1) {
133 		return (DCMD_USAGE);
134 	}
135 
136 	if (mdb_getopts(argc, argv,
137 	    'l', MDB_OPT_SETBITS, TRUE, &longlist) != argc) {
138 		return (DCMD_USAGE);
139 	}
140 
141 
142 	if (!(flags & DCMD_ADDRSPEC)) {
143 		if (longlist == 0) {
144 			if (mdb_walk_dcmd("ports", "ports",
145 			    argc, argv) == -1) {
146 				mdb_warn("failed to walk 'fctl_fca_portlist'");
147 				return (DCMD_ERR);
148 			}
149 		} else {
150 			if (mdb_walk_dcmd("ports", "fcport",
151 			    argc, argv) == -1) {
152 				mdb_warn("failed to walk 'fctl_fca_portlist'");
153 				return (DCMD_ERR);
154 			}
155 		}
156 
157 		return (DCMD_OK);
158 	}
159 
160 	/*
161 	 * If this is the first invocation of the command, print a nice
162 	 * header line for the output that will follow.
163 	 */
164 	if (DCMD_HDRSPEC(flags))
165 		mdb_printf("%16s %-2s %4s %-4s%16s %16s %16s\n",
166 		    "Port", "I#", "State", "Soft", "FCA Handle",
167 		    "Port DIP", "FCA Port DIP");
168 
169 	/*
170 	 * For each port, we just need to read the fc_fca_port_t struct, read
171 	 * the port_handle
172 	 */
173 	if (mdb_vread(&portlist, sizeof (fc_fca_port_t), addr) ==
174 	    sizeof (fc_fca_port_t)) {
175 		/*
176 		 * Now read that port in
177 		 */
178 
179 		if (mdb_vread(&port, sizeof (fc_local_port_t), (uintptr_t)
180 		    portlist.port_handle) == sizeof (fc_local_port_t)) {
181 			mdb_printf("%16p %2d %4x %4x %16p %16p %16p\n",
182 			    portlist.port_handle, port.fp_instance,
183 			    port.fp_state, port.fp_soft_state,
184 			    port.fp_fca_handle, port.fp_port_dip,
185 			    port.fp_fca_dip);
186 		} else
187 			mdb_warn("failed to read port at %p",
188 			    portlist.port_handle);
189 
190 	} else
191 		mdb_warn("failed to read port info at %p", addr);
192 
193 	return (DCMD_OK);
194 }
195 
196 
197 /*
198  * Leadville ULP walker/dcmd code
199  */
200 
201 static int
202 ulp_walk_i(mdb_walk_state_t *wsp)
203 {
204 	if (wsp->walk_addr == NULL &&
205 	    mdb_readvar(&wsp->walk_addr, "fctl_ulp_list") == -1) {
206 		mdb_warn("failed to read 'fctl_ulp_list'");
207 		return (WALK_ERR);
208 	}
209 
210 	wsp->walk_data = mdb_alloc(sizeof (fc_ulp_list_t), UM_SLEEP);
211 	return (WALK_NEXT);
212 }
213 
214 
215 
216 static int
217 ulp_walk_s(mdb_walk_state_t *wsp)
218 {
219 	int status;
220 
221 	if (wsp->walk_addr == NULL)
222 		return (WALK_DONE);
223 
224 	if (mdb_vread(wsp->walk_data, sizeof (fc_ulp_list_t), wsp->walk_addr)
225 	    == -1) {
226 		mdb_warn("failed to read fctl_ulp_list %p", wsp->walk_addr);
227 		return (WALK_DONE);
228 	}
229 
230 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
231 	    wsp->walk_cbdata);
232 
233 	wsp->walk_addr =
234 	    (uintptr_t)(((fc_ulp_list_t *)wsp->walk_data)->ulp_next);
235 
236 	return (status);
237 }
238 
239 
240 static void
241 ulp_walk_f(mdb_walk_state_t *wsp)
242 {
243 	mdb_free(wsp->walk_data, sizeof (fc_ulp_list_t));
244 }
245 
246 
247 static int
248 ulps(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
249 {
250 	fc_ulp_list_t		ulplist;
251 	fc_ulp_modinfo_t	ulp;
252 	char			ulp_name[30];
253 
254 	if (argc != 0) {
255 		return (DCMD_USAGE);
256 	}
257 
258 	/*
259 	 * If no fc_ulp_list_t address was specified on the command line, we can
260 	 * print out all processes by invoking the walker, using this
261 	 * dcmd itself as the callback.
262 	 */
263 	if (!(flags & DCMD_ADDRSPEC)) {
264 		if (mdb_walk_dcmd("ulps", "ulps", argc, argv) == -1) {
265 			mdb_warn("failed to walk 'fc_ulp_list_t'");
266 			return (DCMD_ERR);
267 		}
268 		return (DCMD_OK);
269 	}
270 
271 	/*
272 	 * If this is the first invocation of the command, print a nice
273 	 * header line for the output that will follow.
274 	 */
275 	if (DCMD_HDRSPEC(flags))
276 		mdb_printf("%30s %4s %8s\n", "ULP Name", "Type", "Revision");
277 
278 	/*
279 	 * For each port, we just need to read the fc_fca_port_t struct, read
280 	 * the port_handle
281 	 */
282 	if (mdb_vread(&ulplist, sizeof (fc_ulp_list_t), addr) ==
283 	    sizeof (fc_ulp_list_t)) {
284 		/*
285 		 * Now read that port in
286 		 */
287 
288 		if (mdb_vread(&ulp, sizeof (fc_ulp_modinfo_t),
289 		    (uintptr_t)ulplist.ulp_info) == sizeof (fc_ulp_modinfo_t)) {
290 			if (mdb_vread(&ulp_name, 30,
291 			    (uintptr_t)ulp.ulp_name) > 0) {
292 				mdb_printf("%30s %4x %8x\n",
293 				    ulp_name, ulp.ulp_type, ulp.ulp_rev);
294 			}
295 		} else
296 			mdb_warn("failed to read ulp at %p",
297 			    ulplist.ulp_info);
298 
299 	} else
300 		mdb_warn("failed to read ulplist at %p", addr);
301 
302 	return (DCMD_OK);
303 }
304 
305 
306 
307 /*
308  * Leadville ULP module walker/dcmd code
309  */
310 
311 static int
312 ulpmod_walk_i(mdb_walk_state_t *wsp)
313 {
314 	if (wsp->walk_addr == NULL &&
315 	    mdb_readvar(&wsp->walk_addr, "fctl_ulp_modules") == -1) {
316 		mdb_warn("failed to read 'fctl_ulp_modules'");
317 		return (WALK_ERR);
318 	}
319 
320 	wsp->walk_data = mdb_alloc(sizeof (fc_ulp_module_t), UM_SLEEP);
321 	return (WALK_NEXT);
322 }
323 
324 
325 
326 static int
327 ulpmod_walk_s(mdb_walk_state_t *wsp)
328 {
329 	int status;
330 
331 	if (wsp->walk_addr == NULL)
332 		return (WALK_DONE);
333 
334 	if (mdb_vread(wsp->walk_data, sizeof (fc_ulp_module_t), wsp->walk_addr)
335 	    == -1) {
336 		mdb_warn("failed to read fctl_ulp_modules %p", wsp->walk_addr);
337 		return (WALK_DONE);
338 	}
339 
340 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
341 	    wsp->walk_cbdata);
342 
343 	wsp->walk_addr =
344 	    (uintptr_t)(((fc_ulp_module_t *)wsp->walk_data)->mod_next);
345 
346 	return (status);
347 }
348 
349 
350 static void
351 ulpmod_walk_f(mdb_walk_state_t *wsp)
352 {
353 	mdb_free(wsp->walk_data, sizeof (fc_ulp_module_t));
354 }
355 
356 
357 static int
358 ulpmods(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
359 {
360 	fc_ulp_module_t		modlist;
361 	fc_ulp_modinfo_t	modinfo;
362 	fc_ulp_ports_t		ulp_port;
363 
364 	if (argc != 0) {
365 		return (DCMD_USAGE);
366 	}
367 
368 	if (!(flags & DCMD_ADDRSPEC)) {
369 		if (mdb_walk_dcmd("ulpmods", "ulpmods", argc, argv)
370 		    == -1) {
371 			mdb_warn("failed to walk 'fc_ulp_module_t'");
372 			return (DCMD_ERR);
373 		}
374 		return (DCMD_OK);
375 	}
376 
377 	/*
378 	 * If this is the first invocation of the command, print a nice
379 	 * header line for the output that will follow.
380 	 */
381 	if (DCMD_HDRSPEC(flags))
382 		mdb_printf("%4s %16s %8s %8s\n",
383 		    "Type", "Port Handle", "dstate", "statec");
384 
385 	/*
386 	 * For each port, we just need to read the fc_fca_port_t struct, read
387 	 * the port_handle
388 	 */
389 	if (mdb_vread(&modlist, sizeof (fc_ulp_module_t), addr) ==
390 	    sizeof (fc_ulp_module_t)) {
391 		/*
392 		 * Now read that module info in
393 		 */
394 
395 		if (mdb_vread(&modinfo, sizeof (fc_ulp_modinfo_t),
396 		    (uintptr_t)modlist.mod_info) == sizeof (fc_ulp_modinfo_t)) {
397 			/* Now read all the ports for this module */
398 			if (mdb_vread(&ulp_port, sizeof (fc_ulp_ports_t),
399 			    (uintptr_t)modlist.mod_ports) ==
400 			    sizeof (fc_ulp_ports_t)) {
401 				while (ulp_port.port_handle != NULL) {
402 					mdb_printf("%4x %16p %8x %8x\n",
403 					    modinfo.ulp_type,
404 					    ulp_port.port_handle,
405 					    ulp_port.port_dstate,
406 					    ulp_port.port_statec);
407 
408 					if (ulp_port.port_next == NULL)
409 						break;
410 
411 					mdb_vread(&ulp_port,
412 					    sizeof (fc_ulp_ports_t),
413 					    (uintptr_t)ulp_port.port_next);
414 				}
415 			}
416 		} else
417 			mdb_warn("failed to read modinfo at %p",
418 			    modlist.mod_info);
419 
420 	} else
421 		mdb_warn("failed to read modlist at %p", addr);
422 
423 	return (DCMD_OK);
424 }
425 
426 
427 /*
428  * Display an fc_local_port_t struct
429  */
430 static int
431 fcport(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
432 {
433 	fc_fca_port_t	portlist;
434 	fc_local_port_t	port;
435 	int		idx;
436 	int		first = 1;
437 	int		walking_fc_fca_portlist = 0;
438 
439 	if (argc != 0) {
440 		int result;
441 
442 		if (argc != 1)
443 			return (DCMD_USAGE);
444 
445 		if (argv->a_type != MDB_TYPE_STRING)
446 			return (DCMD_USAGE);
447 
448 		walking_fc_fca_portlist = 1;
449 	}
450 
451 	if (!(flags & DCMD_ADDRSPEC)) {
452 		mdb_printf("Sorry, you must provide an address\n");
453 		return (DCMD_ERR);
454 	}
455 
456 	if (walking_fc_fca_portlist) {
457 		/*
458 		 * Must read the fc_fca_portlist to get the fc_local_port addr
459 		 */
460 		if (mdb_vread(&portlist, sizeof (fc_fca_port_t), addr) ==
461 		    sizeof (fc_fca_port_t)) {
462 			addr = (uintptr_t)portlist.port_handle;
463 		}
464 	}
465 
466 	mdb_printf("Reading fc_local_port_t at %p:\n", addr);
467 
468 	/*
469 	 * For each port, we just need to read the fc_local_port_t struct
470 	 */
471 
472 	if (mdb_vread(&port, sizeof (fc_local_port_t),
473 	    addr) == sizeof (fc_local_port_t)) {
474 		mdb_printf("  fp_mutex          : 0x%p\n", port.fp_mutex);
475 		mdb_printf("  fp_state          : 0x%-8x\n", port.fp_state);
476 		mdb_printf("  fp_port_id        : 0x%-06x\n",
477 		    port.fp_port_id.port_id);
478 		mdb_printf("  fp_fca_handle     : 0x%p\n", port.fp_fca_handle);
479 		mdb_printf("  fp_fca_tran       : 0x%p\n", port.fp_fca_tran);
480 		mdb_printf("  fp_job_head       : 0x%p\n", port.fp_job_head);
481 		mdb_printf("  fp_job_tail       : 0x%p\n", port.fp_job_tail);
482 		mdb_printf("  fp_wait_head      : 0x%p\n", port.fp_wait_head);
483 		mdb_printf("  fp_wait_tail      : 0x%p\n", port.fp_wait_tail);
484 		mdb_printf("  fp_topology       : %u\n", port.fp_topology);
485 		mdb_printf("  fp_task           : %d\n", port.fp_task);
486 		mdb_printf("  fp_last_task      : %d\n", port.fp_last_task);
487 		mdb_printf("  fp_soft_state     : 0x%-4x\n",
488 		    port.fp_soft_state);
489 		mdb_printf("  fp_flag           : 0x%-2x\n", port.fp_flag);
490 		mdb_printf("  fp_statec_busy    : 0x%-8x\n",
491 		    port.fp_statec_busy);
492 		mdb_printf("  fp_port_num       : %d\n", port.fp_port_num);
493 		mdb_printf("  fp_instance       : %d\n", port.fp_instance);
494 		mdb_printf("  fp_ulp_attach     : %d\n", port.fp_ulp_attach);
495 		mdb_printf("  fp_dev_count      : %d\n", port.fp_dev_count);
496 		mdb_printf("  fp_total_devices  : %d\n", port.fp_total_devices);
497 		mdb_printf("  fp_bind_state     : 0x%-8x\n",
498 		    port.fp_bind_state);
499 		mdb_printf("  fp_options        : 0x%-8x\n", port.fp_options);
500 		mdb_printf("  fp_port_type      : 0x%-2x\n",
501 		    port.fp_port_type.port_type);
502 		mdb_printf("  fp_ub_count       : %d\n", port.fp_ub_count);
503 		mdb_printf("  fp_active_ubs     : %d\n", port.fp_active_ubs);
504 		mdb_printf("  fp_port_dip       : 0x%p\n", port.fp_port_dip);
505 		mdb_printf("  fp_fca_dip        : 0x%p\n", port.fp_fca_dip);
506 
507 		for (idx = 0; idx < 16; idx++) {
508 			if (port.fp_ip_addr[idx] != 0)
509 				break;
510 		}
511 
512 		if (idx != 16) {
513 			mdb_printf("  fp_ip_addr        : %-2x:%-2x:%-2x:%-2x:"
514 			    "%-2x:%-2x:%-2x:%-2x:%-2x:%-2x:%-2x:%-2x:%-2x:%-2x"
515 			    ":%-2x:%-2x\n",
516 			    port.fp_ip_addr[0], port.fp_ip_addr[1],
517 			    port.fp_ip_addr[2], port.fp_ip_addr[3],
518 			    port.fp_ip_addr[4], port.fp_ip_addr[5],
519 			    port.fp_ip_addr[6], port.fp_ip_addr[7],
520 			    port.fp_ip_addr[8], port.fp_ip_addr[9],
521 			    port.fp_ip_addr[10], port.fp_ip_addr[11],
522 			    port.fp_ip_addr[12], port.fp_ip_addr[13],
523 			    port.fp_ip_addr[14], port.fp_ip_addr[15]);
524 		} else {
525 			mdb_printf("  fp_ip_addr        : N/A\n");
526 		}
527 
528 		mdb_printf("  fp_fc4_types      : ");
529 
530 		for (idx = 0; idx < 8; idx++) {
531 			if (port.fp_fc4_types[idx] != 0) {
532 				if (first) {
533 					mdb_printf("%d",
534 					    port.fp_fc4_types[idx]);
535 					first = 0;
536 				} else {
537 					mdb_printf(", %d",
538 					    port.fp_fc4_types[idx]);
539 				}
540 			}
541 		}
542 
543 		if (first) {
544 			mdb_printf("None\n");
545 		} else {
546 			mdb_printf("\n");
547 		}
548 
549 		mdb_printf("  fp_pm_level       : %d\n", port.fp_pm_level);
550 		mdb_printf("  fp_pm_busy        : %d\n", port.fp_pm_busy);
551 		mdb_printf("  fp_pm_busy_nocomp : 0x%-8x\n",
552 		    port.fp_pm_busy_nocomp);
553 		mdb_printf("  fp_hard_addr      : 0x%-6x\n",
554 		    port.fp_hard_addr.hard_addr);
555 		mdb_printf("  fp_sym_port_name  : \"%s\"\n",
556 		    port.fp_sym_port_name);
557 		mdb_printf("  fp_sym_node_name  : \"%s\"\n",
558 		    port.fp_sym_node_name);
559 		mdb_printf("  fp_rscn_count     : %d\n", port.fp_rscn_count);
560 	} else {
561 		mdb_warn("failed to read fc_local_port_t at 0x%p", addr);
562 	}
563 
564 	mdb_printf("\n");
565 
566 	return (DCMD_OK);
567 }
568 
569 
570 /*
571  * Leadville remote_port walker/dcmd code
572  */
573 
574 /*
575  * We need to be given the address of a port structure in order to start
576  * walking.  From that, we can read the pwwn table.
577  */
578 static int
579 pd_by_pwwn_walk_i(mdb_walk_state_t *wsp)
580 {
581 	fc_local_port_t port;
582 
583 	if (wsp->walk_addr == NULL) {
584 		mdb_warn("pd_by_pwwn walk doesn't support global walks\n");
585 		return (WALK_ERR);
586 	}
587 
588 	/*
589 	 * Allocate space for the pwwn_hash table
590 	 */
591 
592 	fp_pwwn_table = mdb_alloc(sizeof (struct pwwn_hash) *
593 	    PWWN_HASH_TABLE_SIZE, UM_SLEEP);
594 
595 	/*
596 	 * Input should be an fc_local_port_t, so read it to get the pwwn
597 	 * table's head
598 	 */
599 
600 	if (mdb_vread(&port, sizeof (fc_local_port_t), wsp->walk_addr) !=
601 	    sizeof (fc_local_port_t)) {
602 		mdb_warn("Unable to read in the port structure address\n");
603 		return (WALK_ERR);
604 	}
605 
606 	if (mdb_vread(fp_pwwn_table, sizeof (struct pwwn_hash) *
607 	    PWWN_HASH_TABLE_SIZE, (uintptr_t)port.fp_pwwn_table) == -1) {
608 		mdb_warn("Unable to read in the pwwn hash table\n");
609 		return (WALK_ERR);
610 	}
611 
612 	pd_hash_index = 0;
613 
614 	while ((fp_pwwn_table[pd_hash_index].pwwn_head == NULL) &&
615 	    (pd_hash_index < PWWN_HASH_TABLE_SIZE)) {
616 		pd_hash_index++;
617 	}
618 
619 	wsp->walk_addr = (uintptr_t)fp_pwwn_table[pd_hash_index].pwwn_head;
620 
621 	wsp->walk_data = mdb_alloc(sizeof (fc_remote_port_t), UM_SLEEP);
622 	return (WALK_NEXT);
623 }
624 
625 /*
626  * At each step, read a fc_remote_port_t into our private storage, and then
627  * invoke the callback function.  We terminate when we reach a NULL p_next
628  * pointer.
629  */
630 static int
631 pd_by_pwwn_walk_s(mdb_walk_state_t *wsp)
632 {
633 	int status;
634 
635 	if ((wsp->walk_addr == NULL) &&
636 	    (pd_hash_index >= (PWWN_HASH_TABLE_SIZE - 1))) {
637 		return (WALK_DONE);
638 	}
639 
640 	if (mdb_vread(wsp->walk_data, sizeof (fc_remote_port_t), wsp->walk_addr)
641 	    == -1) {
642 		mdb_warn("failed to read fc_remote_port at %p", wsp->walk_addr);
643 		return (WALK_DONE);
644 	}
645 
646 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
647 	    wsp->walk_cbdata);
648 
649 	wsp->walk_addr =
650 	    (uintptr_t)(((fc_remote_port_t *)wsp->walk_data)->pd_wwn_hnext);
651 
652 	if (wsp->walk_addr == NULL) {
653 		/*
654 		 * Try the next hash list, if there is one.
655 		 */
656 
657 		pd_hash_index++;
658 
659 		while ((fp_pwwn_table[pd_hash_index].pwwn_head == NULL) &&
660 		    (pd_hash_index < PWWN_HASH_TABLE_SIZE)) {
661 			pd_hash_index++;
662 		}
663 
664 		if (pd_hash_index == PWWN_HASH_TABLE_SIZE) {
665 			/* We're done */
666 			return (status);
667 		}
668 
669 		wsp->walk_addr =
670 		    (uintptr_t)fp_pwwn_table[pd_hash_index].pwwn_head;
671 	}
672 
673 	return (status);
674 }
675 
676 /*
677  * The walker's fini function is invoked at the end of each walk.
678  */
679 static void
680 pd_by_pwwn_walk_f(mdb_walk_state_t *wsp)
681 {
682 	mdb_free(wsp->walk_data, sizeof (fc_remote_port_t));
683 	mdb_free(fp_pwwn_table, sizeof (struct pwwn_hash) *
684 	    PWWN_HASH_TABLE_SIZE);
685 	fp_pwwn_table = NULL;
686 }
687 
688 /*
689  * This is the same walker as pd_by_pwwn, but we walk the D_ID hash table
690  */
691 
692 static int
693 pd_by_did_walk_i(mdb_walk_state_t *wsp)
694 {
695 	fc_local_port_t port;
696 
697 	if (wsp->walk_addr == NULL) {
698 		mdb_warn("pd_by_did walk doesn't support global walks\n");
699 		return (WALK_ERR);
700 	}
701 
702 	/*
703 	 * Allocate space for the did_hash table
704 	 */
705 
706 	fp_did_table = mdb_alloc(sizeof (struct d_id_hash) *
707 	    D_ID_HASH_TABLE_SIZE, UM_SLEEP);
708 
709 	/*
710 	 * Input should be an fc_local_port_t, so read it to get the d_id
711 	 * table's head
712 	 */
713 
714 	if (mdb_vread(&port, sizeof (fc_local_port_t), wsp->walk_addr) !=
715 	    sizeof (fc_local_port_t)) {
716 		mdb_warn("Unable to read in the port structure address\n");
717 		return (WALK_ERR);
718 	}
719 
720 	if (mdb_vread(fp_did_table, sizeof (struct d_id_hash) *
721 	    D_ID_HASH_TABLE_SIZE, (uintptr_t)port.fp_did_table) == -1) {
722 		mdb_warn("Unable to read in the D_ID hash table\n");
723 		return (WALK_ERR);
724 	}
725 	pd_hash_index = 0;
726 
727 	while ((fp_did_table[pd_hash_index].d_id_head == NULL) &&
728 	    (pd_hash_index < D_ID_HASH_TABLE_SIZE)) {
729 		pd_hash_index++;
730 	}
731 
732 	wsp->walk_addr = (uintptr_t)fp_did_table[pd_hash_index].d_id_head;
733 
734 	wsp->walk_data = mdb_alloc(sizeof (fc_remote_port_t), UM_SLEEP);
735 	return (WALK_NEXT);
736 }
737 
738 /*
739  * At each step, read a fc_remote_port_t into our private storage, and then
740  * invoke the callback function.  We terminate when we reach a NULL p_next
741  * pointer.
742  */
743 static int
744 pd_by_did_walk_s(mdb_walk_state_t *wsp)
745 {
746 	int status;
747 
748 	if ((wsp->walk_addr == NULL) &&
749 	    (pd_hash_index >= (D_ID_HASH_TABLE_SIZE - 1))) {
750 		return (WALK_DONE);
751 	}
752 
753 	if (mdb_vread(wsp->walk_data, sizeof (fc_remote_port_t), wsp->walk_addr)
754 	    == -1) {
755 		mdb_warn("failed to read fc_remote_port at %p", wsp->walk_addr);
756 		return (WALK_DONE);
757 	}
758 
759 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
760 	    wsp->walk_cbdata);
761 
762 	wsp->walk_addr =
763 	    (uintptr_t)(((fc_remote_port_t *)wsp->walk_data)->pd_did_hnext);
764 
765 	if (wsp->walk_addr == NULL) {
766 		/*
767 		 * Try the next hash list, if there is one.
768 		 */
769 
770 		pd_hash_index++;
771 
772 		while ((fp_did_table[pd_hash_index].d_id_head == NULL) &&
773 		    (pd_hash_index < D_ID_HASH_TABLE_SIZE)) {
774 			pd_hash_index++;
775 		}
776 
777 		if (pd_hash_index == D_ID_HASH_TABLE_SIZE) {
778 			/* We're done */
779 			return (status);
780 		}
781 
782 		wsp->walk_addr =
783 		    (uintptr_t)fp_did_table[pd_hash_index].d_id_head;
784 	}
785 
786 	return (status);
787 }
788 
789 /*
790  * The walker's fini function is invoked at the end of each walk.
791  */
792 static void
793 pd_by_did_walk_f(mdb_walk_state_t *wsp)
794 {
795 	mdb_free(wsp->walk_data, sizeof (fc_remote_port_t));
796 	mdb_free(fp_did_table, sizeof (struct d_id_hash) *
797 	    D_ID_HASH_TABLE_SIZE);
798 	fp_did_table = NULL;
799 }
800 
801 
802 /*
803  * Display a remote_port structure
804  */
805 static int
806 remote_port(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
807 {
808 	fc_remote_port_t	pd;
809 	int			idx;
810 	int			first = 1;
811 
812 	if (argc > 0) {
813 		return (DCMD_USAGE);
814 	}
815 
816 	if (!(flags & DCMD_ADDRSPEC)) {
817 		mdb_printf("Sorry, you must provide an address\n");
818 		return (DCMD_ERR);
819 	}
820 
821 	if (mdb_vread(&pd, sizeof (fc_remote_port_t), addr) !=
822 	    sizeof (fc_remote_port_t)) {
823 		mdb_warn("Error reading pd at 0x%x\n", addr);
824 		return (DCMD_ERR);
825 	}
826 
827 	mdb_printf("Reading remote_port at 0x%p\n", addr);
828 	mdb_printf("  mutex          : 0x%p\n", pd.pd_mutex);
829 	mdb_printf("  port_id        : 0x%-8x\n", pd.pd_port_id);
830 	mdb_printf("  port_name      : 0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
831 	    pd.pd_port_name.raw_wwn[0], pd.pd_port_name.raw_wwn[1],
832 	    pd.pd_port_name.raw_wwn[2], pd.pd_port_name.raw_wwn[3],
833 	    pd.pd_port_name.raw_wwn[4], pd.pd_port_name.raw_wwn[5],
834 	    pd.pd_port_name.raw_wwn[6], pd.pd_port_name.raw_wwn[7]);
835 	mdb_printf("  login_count    : %d\n", pd.pd_login_count);
836 	mdb_printf("  state          : 0x%x ", pd.pd_state);
837 
838 	switch (pd.pd_state) {
839 	case PORT_DEVICE_INVALID:
840 		mdb_printf("(invalid)\n");
841 		break;
842 	case PORT_DEVICE_VALID:
843 		mdb_printf("(valid)\n");
844 		break;
845 	case PORT_DEVICE_LOGGED_IN:
846 		mdb_printf("(logged in)\n");
847 		break;
848 	default:
849 		mdb_printf("(Unknown state)\n");
850 	}
851 
852 	mdb_printf("  remote node    : 0x%p\n", pd.pd_remote_nodep);
853 	mdb_printf("  hard_addr      : 0x%x\n", pd.pd_hard_addr);
854 	mdb_printf("  local port     : 0x%p\n", pd.pd_port);
855 	mdb_printf("  type           : %d ", pd.pd_type);
856 
857 	switch (pd.pd_type) {
858 	case PORT_DEVICE_NOCHANGE:
859 		mdb_printf("(No change)\n");
860 		break;
861 	case PORT_DEVICE_NEW:
862 		mdb_printf("(New)\n");
863 		break;
864 	case PORT_DEVICE_OLD:
865 		mdb_printf("(Old)\n");
866 		break;
867 	case PORT_DEVICE_CHANGED:
868 		mdb_printf("(Changed)\n");
869 		break;
870 	case PORT_DEVICE_DELETE:
871 		mdb_printf("(Delete)\n");
872 		break;
873 	case PORT_DEVICE_USER_LOGIN:
874 		mdb_printf("(User login)\n");
875 		break;
876 	case PORT_DEVICE_USER_LOGOUT:
877 		mdb_printf("(User logout)\n");
878 		break;
879 	case PORT_DEVICE_USER_CREATE:
880 		mdb_printf("(User create)\n");
881 		break;
882 	case PORT_DEVICE_USER_DELETE:
883 		mdb_printf("(User delete)\n");
884 		break;
885 	default:
886 		mdb_printf("(Unknown type)\n");
887 	}
888 
889 	mdb_printf("  flags          : 0x%x ", pd.pd_flags);
890 
891 	switch (pd.pd_flags) {
892 	case PD_IDLE:
893 		mdb_printf("(Idle)\n");
894 		break;
895 	case PD_ELS_IN_PROGRESS:
896 		mdb_printf("(ELS in progress)\n");
897 		break;
898 	case PD_ELS_MARK:
899 		mdb_printf("(Mark)\n");
900 		break;
901 	default:
902 		mdb_printf("(Unknown flag value)\n");
903 	}
904 
905 	mdb_printf("  login_class    : 0x%x\n", pd.pd_login_class);
906 	mdb_printf("  recipient      : %d\n", pd.pd_recepient);
907 	mdb_printf("  ref_count      : %d\n", pd.pd_ref_count);
908 	mdb_printf("  aux_flags      : 0x%x ", pd.pd_aux_flags);
909 
910 	first = 1;
911 	if (pd.pd_aux_flags & PD_IN_DID_QUEUE) {
912 		mdb_printf("(IN_DID_QUEUE");
913 		first = 0;
914 	}
915 
916 	if (pd.pd_aux_flags & PD_DISABLE_RELOGIN) {
917 		if (first) {
918 			mdb_printf("(DISABLE_RELOGIN");
919 		} else {
920 			mdb_printf(", DISABLE_RELOGIN");
921 		}
922 		first = 0;
923 	}
924 
925 	if (pd.pd_aux_flags & PD_NEEDS_REMOVAL) {
926 		if (first) {
927 			mdb_printf("(NEEDS_REMOVAL");
928 		} else {
929 			mdb_printf(", NEEDS_REMOVAL");
930 		}
931 		first = 0;
932 	}
933 
934 	if (pd.pd_aux_flags & PD_LOGGED_OUT) {
935 		if (first) {
936 			mdb_printf("(LOGGED_OUT");
937 		} else {
938 			mdb_printf(", LOGGED_OUT");
939 		}
940 		first = 0;
941 	}
942 
943 	if (pd.pd_aux_flags & PD_GIVEN_TO_ULPS) {
944 		if (first) {
945 			mdb_printf("(GIVEN_TO_ULPS");
946 		} else {
947 			mdb_printf(", GIVEN_TO_ULPS");
948 		}
949 		first = 0;
950 	}
951 
952 	if (first == 0) {
953 		mdb_printf(")\n");
954 	} else {
955 		mdb_printf("\n");
956 	}
957 
958 	mdb_printf("  sig            : %p\n", pd.pd_logo_tc.sig);
959 	mdb_printf("  active         : %d\n", pd.pd_logo_tc.active);
960 	mdb_printf("  counter        : %d\n", pd.pd_logo_tc.counter);
961 	mdb_printf("  max_value      : %d\n", pd.pd_logo_tc.max_value);
962 	mdb_printf("  timer          : %d\n", pd.pd_logo_tc.timer);
963 	mdb_printf("\n");
964 
965 	return (DCMD_OK);
966 }
967 
968 int
969 fc_dump_logmsg(fc_trace_dmsg_t *addr, uint_t pktstart, uint_t pktend,
970     uint_t *printed)
971 {
972 	fc_trace_dmsg_t	msg;
973 	caddr_t		buf;
974 	char		merge[1024];
975 	caddr_t		tmppkt;
976 	char		*tmpbuf; /* for tokenising the buffer */
977 	uint_t		pktnum = 0;
978 
979 	while (addr != NULL) {
980 		if (mdb_vread(&msg, sizeof (msg), (uintptr_t)addr) !=
981 		    sizeof (msg)) {
982 			mdb_warn("failed to read message pointer in kernel");
983 			return (DCMD_ERR);
984 		}
985 
986 		if (msg.id_size) {
987 
988 			buf = mdb_alloc(msg.id_size + 1, UM_SLEEP);
989 			tmppkt = mdb_alloc(msg.id_size + 1, UM_SLEEP);
990 
991 			if (mdb_vread(buf, msg.id_size,
992 			    (uintptr_t)msg.id_buf) != msg.id_size) {
993 				mdb_warn("failed to read buffer contents"
994 				    " in kernel");
995 				mdb_free(buf, msg.id_size + 1);
996 				return (DCMD_ERR);
997 			}
998 
999 			if (buf[0] == '\n') {
1000 				mdb_printf("There is a problem in"
1001 				    "the buffer\n");
1002 			}
1003 			/* funky packet processing stuff */
1004 			bcopy(buf, tmppkt, msg.id_size + 1);
1005 
1006 			/* find the equals sign, and put a null there */
1007 			tmpbuf = strchr(tmppkt, '=');
1008 			*tmpbuf = 0;
1009 			pktnum = (uint_t)mdb_strtoull(tmppkt);
1010 
1011 			if ((pktnum >= pktstart) && (pktnum <= pktend)) {
1012 				(void) mdb_snprintf(merge, sizeof (merge),
1013 				    "[%Y:%03d:%03d:%03d] %s",
1014 				    msg.id_time.tv_sec,
1015 				    (int)msg.id_time.tv_nsec/1000000,
1016 				    (int)(msg.id_time.tv_nsec/1000)%1000,
1017 				    (int)msg.id_time.tv_nsec%1000, buf);
1018 				mdb_printf("%s", merge);
1019 				if (printed != NULL)
1020 					(*printed) ++;
1021 			}
1022 			mdb_free(buf, msg.id_size + 1);
1023 			mdb_free(tmppkt, msg.id_size + 1);
1024 		}
1025 		addr = msg.id_next;
1026 	}
1027 
1028 	return (DCMD_OK);
1029 }
1030 
1031 int
1032 fc_dump_old_logmsg(fc_trace_dmsgv1_t *addr, uint_t pktstart, uint_t pktend,
1033     uint_t *printed)
1034 {
1035 	fc_trace_dmsgv1_t	msg;
1036 	caddr_t			buf;
1037 	char			merge[1024];
1038 	caddr_t			tmppkt;
1039 	char			*tmpbuf; /* for tokenising the buffer */
1040 	uint_t			pktnum = 0;
1041 
1042 	while (addr != NULL) {
1043 		if (mdb_vread(&msg, sizeof (msg), (uintptr_t)addr) !=
1044 		    sizeof (msg)) {
1045 			mdb_warn("failed to read message pointer in kernel");
1046 			return (DCMD_ERR);
1047 		}
1048 
1049 		if (msg.id_size) {
1050 
1051 			buf = mdb_alloc(msg.id_size + 1, UM_SLEEP);
1052 			tmppkt = mdb_alloc(msg.id_size + 1, UM_SLEEP);
1053 
1054 			if (mdb_vread(buf, msg.id_size,
1055 			    (uintptr_t)msg.id_buf) != msg.id_size) {
1056 				mdb_warn("failed to read buffer contents"
1057 				    " in kernel");
1058 				mdb_free(buf, msg.id_size + 1);
1059 				return (DCMD_ERR);
1060 			}
1061 
1062 			if (buf[0] == '\n') {
1063 				mdb_printf("There is a problem in"
1064 				    "the buffer\n");
1065 			}
1066 			/* funky packet processing stuff */
1067 			bcopy(buf, tmppkt, msg.id_size + 1);
1068 
1069 			tmpbuf = strchr(tmppkt, '=');
1070 			*tmpbuf = 0;
1071 			pktnum = (uint_t)mdb_strtoull(tmppkt);
1072 
1073 			if ((pktnum >= pktstart) && (pktnum <= pktend)) {
1074 				(void) mdb_snprintf(merge, sizeof (merge),
1075 				    "[%Y] %s", msg.id_time, buf);
1076 				mdb_printf("%s", merge);
1077 				if (printed != NULL)
1078 					(*printed) ++;
1079 			}
1080 			mdb_free(buf, msg.id_size + 1);
1081 			mdb_free(tmppkt, msg.id_size + 1);
1082 		}
1083 		addr = msg.id_next;
1084 	}
1085 
1086 	return (DCMD_OK);
1087 }
1088 
1089 int
1090 fc_trace_dump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1091 {
1092 	fc_trace_logq_t logq;
1093 	uint_t		pktnum = 0;
1094 	uint_t		printed = 0; /* have we printed anything? */
1095 
1096 	uintptr_t	pktstart = 0;
1097 	uintptr_t	pktend = UINT_MAX;
1098 	int		rval = DCMD_OK;
1099 
1100 	if (mdb_vread(&logq, sizeof (logq), addr) != sizeof (logq)) {
1101 		mdb_warn("Failed to read log queue in kernel");
1102 		return (DCMD_ERR);
1103 	}
1104 
1105 	if (mdb_getopts(argc, argv,
1106 	    's', MDB_OPT_UINTPTR, &pktstart,
1107 	    'e', MDB_OPT_UINTPTR, &pktend) != argc) {
1108 		return (DCMD_USAGE);
1109 	}
1110 
1111 	if (pktstart > pktend) {
1112 		return (DCMD_USAGE);
1113 	}
1114 
1115 	if ((logq.il_flags & FC_TRACE_LOGQ_V2) != 0) {
1116 		rval = fc_dump_logmsg((fc_trace_dmsg_t *)logq.il_msgh, pktstart,
1117 		    pktend, &printed);
1118 	} else {
1119 		rval = fc_dump_old_logmsg((fc_trace_dmsgv1_t *)logq.il_msgh,
1120 		    pktstart, pktend, &printed);
1121 	}
1122 
1123 	if (rval != DCMD_OK) {
1124 		return (rval);
1125 	}
1126 
1127 	if (printed == 0) {
1128 		mdb_printf("No packets in the buffer match the"
1129 		    " criteria given");
1130 	}
1131 
1132 	return (rval);
1133 }
1134 
1135 int
1136 fp_trace_dump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1137 {
1138 	if (mdb_readvar(&addr, "fp_logq") == -1) {
1139 		mdb_warn("failed to read fp_logq");
1140 		return (DCMD_ERR);
1141 	}
1142 
1143 	if (DCMD_HDRSPEC(flags)) {
1144 		mdb_printf("fp trace buffer contents\n");
1145 	}
1146 
1147 	return (fc_trace_dump(addr, flags, argc, argv));
1148 }
1149 
1150 
1151 int
1152 fcp_trace_dump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1153 {
1154 	if (mdb_readvar(&addr, "fcp_logq") == -1) {
1155 		mdb_warn("failed to read fcp_logq");
1156 		return (DCMD_ERR);
1157 	}
1158 
1159 	if (DCMD_HDRSPEC(flags)) {
1160 		mdb_printf("fcp trace buffer contents\n");
1161 	}
1162 
1163 	return (fc_trace_dump(addr, flags, argc, argv));
1164 }
1165 
1166 /*
1167  * Leadville job_request walker/dcmd code
1168  */
1169 
1170 /*
1171  * We need to be given the address of a local port structure in order to start
1172  * walking.  From that, we can read the job_request list.
1173  */
1174 
1175 static int
1176 job_request_walk_i(mdb_walk_state_t *wsp)
1177 {
1178 	if (wsp->walk_addr == NULL) {
1179 		mdb_warn("The address of a fc_local_port"
1180 		    " structure must be given\n");
1181 		return (WALK_ERR);
1182 	}
1183 
1184 	/*
1185 	 * Input should be a fc_local_port_t, so read it to get the job_request
1186 	 * lists's head
1187 	 */
1188 
1189 	if (mdb_vread(&port, sizeof (fc_local_port_t), wsp->walk_addr) !=
1190 	    sizeof (fc_local_port_t)) {
1191 		mdb_warn("Failed to read in the fc_local_port"
1192 		    " at 0x%p\n", wsp->walk_addr);
1193 		return (WALK_ERR);
1194 	}
1195 
1196 	wsp->walk_addr = (uintptr_t)(port.fp_job_head);
1197 	wsp->walk_data = mdb_alloc(sizeof (struct job_request), UM_SLEEP);
1198 
1199 	return (WALK_NEXT);
1200 }
1201 
1202 static int
1203 job_request_walk_s(mdb_walk_state_t *wsp)
1204 {
1205 	int status;
1206 
1207 	if (wsp->walk_addr == NULL)
1208 		return (WALK_DONE);
1209 
1210 	if (mdb_vread(wsp->walk_data, sizeof (struct job_request),
1211 	    wsp->walk_addr) == -1) {
1212 		mdb_warn("Failed to read in the job_request at 0x%p\n",
1213 		    wsp->walk_addr);
1214 		return (WALK_DONE);
1215 	}
1216 
1217 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1218 	    wsp->walk_cbdata);
1219 
1220 	wsp->walk_addr =
1221 	    (uintptr_t)(((struct job_request *)wsp->walk_data)->job_next);
1222 
1223 	return (status);
1224 }
1225 
1226 /*
1227  * The walker's fini function is invoked at the end of each walk.
1228  */
1229 static void
1230 job_request_walk_f(mdb_walk_state_t *wsp)
1231 {
1232 	mdb_free(wsp->walk_data, sizeof (struct job_request));
1233 }
1234 
1235 
1236 /*
1237  * Leadville fc_orphan walker/dcmd code
1238  */
1239 
1240 /*
1241  * We need to be given the address of a port structure in order to start
1242  * walking.  From that, we can read the orphan list.
1243  */
1244 
1245 static int
1246 orphan_walk_i(mdb_walk_state_t *wsp)
1247 {
1248 	if (wsp->walk_addr == NULL) {
1249 		mdb_warn("The address of a fc_local_port"
1250 		    " structure must be given\n");
1251 		return (WALK_ERR);
1252 	}
1253 
1254 	/*
1255 	 * Input should be a fc_local_port_t, so read it to get the orphan
1256 	 * lists's head
1257 	 */
1258 
1259 	if (mdb_vread(&port, sizeof (fc_local_port_t), wsp->walk_addr) !=
1260 	    sizeof (fc_local_port_t)) {
1261 		mdb_warn("Failed to read in the fc_local_port"
1262 		    " at 0x%p\n", wsp->walk_addr);
1263 		return (WALK_ERR);
1264 	}
1265 
1266 	wsp->walk_addr = (uintptr_t)(port.fp_orphan_list);
1267 	wsp->walk_data = mdb_alloc(sizeof (struct fc_orphan), UM_SLEEP);
1268 
1269 	return (WALK_NEXT);
1270 }
1271 
1272 static int
1273 orphan_walk_s(mdb_walk_state_t *wsp)
1274 {
1275 	int status;
1276 
1277 	if (wsp->walk_addr == NULL)
1278 		return (WALK_DONE);
1279 
1280 	if (mdb_vread(wsp->walk_data, sizeof (struct fc_orphan),
1281 	    wsp->walk_addr) == -1) {
1282 		mdb_warn("Failed to read in the fc_orphan at 0x%p\n",
1283 		    wsp->walk_addr);
1284 		return (WALK_DONE);
1285 	}
1286 
1287 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1288 	    wsp->walk_cbdata);
1289 
1290 	wsp->walk_addr =
1291 	    (uintptr_t)(((struct fc_orphan *)wsp->walk_data)->orp_next);
1292 
1293 	return (status);
1294 }
1295 
1296 /*
1297  * The walker's fini function is invoked at the end of each walk.
1298  */
1299 static void
1300 orphan_walk_f(mdb_walk_state_t *wsp)
1301 {
1302 	mdb_free(wsp->walk_data, sizeof (struct fc_orphan));
1303 }
1304 
1305 
1306 /*
1307  * MDB module linkage information:
1308  *
1309  * We declare a list of structures describing our dcmds, a list of structures
1310  * describing our walkers, and a function named _mdb_init to return a pointer
1311  * to our module information.
1312  */
1313 
1314 static const mdb_dcmd_t dcmds[] = {
1315 	{ "ports", "[-l]", "Leadville port list", ports },
1316 	{ "ulps", NULL, "Leadville ULP list", ulps },
1317 	{ "ulpmods", NULL, "Leadville ULP module list", ulpmods },
1318 	{ "fcport", NULL, "Display a Leadville fc_local_port structure",
1319 	    fcport },
1320 	{ "remote_port", NULL, "Display fc_remote_port structures",
1321 	    remote_port },
1322 	{ "fcptrace", "[-s m][-e n] (m < n)", "Dump the fcp trace buffer, "
1323 	    "optionally supplying starting and ending packet numbers.",
1324 	    fcp_trace_dump, NULL },
1325 	{ "fptrace", "[-s m][-e n] (m < n)", "Dump the fp trace buffer, "
1326 	    "optionally supplying starting and ending packet numbers.",
1327 	    fp_trace_dump, NULL },
1328 	{ NULL }
1329 };
1330 
1331 static const mdb_walker_t walkers[] = {
1332 	{ "ports", "walk list of Leadville port structures",
1333 	    port_walk_i, port_walk_s, port_walk_f },
1334 	{ "ulps", "walk list of Leadville ULP structures",
1335 	    ulp_walk_i, ulp_walk_s, ulp_walk_f },
1336 	{ "ulpmods", "walk list of Leadville ULP module structures",
1337 	    ulpmod_walk_i, ulpmod_walk_s, ulpmod_walk_f },
1338 	{ "pd_by_pwwn", "walk list of fc_remote_port structures hashed by PWWN",
1339 	    pd_by_pwwn_walk_i, pd_by_pwwn_walk_s, pd_by_pwwn_walk_f },
1340 	{ "pd_by_did", "walk list of fc_remote_port structures hashed by D_ID",
1341 	    pd_by_did_walk_i, pd_by_did_walk_s, pd_by_did_walk_f },
1342 	{ "job_request", "walk list of job_request structures for a local port",
1343 	    job_request_walk_i, job_request_walk_s, job_request_walk_f },
1344 	{ "orphan", "walk list of orphan structures for a local port",
1345 	    orphan_walk_i, orphan_walk_s, orphan_walk_f },
1346 	{ NULL }
1347 };
1348 
1349 static const mdb_modinfo_t modinfo = {
1350 	MDB_API_VERSION, dcmds, walkers
1351 };
1352 
1353 const mdb_modinfo_t *
1354 _mdb_init(void)
1355 {
1356 	return (&modinfo);
1357 }
1358