xref: /titanic_44/usr/src/cmd/mdb/common/modules/sdbc/sdbc.c (revision 1f6eb0216cb17ca5fdff9563329f1dda47c8b801)
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 
26 #include <sys/mdb_modapi.h>
27 #include <sys/nsc_thread.h>
28 
29 /* needed to maintain identical _sd_bitmap_t sizes */
30 #define	_SD_8K_BLKSIZE
31 #include <sys/nsctl/sd_bcache.h>
32 
33 #include <ns/sdbc/sd_io.h>
34 #include <ns/sdbc/sd_ft.h>
35 #include <ns/sdbc/safestore.h>
36 
37 /*
38  * initialize cd filter options to this
39  * to differentiate with kernel values in range [-1, sdbc_max_devs]
40  */
41 #define	MDB_CD ((uintptr_t)~1)
42 #define	OPT_C_SELECTED (opt_c != MDB_CD)
43 
44 /* initialize block filters to this */
45 #define	MDB_BLKNUM ((uintptr_t)~1)
46 #define	OPT_B_SELECTED (opt_b != MDB_BLKNUM)
47 
48 enum vartype { UINTTYPE = 0, ADDRTYPE, LOCKTYPE, CVTYPE };
49 
50 static void display_var(char *, enum vartype);
51 #ifdef SAFESTORE
52 static void print_wrq(_sd_writeq_t *, uint_t);
53 #endif
54 
55 struct walk_info {
56 		uintptr_t w_start;
57 		uintptr_t w_end;
58 };
59 
60 
61 mdb_bitmask_t host_states[] = {
62 	{ "HOST_NONE", 0xff, _SD_HOST_NONE },
63 	{ "HOST_CONFIGURED", 0xff, _SD_HOST_CONFIGURED },
64 	{ "HOST_DECONFIGURED", 0xff, _SD_HOST_DECONFIGURED },
65 	{ "HOST_NOCACHE", 0xff, _SD_HOST_NOCACHE },
66 	{ NULL, 0, 0 }
67 
68 };
69 
70 mdb_bitmask_t cache_hints[] = {
71 	{ "WRTHRU", NSC_WRTHRU, NSC_WRTHRU },
72 	{ "FORCED_WRTHRU", NSC_FORCED_WRTHRU, NSC_FORCED_WRTHRU },
73 	{ "NOCACHE", NSC_NOCACHE, NSC_NOCACHE },
74 	{ "QUEUE", NSC_QUEUE, NSC_QUEUE },
75 	{ "RDAHEAD", NSC_RDAHEAD, NSC_RDAHEAD },
76 	{ "NO_FORCED_WRTHRU", NSC_NO_FORCED_WRTHRU, NSC_NO_FORCED_WRTHRU },
77 	{ "METADATA", NSC_METADATA, NSC_METADATA },
78 	{ "SEQ_IO", NSC_SEQ_IO, NSC_SEQ_IO },
79 	{ NULL, 0, 0 }
80 
81 };
82 
83 
84 /*
85  * some cache general dcmds that do not use walkers
86  */
87 /*ARGSUSED*/
88 static int
89 sdbc_config(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
90 {
91 	_sd_cache_param_t _sd_cache_config;
92 	_sd_net_t _sd_net_config;
93 	_sd_ft_info_t  _sd_ft_data;
94 	uint_t _sd_node_hint;
95 	char sdbc_version[17];
96 
97 	if (mdb_readvar(sdbc_version, "sdbc_version") == -1) {
98 		mdb_warn("failed to read sdbc_version symbol");
99 	} else {
100 		sdbc_version[16] = '\0';  /* make sure string is terminated */
101 		mdb_printf("sdbc_version %s\n", sdbc_version);
102 	}
103 
104 	if (mdb_readvar(&_sd_cache_config, "_sd_cache_config") == -1) {
105 		mdb_warn("failed to read _sd_cache_config symbol");
106 	} else {
107 
108 		mdb_printf("SDBC Configuration:\n");
109 		mdb_inc_indent(4);
110 		mdb_printf("user magic: %X kernel magic: %X (should match)\n",
111 			    _SD_MAGIC, _sd_cache_config.magic);
112 		mdb_printf(
113 		    "mirror host: %2d Block size: %4d threads %4d "
114 		    "write cache: %4dM\n",
115 			    _sd_cache_config.mirror_host,
116 			    _sd_cache_config.blk_size,
117 			    _sd_cache_config.threads,
118 			    _sd_cache_config.write_cache);
119 		mdb_printf("num_handles %4-d cache_mem %4dM prot_lru %d\n",
120 			    _sd_cache_config.num_handles,
121 			    _sd_cache_config.cache_mem[0],
122 			    _sd_cache_config.prot_lru);
123 		mdb_printf("gen_pattern %d fill_pattern %?-p num_nodes %d\n",
124 			    _sd_cache_config.gen_pattern,
125 			    _sd_cache_config.fill_pattern,
126 			    _sd_cache_config.num_nodes);
127 		mdb_dec_indent(4);
128 	}
129 
130 	if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) {
131 		mdb_warn("failed to read _sd_net_config symbol");
132 	} else {
133 		mdb_inc_indent(4);
134 		mdb_printf(
135 	"psize %4-d configured %d csize %10-d wsize %10-d cpages %6d\n",
136 			_sd_net_config.sn_psize,
137 			_sd_net_config.sn_configured,
138 			_sd_net_config.sn_csize,
139 			_sd_net_config.sn_wsize,
140 			_sd_net_config.sn_cpages);
141 
142 		mdb_dec_indent(4);
143 #ifdef SAFESTORE
144 		print_wrq(&(_sd_net_config.sn_wr_queue), FALSE);
145 #endif
146 	}
147 
148 
149 	if (mdb_readvar(&_sd_ft_data, "_sd_ft_data") == -1) {
150 		mdb_warn("failed to read _sd_ft_data symbol");
151 
152 	} else {
153 		mdb_printf("FT data:\n");
154 		mdb_inc_indent(4);
155 		mdb_printf("crashed %d host_state <%b> numio %d\n",
156 			_sd_ft_data.fi_crashed,
157 			_sd_ft_data.fi_host_state, host_states,
158 			_sd_ft_data.fi_numio);
159 		mdb_printf("lock %?-p (owner) rem_sv %h-x sleep %?-p (owner)\n",
160 			_sd_ft_data.fi_lock._opaque[0],
161 			_sd_ft_data.fi_rem_sv._opaque,
162 			_sd_ft_data.fi_sleep._opaque[0]);
163 		mdb_dec_indent(4);
164 	}
165 
166 	if (mdb_readvar(&_sd_node_hint, "_sd_node_hint") == -1) {
167 		mdb_warn("failed to read _sd_node_hint symbol");
168 
169 	} else
170 		mdb_printf("Node Hints: %08x <%b>\n",
171 			_sd_node_hint, cache_hints);
172 
173 	display_var("sdbc_wrthru_len", UINTTYPE);
174 	display_var("_sd_debug_level", UINTTYPE);
175 	display_var("_sdbc_attached", UINTTYPE);
176 
177 	return (DCMD_OK);
178 }
179 
180 static void
181 sdbc_hit_percent(uint_t hits, uint_t misses, char *type)
182 {
183 	uint64_t dhits, dmisses;
184 	uint64_t hit_rate = 0;
185 
186 	mdb_printf("%s hits: %u\t %s misses: %u\n", type, hits, type, misses);
187 
188 	/* a little crude. anything less than 1 percent will show as 0 */
189 	if (hits > 0 || misses > 0) {
190 		dhits = (uint64_t)hits;
191 		dmisses = (uint64_t)misses;
192 		hit_rate = (dhits * 100)/ (dhits + dmisses);
193 		mdb_printf("%s hit rate: %lld %%\n", type, hit_rate);
194 	}
195 	mdb_printf("\n");
196 }
197 
198 /*ARGSUSED*/
199 static int
200 sdbc_stats(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
201 {
202 	int i;
203 	char *fn;
204 	_sd_stats_t *_sd_cache_stats; /* local memory */
205 	uintptr_t _sd_cache_statsp; /* kernel pointer */
206 	_sd_shared_t *sh;
207 	int statssize;
208 	GElf_Sym sym;
209 	int maxdevs;
210 
211 	if (argc != 0)
212 		return (DCMD_USAGE);
213 
214 	/* get the number of volumes */
215 	if (mdb_readvar(&maxdevs, "sdbc_max_devs") == -1) {
216 		mdb_warn("failed to read  sdbc_max_devs");
217 		return (DCMD_ERR);
218 	}
219 
220 	statssize = sizeof (_sd_stats_t) + (maxdevs - 1) *
221 						sizeof (_sd_shared_t);
222 
223 	_sd_cache_stats = mdb_zalloc(statssize, UM_SLEEP);
224 
225 	if (mdb_lookup_by_obj("sdbc", "_sd_cache_stats", &sym) == -1) {
226 		mdb_warn("failed to lookup _sd_cache_stats symbol");
227 		return (DCMD_ERR);
228 	}
229 
230 	if (mdb_vread(&_sd_cache_statsp, sizeof (uintptr_t),
231 						sym.st_value) == -1) {
232 		mdb_warn("failed to read _sd_stats_t pointer");
233 		return (DCMD_ERR);
234 	}
235 
236 	if (mdb_vread(_sd_cache_stats, statssize, _sd_cache_statsp) == -1) {
237 		mdb_warn("failed to read _sd_stats_t structure");
238 		return (DCMD_ERR);
239 	}
240 
241 	mdb_printf("Storage Device Block Cache Statistics\n");
242 	mdb_printf("-------------------------------------\n");
243 
244 	i = _sd_cache_stats->st_blksize;
245 	mdb_printf("Blocksize: 0x%x (%d)\n", i, i);
246 
247 	mdb_printf("\n");
248 	sdbc_hit_percent(_sd_cache_stats->st_rdhits, _sd_cache_stats->st_rdmiss,
249 				"Read");
250 	sdbc_hit_percent(_sd_cache_stats->st_wrhits, _sd_cache_stats->st_wrmiss,
251 				"Write");
252 
253 	mdb_printf("%3s %10s %8s %8s %8s %8s %8s %7s %4s %4s %s\n",
254 		"Cd", "Dev", "Size",
255 		"CacheRd", "CacheWr", "DiskRd", "DiskWr",
256 		"DirtyBl", "#IO", "Fail", "F");
257 	for (i = 0; i < maxdevs; i++) {
258 		sh = &_sd_cache_stats->st_shared[i];
259 		if (!sh->sh_alloc)
260 			continue;
261 		fn = strrchr(sh->sh_filename, '/');
262 		fn = fn ? fn+1 : sh->sh_filename;
263 		mdb_printf("%3d %10s %7d %8d %8d %8d %8d %7d %4d %4d %d\n",
264 			sh->sh_cd, fn, sh->sh_filesize,
265 			sh->sh_cache_read, sh->sh_cache_write,
266 			sh->sh_disk_read, sh->sh_disk_write,
267 			sh->sh_numdirty, sh->sh_numio, sh->sh_numfail,
268 			sh->sh_failed);
269 	}
270 
271 	mdb_free(_sd_cache_stats, statssize);
272 	return (DCMD_OK);
273 }
274 
275 /*
276  * display some variables and counters
277  */
278 static void
279 display_var(char *name, enum vartype type)
280 {
281 	uint_t		uintval;
282 	uintptr_t	addrval;
283 	kmutex_t	lockval;
284 	kcondvar_t	cvval;
285 
286 	switch (type) {
287 		case UINTTYPE:
288 			if (mdb_readvar(&uintval, name) == -1) {
289 				mdb_warn("failed to read %s variable", name);
290 			} else
291 				mdb_printf("%s =\t%8x %12u\n",
292 						    name, uintval, uintval);
293 			break;
294 		case ADDRTYPE:
295 			if (mdb_readvar(&addrval, name) == -1) {
296 				mdb_warn("failed to read %s variable", name);
297 			} else
298 				mdb_printf("%s =\t%?-p\n",
299 						    name, addrval);
300 			break;
301 		case LOCKTYPE:
302 			if (mdb_readvar(&lockval, name) == -1) {
303 				mdb_warn("failed to read %s lock variable",
304 								name);
305 			} else
306 				mdb_printf("%s =\t%-p (owner)\n",
307 						name, lockval._opaque[0]);
308 			break;
309 		case CVTYPE:
310 			if (mdb_readvar(&cvval, name) == -1) {
311 				mdb_warn("failed to read %s condvar variable",
312 								name);
313 			} else
314 				mdb_printf("%s = \t%h-x\n",
315 						name, cvval._opaque);
316 			break;
317 		default:
318 			mdb_warn("display_var: unknown type");
319 	}
320 }
321 
322 mdb_bitmask_t dealloc_flag_vals[] = {
323 	{ "PROCESS_CACHE_DM", (u_longlong_t)~0, PROCESS_CACHE_DM },
324 	{ "CACHE_SHUTDOWN_DM", (u_longlong_t)~0, CACHE_SHUTDOWN_DM },
325 	{ "CACHE_THREAD_TERMINATED_DM",
326 	    (u_longlong_t)~0, CACHE_THREAD_TERMINATED_DM },
327 	{ "TIME_DELAY_LVL0", (u_longlong_t)~0, TIME_DELAY_LVL0 },
328 	{ "TIME_DELAY_LVL1", (u_longlong_t)~0, TIME_DELAY_LVL1 },
329 	{ "TIME_DELAY_LVL2", (u_longlong_t)~0, TIME_DELAY_LVL2 },
330 	{ NULL, 0, 0 }
331 };
332 
333 mdb_bitmask_t mdp_bits[] = {
334 	{ "MONITOR_DYNMEM_PROCESS_DEFAULT",
335 	    (u_longlong_t)~0, MONITOR_DYNMEM_PROCESS_DEFAULT},
336 	{ "RPT_SHUTDOWN_PROCESS_DM",
337 	    RPT_SHUTDOWN_PROCESS_DM, RPT_SHUTDOWN_PROCESS_DM },
338 	{ "RPT_DEALLOC_STATS1_DM",
339 	    RPT_DEALLOC_STATS1_DM, RPT_DEALLOC_STATS1_DM },
340 	{ "RPT_DEALLOC_STATS2_DM",
341 	    RPT_DEALLOC_STATS2_DM, RPT_DEALLOC_STATS2_DM },
342 	{ NULL, 0, 0 }
343 };
344 
345 mdb_bitmask_t process_directive_bits[] = {
346 	{ "PROCESS_DIRECTIVE_DEFAULT",
347 	    (u_longlong_t)~0, PROCESS_DIRECTIVE_DEFAULT },
348 	{ "WAKE_DEALLOC_THREAD_DM",
349 	    WAKE_DEALLOC_THREAD_DM, WAKE_DEALLOC_THREAD_DM },
350 	{ "MAX_OUT_ACCEL_HIST_FLAG_DM",
351 	    MAX_OUT_ACCEL_HIST_FLAG_DM, MAX_OUT_ACCEL_HIST_FLAG_DM},
352 	{ NULL, 0, 0 }
353 };
354 
355 /*ARGSUSED*/
356 static int
357 sdbc_vars(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
358 {
359 	int sd_dealloc_flag_dm;
360 	_dm_process_vars_t dynmem_processing_dm;
361 
362 	if (argc != 0)
363 		return (DCMD_USAGE);
364 
365 	mdb_printf("counters and other variables:\n");
366 	mdb_inc_indent(4);
367 
368 	display_var("xmem_inval_hit", UINTTYPE);
369 	display_var("xmem_inval_miss", UINTTYPE);
370 	display_var("xmem_inval_inuse", UINTTYPE);
371 
372 	display_var("sdbc_allocb_pageio1", UINTTYPE);
373 	display_var("sdbc_allocb_pageio2", UINTTYPE);
374 	display_var("sdbc_allocb_inuse", UINTTYPE);
375 	display_var("sdbc_allocb_hit", UINTTYPE);
376 	display_var("sdbc_allocb_lost", UINTTYPE);
377 	display_var("sdbc_pageio_always", UINTTYPE);
378 	display_var("sdbc_do_page", UINTTYPE);
379 	display_var("sdbc_flush_pageio", UINTTYPE);
380 
381 	display_var("sdbc_centry_hit", UINTTYPE);
382 	display_var("sdbc_centry_inuse", UINTTYPE);
383 	display_var("sdbc_centry_lost", UINTTYPE);
384 	display_var("sdbc_centry_deallocd", UINTTYPE);
385 
386 	display_var("_sd_prefetch_opt", UINTTYPE);
387 
388 	display_var("sdbc_ra_hash", UINTTYPE);
389 	display_var("sdbc_ra_none", UINTTYPE);
390 
391 	display_var("sdbc_static_cache", UINTTYPE);
392 	display_var("sdbc_use_dmchain", UINTTYPE);
393 
394 	/* in no particular order ... */
395 	display_var("sdbc_check_cot", UINTTYPE);
396 	display_var("_sd_cctl_groupsz", UINTTYPE);
397 	display_var("CBLOCKS", UINTTYPE);
398 	display_var("_SD_SELF_HOST", UINTTYPE);
399 	display_var("_SD_MIRROR_HOST", UINTTYPE);
400 	display_var("sdbc_bio_count", UINTTYPE);
401 	display_var("_sd_cblock_shift", UINTTYPE);
402 	display_var("_sd_nodes_configured", UINTTYPE);
403 	display_var("nv_alloc_factor", UINTTYPE);
404 	display_var("_sd_ft_exit", UINTTYPE);
405 	display_var("_sd_flush_exit", UINTTYPE);
406 	display_var("_sd_node_recovery", UINTTYPE);
407 	display_var("_sd_async_recovery", UINTTYPE);
408 	display_var("_sdbc_ft_hold_io", UINTTYPE);
409 	display_var("mirror_clean_shutdown", UINTTYPE);
410 	display_var("_sd_ft_warm_start", UINTTYPE);
411 	mdb_dec_indent(4);
412 	mdb_printf("\n");
413 
414 	/* some addresses of various lists and tables */
415 	mdb_printf("Addresses:\n");
416 	mdb_inc_indent(4);
417 	display_var("_sd_htable", ADDRTYPE);
418 	display_var("_sdbc_gl_centry_info", ADDRTYPE);
419 	display_var("_sdbc_gl_centry_info_nvmem", ADDRTYPE);
420 	display_var("_sdbc_gl_centry_info_size", ADDRTYPE); /* size_t */
421 	display_var("_sdbc_gl_file_info", ADDRTYPE);
422 	display_var("_sdbc_gl_file_info_size", ADDRTYPE); /* size_t */
423 	mdb_dec_indent(4);
424 	mdb_printf("\n");
425 
426 	/* dynamic memory variables */
427 	mdb_printf("Dynamic Memory variables and stats:\n");
428 	mdb_inc_indent(4);
429 	display_var("_sdbc_memtype_deconfigure_delayed", UINTTYPE);
430 
431 	if (mdb_readvar(&sd_dealloc_flag_dm, "sd_dealloc_flag_dm") == -1) {
432 		mdb_warn("failed to read sd_dealloc_flag_dm symbol");
433 	} else
434 		mdb_printf("sd_dealloc_flag_dm %08x <%b>\n",
435 				sd_dealloc_flag_dm,
436 				sd_dealloc_flag_dm, dealloc_flag_vals);
437 
438 	if (mdb_readvar(&dynmem_processing_dm, "dynmem_processing_dm") == -1) {
439 		mdb_warn("failed to read dynmem_processing_dm structure");
440 	} else {
441 		_dm_process_vars_t *dp;
442 
443 		dp = &dynmem_processing_dm;
444 
445 		mdb_printf(
446 		"thread_dm_cv %h-x thread_dm_lock %?-p (owner)\n",
447 			dp->thread_dm_cv._opaque,
448 			dp->thread_dm_lock._opaque[0]);
449 
450 		mdb_printf("sd_dealloc_flagx %x %8Tmax_dyn_list %3-d\n",
451 			dp->sd_dealloc_flagx,
452 			dp->max_dyn_list);
453 
454 		mdb_printf("monitor_dynmem_process <%b>\n",
455 			dp->monitor_dynmem_process, mdp_bits);
456 
457 		mdb_printf(
458 	"cache_aging_ct1 %3-d  %8Tcache_aging_ct2 %3-d cache_aging_ct3 %3-d\n",
459 			dp->cache_aging_ct1,
460 			dp->cache_aging_ct2,
461 			dp->cache_aging_ct3);
462 
463 		mdb_printf(
464 			"cache_aging_sec1 %3-d %8Tcache_aging_sec2 %3-d"
465 			" cache_aging_sec3 %3-d\n",
466 			dp->cache_aging_sec1,
467 			dp->cache_aging_sec2,
468 			dp->cache_aging_sec3);
469 
470 		mdb_printf("cache_aging_pcnt1 %3-d %8Tcache_aging_pcnt2 %3-d\n",
471 			dp->cache_aging_pcnt1,
472 			dp->cache_aging_pcnt2);
473 
474 		mdb_printf(
475 		    "max_holds_pcnt %3-d %8Talloc_ct %8-d dealloc_ct %8-d\n",
476 			dp->max_holds_pcnt,
477 			dp->alloc_ct,
478 			dp->dealloc_ct);
479 
480 		mdb_printf(
481 		"history %4x %8Tnodatas %8-d notavail %8-d candidates %8-d\n",
482 			dp->history,
483 			dp->nodatas,
484 			dp->notavail,
485 			dp->candidates);
486 
487 		mdb_printf(
488 			"deallocs %8-d %8Thosts %8-d pests %8-d metas %8-d\n",
489 			dp->deallocs,
490 			dp->hosts,
491 			dp->pests,
492 			dp->metas);
493 
494 		mdb_printf("holds %8-d %8Tothers %8-d\n",
495 			dp->holds,
496 			dp->others);
497 
498 		mdb_printf("process_directive <%b>\n",
499 			dp->process_directive, process_directive_bits);
500 
501 		mdb_printf("read_hits %8-d %8Tread_misses %8-d\n",
502 			dp->read_hits,
503 			dp->read_misses);
504 
505 		mdb_printf(
506 		    "write_thru %8-d %8Twrite_hits %8-d write_misses %8-d\n",
507 			dp->write_hits,
508 			dp->write_misses,
509 			dp->write_thru);
510 
511 		mdb_printf("prefetch_hits %8-d prefetch_misses %8-d\n",
512 			dp->prefetch_hits,
513 			dp->prefetch_misses);
514 	}
515 	mdb_dec_indent(4);
516 	mdb_printf("\n");
517 
518 	/* some locks and condition variables */
519 	mdb_printf("Locks:\n");
520 	mdb_inc_indent(4);
521 	display_var("mutex_and_condvar_flag", UINTTYPE);
522 	display_var("_sd_cache_lock", LOCKTYPE);
523 	display_var("_sd_block_lk", LOCKTYPE);
524 	display_var("_sdbc_config_lock", LOCKTYPE);
525 	display_var("_sdbc_ft_hold_io_lk", LOCKTYPE);
526 	display_var("_sd_flush_cv", CVTYPE);
527 	display_var("_sdbc_ft_hold_io_cv", CVTYPE);
528 	mdb_dec_indent(4);
529 	mdb_printf("\n");
530 
531 	return (DCMD_OK);
532 }
533 
534 const mdb_bitmask_t nsc_buf_bits[] = {
535 	{"HALLOCATED", NSC_HALLOCATED, NSC_HALLOCATED},
536 	{"HACTIVE", NSC_HACTIVE, NSC_HACTIVE},
537 	{"RDBUF", NSC_RDBUF, NSC_RDBUF},
538 	{"WRBUF", NSC_WRBUF, NSC_WRBUF},
539 	{"NOBLOCK", NSC_NOBLOCK, NSC_NOBLOCK},
540 	{"WRTHRU", NSC_WRTHRU, NSC_WRTHRU},
541 	{"NOCACHE", NSC_NOCACHE, NSC_NOCACHE},
542 	{"BCOPY", NSC_BCOPY, NSC_BCOPY},
543 	{"PAGEIO", NSC_PAGEIO, NSC_PAGEIO},
544 	{"PINNABLE", NSC_PINNABLE, NSC_PINNABLE},
545 	{"FORCED_WRTHRU", NSC_FORCED_WRTHRU, NSC_FORCED_WRTHRU},
546 	{"METADATA", NSC_METADATA, NSC_METADATA},
547 	{"MIXED", NSC_MIXED, NSC_MIXED},
548 	{NULL, 0, 0}
549 };
550 
551 
552 /*
553  * HELP functions for cache ctl type dcmds
554  */
555 
556 static void
557 cctl_help_common(char *name)
558 {
559 	mdb_inc_indent(4);
560 	mdb_printf("-c cd displays cctls for cache descriptor 'cd'\n");
561 	mdb_dec_indent(4);
562 	mdb_printf("inclusive filters:\n");
563 	mdb_inc_indent(4);
564 	mdb_printf("-b blk displays cctls for cache block number 'blk'\n");
565 	mdb_printf("-d displays cctls with dirty bits\n");
566 	mdb_printf("-h displays cctls that are hashed\n");
567 	mdb_printf("-i displays cctls that are inuse\n");
568 	mdb_printf("-o displays cctls that have I/O in progress\n");
569 	mdb_printf("-p displays cctls that have pagio set\n");
570 	mdb_printf("-B displays cctls that are marked BAD\n");
571 	mdb_printf("-H displays cctls that are HOSTS\n");
572 	mdb_printf("-P displays cctls that are PARASITES\n");
573 	mdb_printf("-R displays cctls that are explicit (NSC_RDAHEAD) "
574 			"Prefetch bufs\n");
575 	mdb_printf("-r displays cctls that are implicit Prefetch bufs\n");
576 	mdb_printf("-V displays cctls that have valid bits set\n");
577 	mdb_printf("-v verbose\n");
578 	mdb_dec_indent(4);
579 
580 	mdb_printf("Default: %s displays all cctls in the list\n", name);
581 	mdb_printf("\n");
582 
583 	mdb_printf("Example:\n");
584 	mdb_inc_indent(4);
585 
586 	mdb_printf("%s -io -c 5 displays all cctls for cd 5 that are\n"
587 			"in use or have I/O in progress\n", name);
588 	mdb_dec_indent(4);
589 }
590 
591 #define	CCTL_OPTIONSTRING "[-vdhiopBHPV][-c cd][-b blknum]"
592 void
593 cctl_help()
594 {
595 	mdb_printf("sdbc_cctl displays cache ctl structures\n");
596 	mdb_printf("Usage: [address]::sdbc_cctl " CCTL_OPTIONSTRING "\n");
597 	cctl_help_common("sdbc_cctl");
598 }
599 
600 void
601 cchain_help()
602 {
603 	mdb_printf("sdbc_cchain displays cache ctl structures in a"
604 			" (alloc) cc_chain\n");
605 	mdb_printf("Usage: address::sdbc_cchain " CCTL_OPTIONSTRING "\n");
606 	cctl_help_common("sdbc_cchain");
607 }
608 
609 void
610 dchain_help()
611 {
612 	mdb_printf("sdbc_dchain displays cache ctl structures in a"
613 			" dirty chain\n");
614 	mdb_printf("Usage: address::sdbc_dchain " CCTL_OPTIONSTRING "\n");
615 	cctl_help_common("sdbc_dchain");
616 }
617 
618 void
619 dmchain_help()
620 {
621 	mdb_printf("sdbc_dmchain displays cache ctl structures in a"
622 			" dynamic memory allocation chain\n");
623 	mdb_printf("order of display is:\n"
624 		    "the cctl represented by the given address,\n"
625 		    "the cc_head_dm cctl,\n"
626 		    "the chain starting at cc_next_dm of the head cctl\n");
627 	mdb_printf("Usage: address::sdbc_dmchain " CCTL_OPTIONSTRING "\n");
628 	cctl_help_common("sdbc_dmchain");
629 }
630 
631 void
632 hashchain_help()
633 {
634 	mdb_printf("sdbc_hashchain displays cache ctl structures in a"
635 			" hash chain\n");
636 	mdb_printf("Usage: address::sdbc_hashchain " CCTL_OPTIONSTRING "\n");
637 	cctl_help_common("sdbc_hashchain");
638 }
639 
640 void
641 hashtable_help()
642 {
643 	mdb_printf("sdbc_hashtable displays the hash table and its chains\n");
644 	mdb_printf("Usage: address::sdbc_hashtable " CCTL_OPTIONSTRING "\n");
645 	cctl_help_common("sdbc_hashtable");
646 }
647 
648 
649 void
650 lru_help()
651 {
652 	mdb_printf("sdbc_lru displays cache ctl structures in the LRU queue\n");
653 	mdb_printf("Usage: [address]::sdbc_lru " CCTL_OPTIONSTRING "\n");
654 	cctl_help_common("sdbc_lru");
655 }
656 
657 /*
658  * help functions for write ctl dcmds
659  */
660 void
661 wctl_help_common(char *name)
662 {
663 	mdb_inc_indent(4);
664 	mdb_printf("-v verbose\n");
665 	mdb_printf("-c cd show ctl structs for cache descriptor 'cd'\n");
666 	mdb_printf("-d show ctl structs that have dirty bits set\n");
667 	mdb_dec_indent(4);
668 	mdb_printf("Default: %s displays all write ctl in the list\n", name);
669 }
670 
671 void
672 wctl_help()
673 {
674 	mdb_printf(
675 	    "sdbc_wctl displays the allocated array of write ctl structures\n");
676 	mdb_printf("Usage: [address]::sdbc_wctl [-vd][-c cd]\n");
677 	wctl_help_common("sdbc_wctl");
678 }
679 
680 void
681 wrq_help()
682 {
683 	mdb_printf("sdbc_wrq displays the write ctl queue (wctl free list)\n");
684 	mdb_printf("Usage: [address]::sdbc_wrq [-vd][-c cd]\n");
685 	wctl_help_common("sdbc_wrq");
686 }
687 
688 /* help function for the sdbc_cdinfo dcmd */
689 void
690 cdinfo_help()
691 {
692 	mdb_printf(
693 	"sdbc_cdinfo displays cd information from the _sd_cache_files table\n");
694 	mdb_printf("Usage: [address]::sdbc_cdfinfo [-av][-c cd]\n");
695 	mdb_inc_indent(4);
696 	mdb_printf("-a displays info for all cd_info structures\n");
697 	mdb_printf("-c cd displays info for cache descriptor 'cd'\n");
698 	mdb_printf("-v verbose\n");
699 	mdb_dec_indent(4);
700 	mdb_printf("Default: display info for cd's that are allocated\n");
701 }
702 
703 void
704 ftctl_help()
705 {
706 	mdb_printf(
707 	    "sdbc_ftctl displays the array of fault tolerant structures \n");
708 	mdb_printf("Usage: [address]::sdbc_ftctl [-vd][-c cd]\n");
709 	wctl_help_common("sdbc_ftctl");
710 }
711 
712 /*
713  * help function for the sdbc_handles dcmd
714  */
715 void
716 handle_help()
717 {
718 	mdb_printf("sdbc_handles displays active or allocated"
719 			" cache buffer handles\n");
720 	mdb_printf("Usage: [address]::sdbc_handles [-avC][-c cd]\n");
721 	mdb_inc_indent(4);
722 	mdb_printf("-a displays all handles\n");
723 	mdb_printf("-c n displays handle for cd n\n");
724 	mdb_printf("-v displays detailed handle data\n");
725 	mdb_printf("-C displays the handle cc_chain\n");
726 	mdb_dec_indent(4);
727 	mdb_printf("Default: display only allocated or active handles\n");
728 }
729 
730 /*
731  * help functions for the "global" memory dcmds
732  */
733 void
734 glcinfo_help()
735 {
736 	mdb_printf("sdbc_glcinfo displays the global cache entry info\n");
737 	mdb_printf("Usage: [address]::sdbc_glcinfo [-adC][-c cd][-b fbapos]\n");
738 	mdb_inc_indent(4);
739 	mdb_printf("-a displays all global info structs\n");
740 	mdb_printf("-b fbapos displays structs that match FBA block"
741 			"(not cache block) 'fbapos'\n");
742 	mdb_printf("-c cd displays structs that match cache descriptor 'cd'\n");
743 	mdb_printf("-d displays structs with dirty bits set\n");
744 	mdb_printf("-C does consistency check against nvram copy\n");
745 	mdb_dec_indent(4);
746 	mdb_printf("Default: display entries with a valid cd\n");
747 }
748 
749 void
750 glfinfo_help()
751 {
752 	mdb_printf("sdbc_glfinfo displays the global file info\n");
753 	mdb_printf("Usage: [address]::sdbc_glfinfo [-aptC]\n");
754 	mdb_inc_indent(4);
755 	mdb_printf("-a displays all global info structs\n");
756 	mdb_printf("-p displays structs for pinned volumes\n");
757 	mdb_printf("-t displays structs for attached volumes\n");
758 	mdb_printf("-C does consistency check against nvram copy\n");
759 	mdb_dec_indent(4);
760 	mdb_printf("Default: display entries with non-null filename\n");
761 }
762 
763 
764 /*
765  * WALKERS
766  */
767 
768 /*
769  * walker for the cctl list using the cc_link_list_dm pointers
770  */
771 static int
772 sdbc_cctl_winit(mdb_walk_state_t *wsp)
773 {
774 	_sd_cctl_t *_sd_cctl[_SD_CCTL_GROUPS]; /* for getting first entry */
775 	struct walk_info *winfo;
776 
777 	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);
778 
779 	if (wsp->walk_addr == NULL) {
780 		/*
781 		 * we get the "first" cctl from memory and then traverse
782 		 * the cc_link_list_dm pointers.
783 		 * this traversal could start from any cctl.  here we start with
784 		 * the first cctl in the _sd_cctl[] array.
785 		 */
786 		if (mdb_readvar(_sd_cctl, "_sd_cctl") == -1) {
787 			mdb_warn("failed to read _sd_cctl array");
788 			return (DCMD_ERR);
789 		}
790 
791 		wsp->walk_addr = (uintptr_t)_sd_cctl[0];
792 	}
793 
794 	winfo->w_start = 0;
795 	winfo->w_end = wsp->walk_addr;
796 	wsp->walk_data = winfo;
797 
798 	return (WALK_NEXT);
799 }
800 
801 static int
802 sdbc_cctl_wstep(mdb_walk_state_t *wsp)
803 {
804 	struct walk_info *winfo = wsp->walk_data;
805 	_sd_cctl_t centry;
806 	int status;
807 
808 	if (wsp->walk_addr == NULL) /* should not happen */
809 		return (WALK_DONE);
810 
811 	/*
812 	 * w_start is 0 on the first iteration so the test
813 	 * will fail, allowing the first centry to be processed
814 	 */
815 	if (wsp->walk_addr == winfo->w_start)
816 		return (WALK_DONE);
817 
818 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
819 		wsp->walk_cbdata);
820 
821 	if (mdb_vread(&centry, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) {
822 		mdb_warn("failed to read centry at %p", wsp->walk_addr);
823 		return (WALK_ERR);
824 	}
825 	wsp->walk_addr = (uintptr_t)(centry.cc_link_list_dm);
826 	/* set termination condition. only needs to be done once */
827 	winfo->w_start = winfo->w_end;
828 
829 	return (status);
830 }
831 
832 static void
833 sdbc_cctl_wfini(mdb_walk_state_t *wsp)
834 {
835 	mdb_free(wsp->walk_data, sizeof (struct walk_info));
836 }
837 
838 /*
839  * walk the cc_chain list of a _sd_cctl_t
840  * no global walks -- must be called with an address
841  */
842 static int
843 sdbc_cchain_winit(mdb_walk_state_t *wsp)
844 {
845 	if (wsp->walk_addr == NULL)
846 		return (WALK_ERR);
847 
848 	wsp->walk_data = mdb_zalloc(sizeof (_sd_cctl_t), UM_SLEEP);
849 
850 	return (WALK_NEXT);
851 }
852 
853 static int
854 sdbc_cchain_wstep(mdb_walk_state_t *wsp)
855 {
856 	int status;
857 
858 	if (wsp->walk_addr == NULL)
859 		return (WALK_DONE);
860 
861 	if (mdb_vread(wsp->walk_data, sizeof (_sd_cctl_t), wsp->walk_addr)
862 				== -1) {
863 		mdb_warn("sdbc_cchain_wstep failed to read centry at %p",
864 			wsp->walk_addr);
865 		return (WALK_ERR);
866 	}
867 
868 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
869 						wsp->walk_cbdata);
870 
871 	wsp->walk_addr = (uintptr_t)(((_sd_cctl_t *)
872 				(wsp->walk_data))->cc_chain);
873 	return (status);
874 }
875 
876 static void
877 sdbc_cchain_wfini(mdb_walk_state_t *wsp)
878 {
879 	mdb_free(wsp->walk_data, sizeof (_sd_cctl_t));
880 }
881 
882 
883 /*
884  * walk the dirty chain list of a _sd_cctl_t
885  * no global walks -- must be called with an address
886  */
887 static int
888 sdbc_dchain_winit(mdb_walk_state_t *wsp)
889 {
890 	if (wsp->walk_addr == NULL)
891 		return (WALK_ERR);
892 
893 	wsp->walk_data = mdb_zalloc(sizeof (_sd_cctl_t), UM_SLEEP);
894 
895 	/* walk data stores the first and subsequent cc_dirty_link */
896 	if (mdb_vread(wsp->walk_data, sizeof (_sd_cctl_t), wsp->walk_addr)
897 				== -1) {
898 		mdb_warn("sdbc_dchain_winit failed to read centry at %p",
899 			wsp->walk_addr);
900 		return (WALK_ERR);
901 	}
902 
903 	return (WALK_NEXT);
904 }
905 
906 static int
907 sdbc_dchain_wstep(mdb_walk_state_t *wsp)
908 {
909 	_sd_cctl_t centry;
910 	int status;
911 
912 	if (wsp->walk_addr == NULL)
913 		return (WALK_DONE);
914 
915 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
916 						wsp->walk_cbdata);
917 
918 
919 	if (mdb_vread(&centry, sizeof (_sd_cctl_t), wsp->walk_addr)
920 				== -1) {
921 		mdb_warn("sdbc_dchain_wstep failed to read centry at %p",
922 			wsp->walk_addr);
923 		return (WALK_ERR);
924 	}
925 
926 	wsp->walk_addr =
927 		(uintptr_t)(centry.cc_dirty_next);
928 
929 	/* end of dirty_next chain?  start on subsequent dirty_link */
930 	if (wsp->walk_addr == NULL) {
931 		wsp->walk_addr =
932 		(uintptr_t)(((_sd_cctl_t *)(wsp->walk_data))->cc_dirty_link);
933 
934 		/* update dirty link */
935 		/* walk data stores the first and subsequent cc_dirty_link */
936 		if (wsp->walk_addr) {
937 			if (mdb_vread(wsp->walk_data, sizeof (_sd_cctl_t),
938 					wsp->walk_addr) == -1) {
939 
940 				mdb_warn(
941 				"sdbc_dchain_wstep failed to read centry at %p",
942 					wsp->walk_addr);
943 
944 				return (WALK_ERR);
945 			}
946 		}
947 	}
948 
949 	return (status);
950 }
951 
952 static void
953 sdbc_dchain_wfini(mdb_walk_state_t *wsp)
954 {
955 	mdb_free(wsp->walk_data, sizeof (_sd_cctl_t));
956 }
957 
958 /* for stepping thru the dynmem chain */
959 #define	GET_HEAD_DM 0x1
960 #define	GET_NEXT_DM 0x2
961 
962 /*
963  * walk the dm chain of a cctl
964  * start with current address, then cc_head_dm, then the cc_next_dm chain
965  */
966 static int
967 sdbc_dmchain_winit(mdb_walk_state_t *wsp)
968 {
969 	if (wsp->walk_addr == NULL)
970 		return (WALK_ERR);
971 
972 	wsp->walk_data = (void *)GET_HEAD_DM;
973 
974 	return (WALK_NEXT);
975 }
976 
977 static int
978 sdbc_dmchain_wstep(mdb_walk_state_t *wsp)
979 {
980 	_sd_cctl_t centry;
981 	int status;
982 
983 	if (wsp->walk_addr == NULL)
984 		return (WALK_DONE);
985 
986 	if (mdb_vread(&centry, sizeof (_sd_cctl_t), wsp->walk_addr)
987 				== -1) {
988 		mdb_warn("sdbc_dmchain_wstep failed to read centry at %p",
989 			wsp->walk_addr);
990 		return (WALK_ERR);
991 	}
992 
993 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
994 						wsp->walk_cbdata);
995 
996 	if (wsp->walk_data == (void *)GET_HEAD_DM) {
997 		wsp->walk_addr = (uintptr_t)centry.cc_head_dm;
998 		wsp->walk_data = (void *)GET_NEXT_DM;
999 	} else
1000 		wsp->walk_addr = (uintptr_t)centry.cc_next_dm;
1001 
1002 	return (status);
1003 }
1004 
1005 /*ARGSUSED*/
1006 static void
1007 sdbc_dmchain_wfini(mdb_walk_state_t *wsp)
1008 {
1009 }
1010 
1011 /*
1012  * walk a hash chain
1013  * requires an address
1014  */
1015 /*ARGSUSED*/
1016 static int
1017 sdbc_hashchain_winit(mdb_walk_state_t *wsp)
1018 {
1019 
1020 	if (wsp->walk_addr == NULL)
1021 		return (WALK_ERR);
1022 
1023 
1024 	return (WALK_NEXT);
1025 }
1026 
1027 static int
1028 sdbc_hashchain_wstep(mdb_walk_state_t *wsp)
1029 {
1030 	int status;
1031 	_sd_hash_hd_t hash_entry;
1032 
1033 
1034 	if (wsp->walk_addr == NULL)
1035 		return (WALK_DONE);
1036 
1037 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1038 						wsp->walk_cbdata);
1039 
1040 	if (mdb_vread(&hash_entry, sizeof (_sd_hash_hd_t),
1041 					wsp->walk_addr) == -1) {
1042 		mdb_warn(
1043 			"sdbc_hashchain_wstep failed to read hash_entry at %p",
1044 			wsp->walk_addr);
1045 		return (WALK_ERR); /* will upper layer continue ? */
1046 	}
1047 
1048 	wsp->walk_addr = (uintptr_t)hash_entry.hh_next;
1049 
1050 	return (status);
1051 }
1052 
1053 /*ARGSUSED*/
1054 static void
1055 sdbc_hashchain_wfini(mdb_walk_state_t *wsp)
1056 {
1057 }
1058 
1059 /*
1060  * walk the sdbc lru list
1061  */
1062 static int
1063 sdbc_lru_winit(mdb_walk_state_t *wsp)
1064 {
1065 	struct walk_info *winfo;
1066 	GElf_Sym sym;
1067 
1068 	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);
1069 
1070 	/* if called without an address, start at the head of the queue */
1071 	if (wsp->walk_addr == NULL) {
1072 
1073 		if (mdb_lookup_by_obj("sdbc", "_sd_lru_q", &sym) == -1) {
1074 			mdb_warn("failed to lookup _sd_lru_q symbol");
1075 			return (WALK_ERR);
1076 		}
1077 
1078 		/* &(_sd_lru_q.sq_qhead) */
1079 		wsp->walk_addr = (uintptr_t)(sym.st_value);
1080 	}
1081 
1082 	winfo->w_start = 0;
1083 	winfo->w_end = wsp->walk_addr;
1084 	wsp->walk_data = winfo;
1085 
1086 	return (WALK_NEXT);
1087 }
1088 
1089 static int
1090 sdbc_lru_wstep(mdb_walk_state_t *wsp)
1091 {
1092 	struct walk_info *winfo = wsp->walk_data;
1093 	_sd_cctl_t centry;
1094 	int status;
1095 
1096 	if (wsp->walk_addr == NULL) /* should not happen */
1097 		return (WALK_DONE);
1098 
1099 	/*
1100 	 * w_start is 0 on the first iteration so the test
1101 	 * will fail, allowing the first centry to be processed
1102 	 */
1103 	if (wsp->walk_addr == winfo->w_start)
1104 		return (WALK_DONE);
1105 
1106 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1107 						wsp->walk_cbdata);
1108 
1109 	if (mdb_vread(&centry, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) {
1110 		mdb_warn("failed to read centry at %p", wsp->walk_addr);
1111 		return (WALK_ERR);
1112 	}
1113 	wsp->walk_addr = (uintptr_t)(centry.cc_next);
1114 
1115 	/* set termination condition. only needs to be done once */
1116 	winfo->w_start = winfo->w_end;
1117 
1118 	return (status);
1119 }
1120 
1121 static void
1122 sdbc_lru_wfini(mdb_walk_state_t *wsp)
1123 {
1124 	mdb_free(wsp->walk_data, sizeof (struct walk_info));
1125 }
1126 
1127 
1128 #ifdef SAFESTORE
1129 /*
1130  * walk the array of allocated write control structures
1131  */
1132 
1133 static int
1134 sdbc_wctl_winit(mdb_walk_state_t *wsp)
1135 {
1136 	_sd_net_t  _sd_net_config;
1137 	_sd_writeq_t wrq;
1138 	struct walk_info *winfo;
1139 	int blk_shft;
1140 	int count;
1141 
1142 
1143 	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);
1144 
1145 	/* need to calculate the end of the array */
1146 	if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) {
1147 		mdb_warn("failed to read _sd_net_config structure");
1148 		return (WALK_ERR);
1149 	}
1150 
1151 	if (wsp->walk_addr == NULL)
1152 		wsp->walk_addr = (uintptr_t)(_sd_net_config.sn_wr_cctl);
1153 
1154 	/*
1155 	 * this module assumes 8k block size so this code can
1156 	 * be commented out if necessary.
1157 	 */
1158 	if (mdb_readvar(&blk_shft, "_sd_cblock_shift") == -1) {
1159 		mdb_warn("failed to read _sd_cblock_shift."
1160 			"assuming 8k cache block size");
1161 		blk_shft = 13;
1162 	}
1163 
1164 	count = (_sd_net_config.sn_wpages * _sd_net_config.sn_psize) /
1165 						    (1 << blk_shft);
1166 
1167 	winfo->w_end = (uintptr_t)(_sd_net_config.sn_wr_cctl + count);
1168 	wsp->walk_data = winfo;
1169 
1170 	return (WALK_NEXT);
1171 }
1172 
1173 static int
1174 sdbc_wctl_wstep(mdb_walk_state_t *wsp)
1175 {
1176 	struct walk_info *winfo = wsp->walk_data;
1177 	int status;
1178 
1179 	if (wsp->walk_addr == NULL)
1180 		return (WALK_DONE);
1181 
1182 	if (wsp->walk_addr >= winfo->w_end)
1183 		return (WALK_DONE);
1184 
1185 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1186 						wsp->walk_cbdata);
1187 
1188 	wsp->walk_addr += sizeof (_sd_wr_cctl_t);
1189 
1190 	return (status);
1191 
1192 }
1193 
1194 static void
1195 sdbc_wctl_wfini(mdb_walk_state_t *wsp)
1196 {
1197 	mdb_free(wsp->walk_data, sizeof (struct walk_info));
1198 }
1199 
1200 /*
1201  * walk the queue (free list) of write control structures
1202  */
1203 
1204 static int
1205 sdbc_wrq_winit(mdb_walk_state_t *wsp)
1206 {
1207 	_sd_net_t  _sd_net_config;
1208 	_sd_writeq_t wrq;
1209 
1210 	/* if called without an address, start at the head of the queue */
1211 	if (wsp->walk_addr == NULL) {
1212 
1213 		if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) {
1214 			mdb_warn("failed to read _sd_net_config structure");
1215 			return (WALK_ERR);
1216 		}
1217 
1218 		wsp->walk_addr = (uintptr_t)
1219 					(_sd_net_config.sn_wr_queue.wq_qtop);
1220 	}
1221 
1222 	return (WALK_NEXT);
1223 }
1224 
1225 static int
1226 sdbc_wrq_wstep(mdb_walk_state_t *wsp)
1227 {
1228 	_sd_wr_cctl_t wctl;
1229 	int status;
1230 
1231 	if (wsp->walk_addr == NULL)
1232 		return (WALK_DONE);
1233 
1234 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1235 						wsp->walk_cbdata);
1236 
1237 	if (mdb_vread(&wctl, sizeof (_sd_wr_cctl_t), wsp->walk_addr)
1238 				== -1) {
1239 		mdb_warn("sdbc_cchain_wstep failed to read wctl at %p",
1240 			wsp->walk_addr);
1241 		return (WALK_ERR);
1242 	}
1243 
1244 	/* special case -- mini-DSP fake wr_cctl */
1245 	if (wsp->walk_addr == (uintptr_t)wctl.wc_next)
1246 		return (WALK_DONE);
1247 
1248 	wsp->walk_addr = (uintptr_t)(wctl.wc_next);
1249 
1250 	return (WALK_NEXT);
1251 }
1252 
1253 static void
1254 sdbc_wrq_wfini(mdb_walk_state_t *wsp)
1255 {
1256 }
1257 #endif /* SAFESTORE */
1258 /*
1259  * walk the _sd_cache_files array of cd_info structures
1260  */
1261 static int
1262 sdbc_cdinfo_winit(mdb_walk_state_t *wsp)
1263 {
1264 	struct walk_info *winfo;
1265 	_sd_cd_info_t	*_sd_cache_files_addr;
1266 	int maxdevs;
1267 
1268 	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);
1269 
1270 
1271 	/* get the address of the cdinfo table */
1272 	if (mdb_readvar(&_sd_cache_files_addr, "_sd_cache_files") == -1) {
1273 		mdb_warn("failed to read _sd_cache_files address\n");
1274 		return (WALK_ERR);
1275 	}
1276 
1277 	/* if called without an address, start at the head of the queue */
1278 	if (wsp->walk_addr == NULL) {
1279 		/* address of first _sd_cd_info_t */
1280 		wsp->walk_addr = (uintptr_t)(_sd_cache_files_addr);
1281 	}
1282 
1283 	/* get the number of volumes */
1284 	if (mdb_readvar(&maxdevs, "sdbc_max_devs") == -1) {
1285 		mdb_warn("failed to read  sdbc_max_devs");
1286 		return (WALK_ERR);
1287 	}
1288 
1289 	winfo->w_end = (uintptr_t)(_sd_cache_files_addr + maxdevs);
1290 	wsp->walk_data = winfo;
1291 
1292 	return (WALK_NEXT);
1293 }
1294 
1295 static int
1296 sdbc_cdinfo_wstep(mdb_walk_state_t *wsp)
1297 {
1298 	struct walk_info *winfo = wsp->walk_data;
1299 	int status;
1300 
1301 	if (wsp->walk_addr >= winfo->w_end)
1302 		return (WALK_DONE);
1303 
1304 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1305 						wsp->walk_cbdata);
1306 
1307 	wsp->walk_addr += sizeof (_sd_cd_info_t);
1308 
1309 	return (status);
1310 }
1311 
1312 static void
1313 sdbc_cdinfo_wfini(mdb_walk_state_t *wsp)
1314 {
1315 	mdb_free(wsp->walk_data, sizeof (struct walk_info));
1316 }
1317 
1318 #ifdef SAFESTORE
1319 /*
1320  * walk the array of allocated fault tolerant control structures
1321  */
1322 static int
1323 sdbc_ftctl_winit(mdb_walk_state_t *wsp)
1324 {
1325 	_sd_net_t  _sd_net_config;
1326 	struct walk_info *winfo;
1327 	int blk_shft = 13; /* 8k default */
1328 	int count;
1329 
1330 
1331 	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);
1332 
1333 	/* need to calculate the end of the array */
1334 	if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) {
1335 		mdb_warn("failed to read _sd_net_config structure");
1336 		return (WALK_ERR);
1337 	}
1338 
1339 	if (wsp->walk_addr == NULL)
1340 		wsp->walk_addr = (uintptr_t)(_sd_net_config.sn_ft_cctl);
1341 
1342 	/*
1343 	 * this module assumes 8k block size so this code can
1344 	 * be commented out if necessary.
1345 	 */
1346 	if (mdb_readvar(&blk_shft, "_sd_cblock_shift") == -1) {
1347 		mdb_warn("failed to read _sd_cblock_shift."
1348 			"assuming 8k cache block size");
1349 		blk_shft = 13;
1350 	}
1351 
1352 	count = (_sd_net_config.sn_wpages * _sd_net_config.sn_psize) /
1353 						    (1 << blk_shft);
1354 
1355 	winfo->w_end = (uintptr_t)(_sd_net_config.sn_ft_cctl + count);
1356 	wsp->walk_data = winfo;
1357 
1358 	return (WALK_NEXT);
1359 }
1360 
1361 static int
1362 sdbc_ftctl_wstep(mdb_walk_state_t *wsp)
1363 {
1364 	struct walk_info *winfo = wsp->walk_data;
1365 	int status;
1366 
1367 	if (wsp->walk_addr == NULL)
1368 		return (WALK_DONE);
1369 
1370 	if (wsp->walk_addr >= winfo->w_end)
1371 		return (WALK_DONE);
1372 
1373 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1374 						wsp->walk_cbdata);
1375 
1376 	wsp->walk_addr += sizeof (_sd_ft_cctl_t);
1377 
1378 	return (status);
1379 }
1380 
1381 static void
1382 sdbc_ftctl_wfini(mdb_walk_state_t *wsp)
1383 {
1384 	mdb_free(wsp->walk_data, sizeof (struct walk_info));
1385 }
1386 #endif /* SAFESTORE */
1387 
1388 /*
1389  * walk the handle list
1390  */
1391 static int
1392 sdbc_handle_winit(mdb_walk_state_t *wsp)
1393 {
1394 	_sd_buf_hlist_t hl;
1395 	struct walk_info *winfo;
1396 	GElf_Sym sym;
1397 
1398 	if (mdb_readvar(&hl, "_sd_handle_list") == -1) {
1399 		mdb_warn("failed to read _sd_handle_list structure");
1400 		return (WALK_ERR);
1401 	}
1402 
1403 	if (mdb_lookup_by_obj("sdbc", "_sd_handle_list", &sym) == -1) {
1404 		mdb_warn("failed to lookup _sd_handle_list symbol");
1405 		return (WALK_ERR);
1406 	}
1407 
1408 	/* if called without an address, start at first element in list */
1409 	if (wsp->walk_addr == NULL)
1410 		wsp->walk_addr = (uintptr_t)(hl.hl_top.bh_next);
1411 
1412 	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);
1413 
1414 	winfo->w_end = (uintptr_t)(sym.st_value); /* &_sd_handle_list.hl_top */
1415 	wsp->walk_data = winfo;
1416 
1417 	return (WALK_NEXT);
1418 }
1419 
1420 static int
1421 sdbc_handle_wstep(mdb_walk_state_t *wsp)
1422 {
1423 	struct walk_info *winfo = wsp->walk_data;
1424 	_sd_buf_handle_t handle;
1425 	int status;
1426 
1427 	if (wsp->walk_addr == NULL)
1428 		return (WALK_DONE);
1429 
1430 	if (wsp->walk_addr == winfo->w_end)
1431 		return (WALK_DONE);
1432 
1433 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1434 						wsp->walk_cbdata);
1435 
1436 	if (mdb_vread(&handle, sizeof (_sd_buf_handle_t), wsp->walk_addr)
1437 								== -1) {
1438 		mdb_warn("failed to read handle at %p", wsp->walk_addr);
1439 		return (WALK_ERR);
1440 	}
1441 
1442 	wsp->walk_addr = (uintptr_t)(handle.bh_next);
1443 
1444 	return (status);
1445 }
1446 
1447 static void
1448 sdbc_handle_wfini(mdb_walk_state_t *wsp)
1449 {
1450 	mdb_free(wsp->walk_data, sizeof (struct walk_info));
1451 }
1452 
1453 /*
1454  * walk the global info array (dirty bits)
1455  */
1456 
1457 static int
1458 sdbc_glcinfo_winit(mdb_walk_state_t *wsp)
1459 {
1460 	ss_centry_info_t *gl_centry_info;
1461 	size_t gl_centry_info_size;
1462 	struct walk_info *winfo;
1463 
1464 
1465 	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);
1466 
1467 	/* get start of the cache entry metadata */
1468 	if (mdb_readvar(&gl_centry_info, "_sdbc_gl_centry_info") == -1) {
1469 		mdb_warn("failed to read  _sdbc_gl_centry_info");
1470 		return (WALK_ERR);
1471 	}
1472 
1473 	/* need to calculate the end of the array */
1474 	if (mdb_readvar(&gl_centry_info_size,
1475 				"_sdbc_gl_centry_info_size") == -1) {
1476 		mdb_warn("failed to read  _sdbc_gl_centry_info_size");
1477 		return (WALK_ERR);
1478 	}
1479 
1480 	if (wsp->walk_addr == NULL)
1481 		wsp->walk_addr = (uintptr_t)(gl_centry_info);
1482 
1483 
1484 
1485 	winfo->w_end = ((uintptr_t)(gl_centry_info)) + gl_centry_info_size;
1486 	wsp->walk_data = winfo;
1487 
1488 	return (WALK_NEXT);
1489 }
1490 
1491 static int
1492 sdbc_glcinfo_wstep(mdb_walk_state_t *wsp)
1493 {
1494 	struct walk_info *winfo = wsp->walk_data;
1495 	int status;
1496 
1497 	if (wsp->walk_addr == NULL)
1498 		return (WALK_DONE);
1499 
1500 	if (wsp->walk_addr >= winfo->w_end)
1501 		return (WALK_DONE);
1502 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1503 						wsp->walk_cbdata);
1504 
1505 	wsp->walk_addr += sizeof (ss_centry_info_t);
1506 
1507 	return (status);
1508 }
1509 
1510 static void
1511 sdbc_glcinfo_wfini(mdb_walk_state_t *wsp)
1512 {
1513 	mdb_free(wsp->walk_data, sizeof (struct walk_info));
1514 }
1515 
1516 /*
1517  * walk the global file info array
1518  */
1519 static int
1520 sdbc_glfinfo_winit(mdb_walk_state_t *wsp)
1521 {
1522 	ss_voldata_t *gl_file_info;
1523 	struct walk_info *winfo;
1524 	int maxdevs;
1525 
1526 
1527 	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);
1528 
1529 	/* get start of the cache entry metadata */
1530 	if (mdb_readvar(&gl_file_info, "_sdbc_gl_file_info") == -1) {
1531 		mdb_warn("failed to read  _sdbc_gl_file_info");
1532 		return (WALK_ERR);
1533 	}
1534 
1535 
1536 	if (wsp->walk_addr == NULL)
1537 		wsp->walk_addr = (uintptr_t)(gl_file_info);
1538 
1539 	/* get the number of volumes */
1540 	if (mdb_readvar(&maxdevs, "sdbc_max_devs") == -1) {
1541 		mdb_warn("failed to read  sdbc_max_devs");
1542 		return (WALK_ERR);
1543 	}
1544 
1545 	/* end of the array */
1546 	winfo->w_end = (uintptr_t)((gl_file_info) + maxdevs);
1547 
1548 	wsp->walk_data = winfo;
1549 
1550 	return (WALK_NEXT);
1551 }
1552 
1553 static int
1554 sdbc_glfinfo_wstep(mdb_walk_state_t *wsp)
1555 {
1556 	struct walk_info *winfo = wsp->walk_data;
1557 	int status;
1558 
1559 	if (wsp->walk_addr == NULL)
1560 		return (WALK_DONE);
1561 
1562 	if (wsp->walk_addr >= winfo->w_end)
1563 		return (WALK_DONE);
1564 
1565 	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
1566 						wsp->walk_cbdata);
1567 
1568 	wsp->walk_addr += sizeof (ss_voldata_t);
1569 
1570 	return (status);
1571 
1572 }
1573 
1574 static void
1575 sdbc_glfinfo_wfini(mdb_walk_state_t *wsp)
1576 {
1577 	mdb_free(wsp->walk_data, sizeof (struct walk_info));
1578 }
1579 
1580 /* end of WALKERS section */
1581 
1582 
1583 const mdb_bitmask_t cc_flag_bits[] = {
1584 	{"PEND_DIRTY", CC_PEND_DIRTY, CC_PEND_DIRTY},
1585 	{"PINNED", CC_PINNED, CC_PINNED},
1586 	{"PINNABLE", CC_PINNABLE, CC_PINNABLE},
1587 	{"QHEAD", CC_QHEAD, CC_QHEAD},
1588 	{NULL, 0, 0}
1589 };
1590 
1591 const mdb_bitmask_t io_status_bits[] = {
1592 	{"IO_NONE", 0xff, _SD_IO_NONE},
1593 	{"IO_INITIATE", 0xff, _SD_IO_INITIATE},
1594 	{"IO_DONE", 0xff, _SD_IO_DONE},
1595 	{"IO_FAILED", 0xff, _SD_IO_FAILED},
1596 	{"IO_DISCARDED", 0xff, _SD_IO_DISCARDED},
1597 	{NULL, 0, 0}
1598 };
1599 
1600 const mdb_bitmask_t cc_aging_bits[] = {
1601 	{"FOUND_IN_HASH", FOUND_IN_HASH_DM, FOUND_IN_HASH_DM},
1602 	{"FOUND_HOLD_OVER", FOUND_HOLD_OVER_DM, FOUND_HOLD_OVER_DM},
1603 	{"HOST_ENTRY", HOST_ENTRY_DM, HOST_ENTRY_DM},
1604 	{"PARASITIC_ENTRY", PARASITIC_ENTRY_DM, PARASITIC_ENTRY_DM},
1605 	{"STICKY_METADATA", STICKY_METADATA_DM, STICKY_METADATA_DM},
1606 	{"ELIGIBLE_ENTRY", ELIGIBLE_ENTRY_DM, ELIGIBLE_ENTRY_DM},
1607 	{"HASH_ENTRY", HASH_ENTRY_DM, HASH_ENTRY_DM},
1608 	{"HOLD_ENTRY", HOLD_ENTRY_DM, HOLD_ENTRY_DM},
1609 	{"AVAIL_ENTRY", AVAIL_ENTRY_DM, AVAIL_ENTRY_DM},
1610 	{"BAD_CHAIN", BAD_CHAIN_DM, BAD_CHAIN_DM},
1611 	{"BAD_ENTRY", BAD_ENTRY_DM, BAD_ENTRY_DM},
1612 	{"PREFETCH_I", PREFETCH_BUF_I, PREFETCH_BUF_I},
1613 	{"PREFETCH_E", PREFETCH_BUF_E, PREFETCH_BUF_E},
1614 	{NULL, 0, 0}
1615 };
1616 
1617 
1618 /* DCMDS that use walkers */
1619 
1620 /*
1621  * dcmd to display cache entry control structures
1622  */
1623 static int
1624 sdbc_cctl(uintptr_t addr, uint_t flags, int argc,
1625 					const mdb_arg_t *argv)
1626 {
1627 	uint_t opt_a = FALSE;
1628 	uintptr_t opt_c = MDB_CD;    /* cd */
1629 	uintptr_t opt_b = MDB_BLKNUM;    /* block num */
1630 	uint_t opt_B = FALSE;    /* BAD CHAIN or ENTRY */
1631 	uint_t opt_d = FALSE;    /* dirty */
1632 	uint_t opt_H = FALSE;    /* HOST */
1633 	uint_t opt_h = FALSE;    /* hashed */
1634 	uint_t opt_i = FALSE;    /* inuse */
1635 	uint_t opt_p = FALSE;    /* pageio */
1636 	uint_t opt_P = FALSE;    /* PARASITE */
1637 	uint_t opt_R = FALSE;    /* explicit read-ahead (prefetch) */
1638 	uint_t opt_r = FALSE;    /* implicit read-ahead (prefetch) */
1639 	uint_t opt_o = FALSE;    /* io in progress */
1640 	uint_t opt_m = FALSE;	 /* has memory allocated */
1641 	uint_t opt_V = FALSE;    /* valid bits */
1642 	uint_t opt_v = FALSE;    /* verbose */
1643 	uint_t nofilter = FALSE; /* true if b, d, h, i, o, p, V are all false */
1644 	_sd_cctl_t centry;
1645 	_sd_cctl_sync_t cc_sync;
1646 
1647 	/*
1648 	 * possible enhancements -- option to filter on flag bits
1649 	 * option that toggles other options.
1650 	 */
1651 	if (mdb_getopts(argc, argv,
1652 			'a', MDB_OPT_SETBITS, TRUE, &opt_a,
1653 			'B', MDB_OPT_SETBITS, TRUE, &opt_B,
1654 			'b', MDB_OPT_UINTPTR, &opt_b,
1655 			'c', MDB_OPT_UINTPTR, &opt_c,
1656 			'd', MDB_OPT_SETBITS, TRUE, &opt_d,
1657 			'H', MDB_OPT_SETBITS, TRUE, &opt_H,
1658 			'h', MDB_OPT_SETBITS, TRUE, &opt_h,
1659 			'i', MDB_OPT_SETBITS, TRUE, &opt_i,
1660 			'o', MDB_OPT_SETBITS, TRUE, &opt_o,
1661 			'm', MDB_OPT_SETBITS, TRUE, &opt_m,
1662 			'P', MDB_OPT_SETBITS, TRUE, &opt_P,
1663 			'p', MDB_OPT_SETBITS, TRUE, &opt_p,
1664 			'R', MDB_OPT_SETBITS, TRUE, &opt_R,
1665 			'r', MDB_OPT_SETBITS, TRUE, &opt_r,
1666 			'V', MDB_OPT_SETBITS, TRUE, &opt_V,
1667 			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
1668 		return (DCMD_USAGE);
1669 
1670 
1671 	nofilter = (!OPT_B_SELECTED && !opt_d && !opt_h && !opt_i &&
1672 			!opt_o && !opt_m && !opt_p && !opt_V && !opt_B &&
1673 			!opt_P && !opt_H && !opt_R && !opt_r); /* no options */
1674 
1675 	if (!(flags & DCMD_ADDRSPEC)) {
1676 		if (mdb_walk_dcmd("sdbc`sdbc_cctl", "sdbc`sdbc_cctl",
1677 					argc, argv) == -1) {
1678 			mdb_warn("failed to walk 'cctl' list");
1679 			return (DCMD_ERR);
1680 		}
1681 		return (DCMD_OK);
1682 	}
1683 
1684 	if (DCMD_HDRSPEC(flags)) {
1685 		mdb_printf("sdbc cache ctl structures:\n");
1686 	}
1687 
1688 
1689 	if (mdb_vread(&centry, sizeof (_sd_cctl_t), addr) == -1) {
1690 		mdb_warn("dcmd failed to read centry at %p", addr);
1691 		return (DCMD_ERR);
1692 	}
1693 
1694 	/* filter exclusively on a cd number if specified */
1695 	if (OPT_C_SELECTED && (centry.cc_head.hh_cd != opt_c))
1696 		return (DCMD_OK);
1697 
1698 	/* all other filters are inclusive */
1699 	if ((nofilter) ||
1700 		(OPT_B_SELECTED && (centry.cc_head.hh_blk_num == opt_b)) ||
1701 		(opt_B && (centry.cc_aging_dm &
1702 			(BAD_ENTRY_DM | BAD_CHAIN_DM))) ||
1703 		(opt_d && (centry.cc_dirty)) ||
1704 		(opt_H && (centry.cc_aging_dm & HOST_ENTRY_DM)) ||
1705 		(opt_h && (centry.cc_head.hh_hashed)) ||
1706 		(opt_i && (centry.cc_inuse)) ||
1707 		(opt_p && (centry.cc_pageio)) ||
1708 		(opt_P && (centry.cc_aging_dm & PARASITIC_ENTRY_DM)) ||
1709 		(opt_R && (centry.cc_aging_dm & PREFETCH_BUF_E)) ||
1710 		(opt_r && (centry.cc_aging_dm & PREFETCH_BUF_I)) ||
1711 		(opt_V && (centry.cc_valid)) ||
1712 		(opt_m && (centry.cc_alloc_size_dm)) ||
1713 		(opt_o && (centry.cc_iostatus != _SD_IO_NONE)))
1714 		/*EMPTY*/;
1715 	else
1716 		return (DCMD_OK);
1717 
1718 	mdb_inc_indent(4);
1719 	mdb_printf(
1720 	"%-?p cd %3-d blk_num %10-d valid %04hx dirty %04hx flag %02x\n",
1721 			addr, centry.cc_head.hh_cd,
1722 			centry.cc_head.hh_blk_num, centry.cc_valid,
1723 			centry.cc_dirty, centry.cc_flag);
1724 	mdb_dec_indent(4);
1725 
1726 	if (!opt_v)
1727 		return (DCMD_OK);
1728 
1729 	/* verbose */
1730 	mdb_inc_indent(4);
1731 	mdb_printf(
1732 	"hashed %d seq %4-d toflush %04hx %8Tawait_use %4-d await_page %4-d\n",
1733 		centry.cc_head.hh_hashed, centry.cc_seq,
1734 		centry.cc_toflush, centry.cc_await_use,
1735 		centry.cc_await_page);
1736 
1737 	mdb_printf("inuse %d pageio %d cc_flag <%b>\n",
1738 		centry.cc_inuse, centry.cc_pageio,
1739 		centry.cc_flag, cc_flag_bits);
1740 
1741 	mdb_printf("iocount %2d iostatus <%b>\n",
1742 		    centry.cc_iocount, centry.cc_iostatus, io_status_bits);
1743 
1744 	if (mdb_vread(&cc_sync, sizeof (struct _sd_cctl_sync),
1745 					(uintptr_t)centry.cc_sync)
1746 		== -1)
1747 		mdb_warn("failed to read cc_sync"); /* not catastophic */
1748 
1749 	else
1750 		mdb_printf("cc_sync blkcv: %h-x %8Tlock: 0x%p (owner)\n",
1751 				cc_sync._cc_blkcv._opaque,
1752 				cc_sync._cc_lock._opaque[0]);
1753 
1754 	mdb_printf("dynamic memory allocation:\n");
1755 	mdb_inc_indent(4);
1756 	mdb_printf("aging_dm age %3d %4Tage flags: <%b> 0x%x\n",
1757 			centry.cc_aging_dm & 0xff,
1758 			centry.cc_aging_dm, cc_aging_bits, centry.cc_aging_dm);
1759 
1760 	mdb_printf("alloc_size_dm %10-d head_dm %?-p\n",
1761 		centry.cc_alloc_size_dm, centry.cc_head_dm);
1762 	mdb_printf("next_dm %?-p link_list_dm %?-p\n",
1763 		centry.cc_next_dm, centry.cc_link_list_dm);
1764 
1765 	mdb_printf("alloc_ct_dm %10-d dealloc_ct_dm %10-d\n",
1766 		centry.cc_alloc_ct_dm, centry.cc_dealloc_ct_dm);
1767 
1768 	mdb_dec_indent(4);
1769 	/* pointers */
1770 	mdb_printf("cctl pointers:\n");
1771 	mdb_inc_indent(4);
1772 
1773 	mdb_printf("next %?-p prev %?-p chain %?-p\n",
1774 		centry.cc_next, centry.cc_prev, centry.cc_chain);
1775 	mdb_printf("dirty_next %?-p dirty_link %?-p\n",
1776 		centry.cc_dirty_next, centry.cc_dirty_link);
1777 	mdb_printf("data %?-p write ctl %?-p\n",
1778 		centry.cc_data, centry.cc_write);
1779 
1780 	mdb_dec_indent(4);
1781 
1782 	/* dynmem chain */
1783 	mdb_printf("cctl dmqueue index cc_blocks %4-d\n", centry.cc_cblocks);
1784 
1785 	mdb_printf("anon_addr %?-p anon_len %8-d\n",
1786 			centry.cc_anon_addr.sa_virt, centry.cc_anon_len);
1787 
1788 	/* stats */
1789 	mdb_printf("cctl stats:	");
1790 	mdb_inc_indent(4);
1791 	mdb_printf("hits %8-d creat time %?-p\n", centry.cc_hits,
1792 			centry.cc_creat);
1793 	mdb_dec_indent(4);
1794 
1795 	mdb_printf("\n");
1796 
1797 	mdb_dec_indent(4);
1798 
1799 	return (DCMD_OK);
1800 }
1801 
1802 
1803 /*
1804  * convenience dcmd to display the _sd_cctl cc_chain list (alloc list)
1805  * Must be called with an address of a cache entry (_sd_cctl_t)
1806  * same options as sdbc_cctl().
1807  * alternatively the user can call the sdbc_cchain walker
1808  * and pipe the addresses to sdbc_cctl dcmd.
1809  */
1810 static int
1811 sdbc_cchain(uintptr_t addr, uint_t flags, int argc,
1812 					const mdb_arg_t *argv)
1813 {
1814 
1815 	if (!(flags & DCMD_ADDRSPEC))
1816 		return (DCMD_USAGE);
1817 
1818 	if (mdb_pwalk_dcmd("sdbc`sdbc_cchain", "sdbc`sdbc_cctl",
1819 						argc, argv, addr)
1820 			== -1) {
1821 		mdb_warn("failed to walk cc_chain at addr %p", addr);
1822 		return (DCMD_ERR);
1823 	}
1824 
1825 	return (DCMD_OK);
1826 }
1827 
1828 
1829 /*
1830  * convenience dcmd to cdisplay the _sd_cctl dirty chain
1831  * (which is really a 2d chain).
1832  * Must be called with an address of a cache entry (_sd_cctl_t)
1833  * same options as sdbc_cctl().
1834  * alternatively the user can call the sdbc_dchain walker
1835  * and pipe the addresses to sdbc_cctl dcmd.
1836  */
1837 static int
1838 sdbc_dchain(uintptr_t addr, uint_t flags, int argc,
1839 					const mdb_arg_t *argv)
1840 {
1841 
1842 	if (!(flags & DCMD_ADDRSPEC))
1843 		return (DCMD_USAGE);
1844 
1845 	if (mdb_pwalk_dcmd("sdbc`sdbc_dchain", "sdbc`sdbc_cctl",
1846 						argc, argv, addr)
1847 			== -1) {
1848 		mdb_warn("failed to walk dirty chain at addr %p", addr);
1849 		return (DCMD_ERR);
1850 	}
1851 
1852 	return (DCMD_OK);
1853 }
1854 
1855 /*
1856  * convenience dcmd to display the _sd_cctl dm chain list
1857  * Must be called with an address of a cache entry (_sd_cctl_t)
1858  * same options as sdbc_cctl().
1859  * alternatively the user can call the sdbc_dmchain walker
1860  * and pipe the addresses to sdbc_cctl dcmd.
1861  */
1862 static int
1863 sdbc_dmchain(uintptr_t addr, uint_t flags, int argc,
1864 					const mdb_arg_t *argv)
1865 {
1866 
1867 	if (!(flags & DCMD_ADDRSPEC))
1868 		return (DCMD_USAGE);
1869 
1870 	if (mdb_pwalk_dcmd("sdbc`sdbc_dmchain", "sdbc`sdbc_cctl",
1871 						argc, argv, addr)
1872 			== -1) {
1873 		mdb_warn("failed to walk dm chain at addr %p", addr);
1874 		return (DCMD_ERR);
1875 	}
1876 
1877 	return (DCMD_OK);
1878 }
1879 
1880 /*
1881  * dcmd to walk a hash chain
1882  * requires an address. same options as sdbc_cctl dcmd
1883  */
1884 static int
1885 sdbc_hashchain(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1886 {
1887 	if (!(flags & DCMD_ADDRSPEC))
1888 		return (DCMD_USAGE);
1889 
1890 	if (mdb_pwalk_dcmd("sdbc`sdbc_hashchain", "sdbc`sdbc_cctl",
1891 					argc, argv, addr) == -1) {
1892 		mdb_warn("failed to walk hashchain at %p", addr);
1893 		return (DCMD_ERR);
1894 	}
1895 
1896 	return (DCMD_OK);
1897 }
1898 
1899 
1900 static void
1901 display_hash_table(_sd_hash_table_t *addr, _sd_hash_table_t *ht)
1902 {
1903 	mdb_printf("hash table (%p):\n", addr);
1904 	mdb_inc_indent(4);
1905 	mdb_printf("size %7-d bits %2-d mask %8-x nmask %8-x buckets %p\n",
1906 		ht->ht_size, ht->ht_bits, ht->ht_mask,
1907 		ht->ht_nmask, ht->ht_buckets);
1908 	mdb_dec_indent(4);
1909 }
1910 
1911 static void
1912 display_hash_bucket(_sd_hash_bucket_t *addr, _sd_hash_bucket_t *hb)
1913 {
1914 	kmutex_t lock;
1915 	int rc;
1916 
1917 	if ((rc = mdb_vread(&lock, sizeof (kmutex_t),
1918 				(uintptr_t)hb->hb_lock)) == -1)
1919 		mdb_warn("failed to read bucket lock at %p", hb->hb_lock);
1920 
1921 	mdb_printf("hash bucket (%p):\n", addr);
1922 	mdb_inc_indent(4);
1923 	mdb_printf("head %?-p tail %?-p lock %?-p %s\n",
1924 		hb->hb_head, hb->hb_tail,
1925 		(rc == -1) ? hb->hb_lock : lock._opaque[0],
1926 		(rc == -1) ? "" : "(owner)");
1927 	mdb_printf("inlist %d seq %d\n", hb->hb_inlist, hb->hb_seq);
1928 	mdb_dec_indent(4);
1929 }
1930 
1931 /*
1932  * dcmd to walk the hash table
1933  * defaults to _sd_htable the cache hash table,
1934  * but wil accept an address which is probably only useful
1935  * in the event that other hash tables are implemented in
1936  * the cache.
1937  *
1938  * calls sdbc_hashchain dcmd.  same options as sdbc_cctl dcmd.
1939  */
1940 static int
1941 sdbc_hashtable(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1942 {
1943 	_sd_hash_table_t *sd_htable_addr;
1944 	_sd_hash_table_t _sd_htable;
1945 	_sd_hash_bucket_t hash_bucket;
1946 	int i;
1947 
1948 
1949 
1950 	if (!(flags & DCMD_ADDRSPEC)) {
1951 		/* get the address of the standard cache hash table */
1952 		if (mdb_readvar(&sd_htable_addr, "_sd_htable") == -1) {
1953 			mdb_warn("failed to read _sd_htable address\n");
1954 			return (DCMD_ERR);
1955 		}
1956 	} else
1957 		sd_htable_addr = (_sd_hash_table_t *)addr;
1958 
1959 	/* read in the hash table structure */
1960 	if (mdb_vread(&_sd_htable, sizeof (_sd_hash_table_t),
1961 		(uintptr_t)sd_htable_addr) == -1) {
1962 		mdb_warn("failed to read _sd_htable structure at %p\n",
1963 						    sd_htable_addr);
1964 		return (DCMD_ERR);
1965 	}
1966 
1967 	display_hash_table(sd_htable_addr, &_sd_htable);
1968 
1969 	/*
1970 	 * read in the hash buckets
1971 	 * and display chains if there are any
1972 	 */
1973 	for (i = 0; i < _sd_htable.ht_size; ++i) {
1974 		if (mdb_vread(&hash_bucket, sizeof (_sd_hash_bucket_t),
1975 			    (uintptr_t)(_sd_htable.ht_buckets + i)) == -1) {
1976 			mdb_warn("failed to read ht_buckets at %p\n",
1977 					    _sd_htable.ht_buckets + i);
1978 			return (DCMD_ERR);
1979 		}
1980 
1981 		if (hash_bucket.hb_head != NULL) {
1982 			display_hash_bucket(_sd_htable.ht_buckets + i,
1983 							&hash_bucket);
1984 			/*
1985 			 * if this walk fails, continue trying
1986 			 * to read hash buckets
1987 			 */
1988 			if (mdb_call_dcmd("sdbc`sdbc_hashchain",
1989 					(uintptr_t)hash_bucket.hb_head,
1990 					flags|DCMD_ADDRSPEC, argc, argv)
1991 								    == -1)
1992 				    mdb_warn(
1993 					    "failed to walk hash chain at %p",
1994 					hash_bucket.hb_head);
1995 			    mdb_printf("\n");
1996 		    }
1997 	}
1998 
1999 	return (DCMD_OK);
2000 }
2001 /*
2002  * dcmd to display the sdbc lru queue
2003  * same options as sdbc_cctl().
2004  * alternatively the user can call the sdbc_lru walker
2005  * and pipe the addresses to sdbc_cctl dcmd.
2006  */
2007 static int
2008 sdbc_lru(uintptr_t addr, uint_t flags, int argc,
2009 					const mdb_arg_t *argv)
2010 {
2011 	_sd_queue_t _sd_lru_q;
2012 	GElf_Sym sym;
2013 
2014 	if (!(flags & DCMD_ADDRSPEC)) {
2015 		if (mdb_lookup_by_obj("sdbc", "_sd_lru_q", &sym) == -1) {
2016 			mdb_warn("failed to lookup _sd_lru_q symbol");
2017 			return (DCMD_ERR);
2018 		}
2019 
2020 		if (mdb_vread(&_sd_lru_q, sizeof (_sd_queue_t),
2021 						sym.st_value) == -1) {
2022 			mdb_warn("failed to read _sd_lru_q structure");
2023 			return (DCMD_ERR);
2024 		}
2025 
2026 		mdb_printf("Cache LRU Queue\n");
2027 		mdb_inc_indent(4);
2028 		mdb_printf(
2029 		"qlock: 0x%-p (owner) await %d seq %d inq %d req %d noreq %d\n",
2030 			_sd_lru_q.sq_qlock._opaque[0],
2031 			_sd_lru_q.sq_await,
2032 			_sd_lru_q.sq_seq,
2033 			_sd_lru_q.sq_inq,
2034 			_sd_lru_q.sq_req_stat,
2035 			_sd_lru_q.sq_noreq_stat);
2036 
2037 		addr = (uintptr_t)(sym.st_value);
2038 	}
2039 
2040 	if (mdb_pwalk_dcmd("sdbc`sdbc_lru", "sdbc`sdbc_cctl",
2041 					argc, argv, addr) == -1) {
2042 		mdb_warn("failed to walk lru at addr %p", addr);
2043 		return (DCMD_ERR);
2044 	}
2045 
2046 	return (DCMD_OK);
2047 }
2048 
2049 #ifdef SAFESTORE
2050 static void
2051 print_wrq(_sd_writeq_t *wrq, uint_t verbose)
2052 {
2053 	int i;
2054 
2055 	mdb_printf("Cache Write Ctl Queue:\n");
2056 	mdb_inc_indent(4);
2057 	mdb_printf("qtop %-p qlock: %-p (owner) inq %d\n",
2058 		wrq->wq_qtop,
2059 		wrq->wq_qlock._opaque[0],
2060 		wrq->wq_inq);
2061 
2062 	mdb_printf("slp_top %3-d slp_index %3-d slp_inq %3-d\n",
2063 		wrq->wq_slp_top,
2064 		wrq->wq_slp_index,
2065 		wrq->wq_slp_inq);
2066 
2067 	for (i = 0; verbose && i < SD_WR_SLP_Q_MAX; i += 2) {
2068 		mdb_printf("%3d: cv %h-x wq_need %3-d wq_held %3-d%4T",
2069 			i,
2070 			wrq->wq_slp[i].slp_wqcv._opaque,
2071 			wrq->wq_slp[i].slp_wqneed,
2072 			wrq->wq_slp[i].slp_wqheld);
2073 		if (SD_WR_SLP_Q_MAX > (i + 1)) {
2074 			mdb_printf(
2075 			"%3d: cv %h-x wq_need %3-d wq_held %3-d%\n",
2076 			    i+1,
2077 			    wrq->wq_slp[i+1].slp_wqcv._opaque,
2078 			    wrq->wq_slp[i+1].slp_wqneed,
2079 			    wrq->wq_slp[i+1].slp_wqheld);
2080 		}
2081 	}
2082 	mdb_dec_indent(4);
2083 }
2084 
2085 /*
2086  * dcmd to display write control structures
2087  */
2088 
2089 static int
2090 sdbc_wctl(uintptr_t addr, uint_t flags, int argc,
2091 					const mdb_arg_t *argv)
2092 {
2093 	_sd_wr_cctl_t wctl;
2094 	ss_centry_info_t gl_info;
2095 	ss_centry_info_t nv_gl_info;
2096 	uintptr_t opt_c = MDB_CD;
2097 	uint_t opt_d = FALSE;
2098 	uint_t opt_v = FALSE;
2099 
2100 
2101 	/* TODO option for fba pos */
2102 	if (mdb_getopts(argc, argv,
2103 			'd', MDB_OPT_SETBITS, TRUE, &opt_d,
2104 			'c', MDB_OPT_UINTPTR, &opt_c,
2105 			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
2106 		return (DCMD_USAGE);
2107 
2108 
2109 	if (!(flags & DCMD_ADDRSPEC)) {
2110 		if (mdb_walk_dcmd("sdbc`sdbc_wctl", "sdbc`sdbc_wctl",
2111 					argc, argv) == -1) {
2112 			mdb_warn("failed to walk write ctl array");
2113 			return (DCMD_ERR);
2114 		}
2115 		return (DCMD_OK);
2116 	}
2117 
2118 	if (DCMD_HDRSPEC(flags)) {
2119 		mdb_printf("write control block structures:\n");
2120 	}
2121 
2122 	if (mdb_vread(&wctl, sizeof (_sd_wr_cctl_t), addr) == -1) {
2123 		mdb_warn("failed to read wctl at 0x%p", addr);
2124 		return (DCMD_ERR);
2125 	}
2126 
2127 
2128 	/*
2129 	 * print "all" is the default.
2130 	 * filter conditions can only be checked by reading in wc_gl_info
2131 	 */
2132 	if (opt_c || opt_d || opt_v)
2133 	    if (mdb_vread(&gl_info, sizeof (ss_centry_info_t),
2134 				(uintptr_t)wctl.wc_gl_info) == -1) {
2135 		    mdb_warn("failed to read at wc_gl_info 0x%p", addr);
2136 		return (DCMD_ERR);
2137 	}
2138 
2139 
2140 	if (OPT_C_SELECTED && (gl_info.gl_cd != opt_c))
2141 		return (DCMD_OK);
2142 
2143 	if (opt_d && !(gl_info.gl_dirty))
2144 		return (DCMD_OK);
2145 
2146 	mdb_inc_indent(4);
2147 	mdb_printf("%-p data %-p gl_info %-p Ngl_info %-p flg %02x\n",
2148 		addr,
2149 		wctl.wc_data,
2150 		wctl.wc_gl_info,
2151 		wctl.wc_nvmem_gl_info,
2152 		wctl.wc_flag);
2153 	mdb_dec_indent(4);
2154 
2155 	/* verbose */
2156 	if (!opt_v)
2157 		return (DCMD_OK);
2158 
2159 	mdb_inc_indent(4);
2160 	mdb_printf("next %?-p prev %?-p\n", wctl.wc_next, wctl.wc_prev);
2161 	mdb_printf("      gl_info: ");
2162 	mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n",
2163 		gl_info.gl_cd, gl_info.gl_fpos, gl_info.gl_dirty & 0xffff,
2164 		gl_info.gl_flag, cc_flag_bits);
2165 
2166 	if (wctl.wc_nvmem_gl_info) {
2167 	    if (mdb_vread(&nv_gl_info, sizeof (ss_centry_info_t),
2168 				(uintptr_t)wctl.wc_nvmem_gl_info) == -1) {
2169 		    mdb_warn("failed to read at wc_nvmem_gl_info 0x%p",
2170 		    wctl.wc_nvmem_gl_info);  /* not catastophic, continue */
2171 	    } else {
2172 
2173 		    /* consistency check */
2174 			if (memcmp(&gl_info, &nv_gl_info,
2175 					sizeof (ss_centry_info_t) != 0)) {
2176 			mdb_warn("nvram and host memory are NOT identical!");
2177 			mdb_printf("nvmem_gl_info: ");
2178 			mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n",
2179 			nv_gl_info.gl_cd, nv_gl_info.gl_fpos,
2180 			nv_gl_info.gl_dirty & 0xffff,
2181 			nv_gl_info.gl_flag, cc_flag_bits);
2182 		    }
2183 
2184 	    }
2185 	}
2186 
2187 	mdb_dec_indent(4);
2188 	mdb_printf("\n");
2189 	return (DCMD_OK);
2190 }
2191 
2192 /*
2193  * dcmd to display write control structures in the free list
2194  * same options as sdbc_wctl
2195  */
2196 
2197 static int
2198 sdbc_wrq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2199 {
2200 	_sd_net_t _sd_net_config;
2201 	uintptr_t opt_c = MDB_CD;
2202 	uint_t opt_d = FALSE;
2203 	uint_t opt_v = FALSE;
2204 
2205 
2206 	/* look for verbose option */
2207 	if (mdb_getopts(argc, argv,
2208 			'd', MDB_OPT_SETBITS, TRUE, &opt_d,
2209 			'c', MDB_OPT_UINTPTR, &opt_c,
2210 			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
2211 		return (DCMD_USAGE);
2212 
2213 	if (!(flags & DCMD_ADDRSPEC)) {
2214 		if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) {
2215 			mdb_warn("failed to read _sd_net_config structure");
2216 			return (DCMD_ERR);
2217 		}
2218 
2219 		print_wrq(&(_sd_net_config.sn_wr_queue), opt_v);
2220 
2221 		addr = (uintptr_t)(_sd_net_config.sn_wr_queue.wq_qtop);
2222 	}
2223 
2224 	if (mdb_pwalk_dcmd("sdbc`sdbc_wrq", "sdbc`sdbc_wctl",
2225 					argc, argv, addr) == -1) {
2226 		mdb_warn("failed to walk write ctl queue at addr %p", addr);
2227 		return (DCMD_ERR);
2228 	}
2229 	return (DCMD_OK);
2230 }
2231 #endif
2232 
2233 /*
2234  * dcmd to display the dm queues
2235  * use sdbc_lru walker to walk each queue.
2236  */
2237 /*ARGSUSED*/
2238 static int
2239 sdbc_dmqueues(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2240 {
2241 	_sd_queue_t *sdbc_dm_queues; /* kernel address of dm queues */
2242 	int max_dm_queues;
2243 	_sd_queue_t *queues = NULL; /* local copy */
2244 	int i;
2245 
2246 
2247 	if (argc != 0)
2248 		return (DCMD_USAGE);
2249 
2250 	if (!(flags & DCMD_ADDRSPEC)) {
2251 		if (mdb_readvar(&sdbc_dm_queues, "sdbc_dm_queues") == -1) {
2252 			mdb_warn("failed to read sdbc_dm_queues address\n");
2253 			return (DCMD_ERR);
2254 		}
2255 
2256 		if (mdb_readvar(&max_dm_queues, "max_dm_queues") == -1) {
2257 			mdb_warn("failed to read max_dm_queues variable\n");
2258 			return (DCMD_ERR);
2259 		}
2260 
2261 		queues = mdb_zalloc(max_dm_queues * sizeof (_sd_queue_t),
2262 					UM_SLEEP);
2263 mdb_printf("max_dm_queues %d sdbc_dm_queues %p queues %p\n",
2264 		max_dm_queues, sdbc_dm_queues, queues);
2265 
2266 		if (mdb_vread(queues, max_dm_queues * sizeof (_sd_queue_t),
2267 					(uintptr_t)sdbc_dm_queues) == -1) {
2268 			mdb_warn("failed to read sdbc_dm_queues");
2269 			return (DCMD_ERR);
2270 		}
2271 
2272 		for (i = 0;  i < max_dm_queues; ++i) {
2273 			mdb_printf("Cache DM Queue %d %p\n",
2274 					queues[i].sq_dmchain_cblocks,
2275 					sdbc_dm_queues +i);
2276 			mdb_inc_indent(4);
2277 			mdb_printf("qlock: 0x%-p (owner) await %d "
2278 					"seq %d inq %d req %d noreq %d\n",
2279 					queues[i].sq_qlock._opaque[0],
2280 					queues[i].sq_await,
2281 					queues[i].sq_seq,
2282 					queues[i].sq_inq,
2283 					queues[i].sq_req_stat,
2284 					queues[i].sq_noreq_stat);
2285 
2286 			mdb_dec_indent(4);
2287 		}
2288 	}
2289 
2290 	return (DCMD_OK);
2291 }
2292 
2293 
2294 mdb_bitmask_t cd_writer_bits[] = {
2295 	{ "NONE   ", (u_longlong_t)~0, _SD_WRITER_NONE },
2296 	{ "CREATE ", (u_longlong_t)~0, _SD_WRITER_CREATE },
2297 	{ "RUNNING", (u_longlong_t)~0, _SD_WRITER_RUNNING },
2298 	{ NULL, 0, 0 }
2299 };
2300 
2301 mdb_bitmask_t sh_failed_status[] = {
2302 	{ "STATUS OK", (u_longlong_t)~0, 0 },
2303 	{ "I/O ERROR", (u_longlong_t)~0, 1 },
2304 	{ "OPEN FAIL", (u_longlong_t)~0, 2 },
2305 	{ NULL, 0, 0 }
2306 };
2307 
2308 mdb_bitmask_t sh_flag_bits[] = {
2309 	{ "ATTACHED", CD_ATTACHED, CD_ATTACHED },
2310 	{ NULL, 0, 0 }
2311 };
2312 
2313 mdb_bitmask_t sh_alloc_bits[] = {
2314 	{ "ALLOC_IN_PROGRESS", CD_ALLOC_IN_PROGRESS, CD_ALLOC_IN_PROGRESS },
2315 	{ "ALLOCATED", CD_ALLOCATED, CD_ALLOCATED },
2316 	{ "CLOSE_IN_PROGRESS", CD_CLOSE_IN_PROGRESS, CD_CLOSE_IN_PROGRESS },
2317 	{ NULL, 0, 0 }
2318 };
2319 
2320 /*
2321  * dcmd to display cd information
2322  */
2323 static int
2324 sdbc_cdinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2325 {
2326 	_sd_shared_t sd_shared;
2327 	_sd_cd_info_t cdi;
2328 	ss_voldata_t gl_file;
2329 	char *fn = "nopath"; /* filename if sd_shared info cannot be read */
2330 	uchar_t sh_alloc = 0; /* assume not alloc'd if sd_shared info unavail */
2331 	uintptr_t opt_c = MDB_CD;
2332 	uint_t opt_a = FALSE;
2333 	uint_t opt_v = FALSE;
2334 	int dev_t_chars;
2335 
2336 	dev_t_chars = sizeof (dev_t) * 2;	/* # chars to display dev_t */
2337 
2338 
2339 	if (mdb_getopts(argc, argv,
2340 			'a', MDB_OPT_SETBITS, TRUE, &opt_a,
2341 			'c', MDB_OPT_UINTPTR, &opt_c,
2342 			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
2343 		return (DCMD_USAGE);
2344 
2345 	if (!(flags & DCMD_ADDRSPEC)) {
2346 		if (mdb_walk_dcmd("sdbc`sdbc_cdinfo", "sdbc`sdbc_cdinfo",
2347 					argc, argv) == -1) {
2348 			mdb_warn("failed to walk cd info array");
2349 			return (DCMD_ERR);
2350 		}
2351 		return (DCMD_OK);
2352 	}
2353 
2354 	if (DCMD_HDRSPEC(flags)) {
2355 		mdb_printf("cd info structures:\n");
2356 	}
2357 
2358 	if (mdb_vread(&cdi, sizeof (_sd_cd_info_t), addr) == -1) {
2359 		mdb_warn("failed to read cd info at 0x%p", addr);
2360 		return (DCMD_ERR);
2361 	}
2362 
2363 	/*
2364 	 * need to do this read even for non-verbose option to
2365 	 * get the filename and the sh_alloc field
2366 	 */
2367 	if (cdi.cd_info) {
2368 	    if (mdb_vread(&sd_shared, sizeof (_sd_shared_t),
2369 				    (uintptr_t)cdi.cd_info) == -1) {
2370 		    mdb_warn("failed to read shared cd info at 0x%p",
2371 						    cdi.cd_info);
2372 		    /* not catastrophic, keep truckin' */
2373 	    } else {
2374 		    fn = sd_shared.sh_filename;
2375 		    sh_alloc = sd_shared.sh_alloc;
2376 	    }
2377 	}
2378 
2379 	if (!opt_a && (sh_alloc == 0))
2380 		return (DCMD_OK);
2381 
2382 	if (OPT_C_SELECTED && (opt_c != cdi.cd_desc))
2383 		return (DCMD_OK);
2384 
2385 	mdb_inc_indent(4);
2386 	mdb_printf("%p cd %3-d filename %s\n",
2387 		addr, cdi.cd_desc, fn);
2388 	mdb_printf("alloc <%b> hint <%b>\n",
2389 		sh_alloc, sh_alloc_bits,
2390 		cdi.cd_hint, cache_hints);
2391 	mdb_dec_indent(4);
2392 
2393 	if (!opt_v)
2394 		return (DCMD_OK);
2395 
2396 	/* verbose */
2397 	mdb_inc_indent(4);
2398 	mdb_printf("rawfd %?-p crdev %0*lx iodev %?-p\n",
2399 		cdi.cd_rawfd,
2400 		dev_t_chars,
2401 		cdi.cd_crdev,
2402 		cdi.cd_iodev);
2403 	mdb_printf("flag %x %8Tlock %?-p writer <%b>\n",
2404 		cdi.cd_flag,
2405 		cdi.cd_lock._opaque[0],
2406 		cdi.cd_writer, cd_writer_bits);
2407 	mdb_printf("global %?-p dirty_head %?-p\n",
2408 		cdi.cd_global, cdi.cd_dirty_head);
2409 	mdb_printf("last_ent %?-p lastchain_ptr %?-p lastchain %d\n",
2410 		cdi.cd_last_ent, cdi.cd_lastchain_ptr,
2411 		cdi.cd_lastchain);
2412 	mdb_printf("io_head %?-p io_tail %?-p fail_head %?-p\n",
2413 		cdi.cd_io_head, cdi.cd_io_tail, cdi.cd_fail_head);
2414 	mdb_printf(
2415 	    "cd_info %?-p failover %d recovering %d write_inprogress %d\n",
2416 		cdi.cd_info, cdi.cd_failover,
2417 		cdi.cd_recovering,
2418 		cdi.cd_write_inprogress);
2419 
2420 	if (cdi.cd_global != NULL) {
2421 		if (mdb_vread(&gl_file, sizeof (ss_voldata_t),
2422 					(uintptr_t)cdi.cd_global) == -1)
2423 			mdb_warn("failed to read cd_global at %p",
2424 						    cdi.cd_global);
2425 		else {
2426 			mdb_printf("cd_global: %s\n", gl_file.sv_volname);
2427 			mdb_printf("pinned %2-d attached %2-d devidsz %3-d\n",
2428 				gl_file.sv_pinned, gl_file.sv_attached,
2429 				gl_file.sv_devidsz);
2430 			mdb_printf("devid %s\n", gl_file.sv_devid);
2431 			mdb_printf("vol %?p\n", gl_file.sv_vol);
2432 		}
2433 		/* TODO do a consistency check here against the nvram copy */
2434 	}
2435 
2436 	if (cdi.cd_info == NULL) {
2437 		mdb_printf("no shared info\n");
2438 	} else {
2439 		mdb_printf("shared:\n");
2440 		mdb_printf("failed <%b> cd %3-d",
2441 		    sd_shared.sh_failed, sh_failed_status,
2442 		    sd_shared.sh_cd);
2443 		mdb_printf("cache_read %10-d cache_write %10-d\n",
2444 		    sd_shared.sh_cache_read, sd_shared.sh_cache_write);
2445 		mdb_printf("disk_read %10-d disk_write %10-d filesize %10-d\n",
2446 		    sd_shared.sh_disk_read, sd_shared.sh_disk_write,
2447 		    sd_shared.sh_filesize);
2448 		mdb_printf("numdirty %8-d numio %8-d numfail %8-d\n",
2449 		    sd_shared.sh_numdirty,
2450 		    sd_shared.sh_numio,
2451 		    sd_shared.sh_numfail);
2452 		mdb_printf("flushloop %2-d sh_flag <%b>\n",
2453 		    sd_shared.sh_flushloop, sd_shared.sh_flag, sh_flag_bits);
2454 
2455 		/* this can be really verbose */
2456 		if (cdi.cd_dirty_head) {
2457 			mdb_printf("Dirty Chain (cd_dirty_head):");
2458 			/* TODO reconstruct argv without opt_a */
2459 			if (!opt_a)
2460 				mdb_call_dcmd("sdbc_dchain",
2461 					(uintptr_t)cdi.cd_dirty_head,
2462 					flags, argc, argv);
2463 			else /* print with no options */
2464 				mdb_call_dcmd("sdbc_dchain",
2465 					(uintptr_t)cdi.cd_dirty_head,
2466 					flags, 0, NULL);
2467 		}
2468 
2469 		if (cdi.cd_io_head) {
2470 			mdb_printf("I/O Pending Chain (cd_io_head):");
2471 			/* TODO reconstruct argv without opt_a */
2472 			if (!opt_a)
2473 				mdb_call_dcmd("sdbc_dchain",
2474 					(uintptr_t)cdi.cd_io_head,
2475 					flags, argc, argv);
2476 			else /* print with no options */
2477 				mdb_call_dcmd("sdbc_dchain",
2478 					(uintptr_t)cdi.cd_dirty_head,
2479 					flags, 0, NULL);
2480 		}
2481 
2482 		if (cdi.cd_fail_head) {
2483 			mdb_printf("Failed Chain (cd_fail_head):");
2484 			/* TODO reconstruct argv without opt_a */
2485 			if (!opt_a)
2486 				mdb_call_dcmd("sdbc_dchain",
2487 					(uintptr_t)cdi.cd_fail_head,
2488 					flags, argc, argv);
2489 			else /* print with no options */
2490 				mdb_call_dcmd("sdbc_dchain",
2491 					(uintptr_t)cdi.cd_dirty_head,
2492 					flags, 0, NULL);
2493 		}
2494 	}
2495 
2496 	mdb_dec_indent(4);
2497 
2498 	mdb_printf("\n");
2499 
2500 	return (DCMD_OK);
2501 }
2502 
2503 #ifdef SAFESTORE
2504 /*
2505  * dcmd to display fault tolerant control structures
2506  */
2507 static int
2508 sdbc_ftctl(uintptr_t addr, uint_t flags, int argc,
2509 					const mdb_arg_t *argv)
2510 {
2511 	_sd_ft_cctl_t ft_cent;
2512 	ss_centry_info_t gl_info;
2513 	ss_centry_info_t nv_gl_info;
2514 	uintptr_t opt_c = MDB_CD;
2515 	uint_t opt_d = FALSE;
2516 	uint_t opt_v = FALSE;
2517 
2518 
2519 	/* TODO option to select on fpos */
2520 	if (mdb_getopts(argc, argv,
2521 			'd', MDB_OPT_SETBITS, TRUE, &opt_d,
2522 			'c', MDB_OPT_UINTPTR, &opt_c,
2523 			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
2524 		return (DCMD_USAGE);
2525 
2526 
2527 	if (!(flags & DCMD_ADDRSPEC)) {
2528 		if (mdb_walk_dcmd("sdbc`sdbc_ftctl", "sdbc`sdbc_ftctl",
2529 					argc, argv) == -1) {
2530 			mdb_warn("failed to walk write ctl array");
2531 			return (DCMD_ERR);
2532 		}
2533 		return (DCMD_OK);
2534 	}
2535 
2536 	if (DCMD_HDRSPEC(flags)) {
2537 		mdb_printf("Ft control block structures:\n");
2538 	}
2539 
2540 	if (mdb_vread(&ft_cent, sizeof (_sd_ft_cctl_t), addr) == -1) {
2541 		mdb_warn("failed to read ft_cent at 0x%p", addr);
2542 		return (DCMD_ERR);
2543 	}
2544 
2545 
2546 	/*
2547 	 * print "all" is the default.
2548 	 * filter conditions can only be checked by reading in wc_gl_info
2549 	 */
2550 	if (opt_c || opt_d || opt_v)
2551 	    if (mdb_vread(&gl_info, sizeof (ss_centry_info_t),
2552 				(uintptr_t)ft_cent.ft_gl_info) == -1) {
2553 		mdb_warn("failed to read at wc_gl_info 0x%p", addr);
2554 		return (DCMD_ERR);
2555 	}
2556 
2557 
2558 	if (OPT_C_SELECTED && (gl_info.gl_cd != opt_c))
2559 		return (DCMD_OK);
2560 
2561 	if (opt_d && !(gl_info.gl_dirty))
2562 		return (DCMD_OK);
2563 
2564 	mdb_inc_indent(4);
2565 	mdb_printf("%-p data %?-p qnext %?-p\n",
2566 		addr,
2567 		ft_cent.ft_qnext,
2568 		ft_cent.ft_data);
2569 	mdb_printf("gl_info %?-p nvmem_gl_info %?-p\n",
2570 		ft_cent.ft_gl_info,
2571 		ft_cent.ft_nvmem_gl_info);
2572 	mdb_dec_indent(4);
2573 
2574 	/* verbose */
2575 	if (!opt_v) {
2576 		mdb_printf("\n");
2577 		return (DCMD_OK);
2578 	}
2579 
2580 	mdb_inc_indent(4);
2581 	mdb_printf("      gl_info: ");
2582 	mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n",
2583 		gl_info.gl_cd, gl_info.gl_fpos, gl_info.gl_dirty & 0xffff,
2584 		gl_info.gl_flag, cc_flag_bits);
2585 
2586 	if (ft_cent.ft_nvmem_gl_info) {
2587 	    if (mdb_vread(&nv_gl_info, sizeof (ss_centry_info_t),
2588 				(uintptr_t)ft_cent.ft_nvmem_gl_info) == -1) {
2589 		    mdb_warn("failed to read at ft_nvmem_gl_info 0x%p",
2590 		    ft_cent.ft_nvmem_gl_info);  /* not catastophic, continue */
2591 	    } else {
2592 		    mdb_printf("nvmem_gl_info: ");
2593 		    mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n",
2594 		    nv_gl_info.gl_cd, nv_gl_info.gl_fpos,
2595 		    nv_gl_info.gl_dirty & 0xffff,
2596 		    nv_gl_info.gl_flag, cc_flag_bits);
2597 
2598 		    /* consistency check */
2599 		    if (memcmp(&gl_info, &nv_gl_info, sizeof (ss_centry_info_t))
2600 								!= 0) {
2601 			mdb_warn("nvram and host memory are NOT identical!");
2602 		    }
2603 
2604 	    }
2605 	}
2606 
2607 	mdb_dec_indent(4);
2608 	mdb_printf("\n");
2609 	return (DCMD_OK);
2610 }
2611 #endif /* SAFESTORE */
2612 
2613 
2614 /* dcmd to display buffer handles */
2615 static int
2616 sdbc_handles(uintptr_t addr, uint_t flags, int argc,
2617 					const mdb_arg_t *argv)
2618 {
2619 	uint_t opt_a = FALSE;
2620 	uintptr_t opt_c = MDB_CD;
2621 	uint_t opt_v = FALSE;
2622 	uint_t opt_C = FALSE;
2623 	_sd_buf_hlist_t hl;
2624 	_sd_buf_handle_t bh;
2625 
2626 
2627 	if (mdb_getopts(argc, argv,
2628 			'a', MDB_OPT_SETBITS, TRUE, &opt_a,
2629 			'c', MDB_OPT_UINTPTR, &opt_c,
2630 			'C', MDB_OPT_SETBITS, TRUE, &opt_C,
2631 			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
2632 		return (DCMD_USAGE);
2633 
2634 
2635 	if (mdb_readvar(&hl, "_sd_handle_list") == -1) {
2636 		mdb_warn("failed to read _sd_handle_list structure");
2637 		return (DCMD_ERR);
2638 	}
2639 
2640 
2641 	if (!(flags & DCMD_ADDRSPEC)) {
2642 		if (mdb_walk_dcmd("sdbc`sdbc_handles", "sdbc`sdbc_handles",
2643 					argc, argv) == -1) {
2644 			mdb_warn("failed to walk 'sdbc_handle_list'");
2645 			return (DCMD_ERR);
2646 		}
2647 		return (DCMD_OK);
2648 	}
2649 
2650 	if (DCMD_HDRSPEC(flags)) {
2651 		mdb_printf("Handle List Info:\n");
2652 
2653 		mdb_inc_indent(4);
2654 		mdb_printf("hl_top.bh_next: 0x%p\n", hl.hl_top.bh_next);
2655 		mdb_printf("hl_lock: 0x%p (owner)\n", hl.hl_lock._opaque[0]);
2656 		mdb_printf("hl_count: %hd\n", hl.hl_count);
2657 		mdb_dec_indent(4);
2658 		mdb_printf("buf handles:\n");
2659 	}
2660 
2661 	if (mdb_vread(&bh, sizeof (bh), addr) == -1) {
2662 		mdb_warn("failed to read buf handle at 0x%p", addr);
2663 		return (DCMD_ERR);
2664 	}
2665 
2666 	if (!opt_a && !(bh.bh_flag & (NSC_HALLOCATED | NSC_HACTIVE)))
2667 		return (DCMD_OK);
2668 
2669 	/*
2670 	 * may get false matches on cd option --
2671 	 * a cleared bh_cd field will match if user specified cd 0
2672 	 */
2673 	if (OPT_C_SELECTED && (bh.bh_cd != opt_c))
2674 		return (DCMD_OK);
2675 
2676 	mdb_inc_indent(4);
2677 	mdb_printf("%p %8T cd %3-d %4T<%b> %x\n", addr, bh.bh_cd,
2678 					bh.bh_flag, nsc_buf_bits, bh.bh_flag);
2679 
2680 	/* check for verbose, avoid printing twice */
2681 	if (!opt_v && opt_C) {
2682 		mdb_printf("cc_chain: ");
2683 		if (bh.bh_centry)
2684 			mdb_call_dcmd("sdbc`sdbc_cchain",
2685 			    (uintptr_t)bh.bh_centry, DCMD_ADDRSPEC, 0, NULL);
2686 	}
2687 
2688 	mdb_dec_indent(4);
2689 
2690 	if (!opt_v)
2691 		return (DCMD_OK);
2692 
2693 	/* verbose */
2694 	mdb_inc_indent(4);
2695 
2696 	mdb_printf("callbacks: %-20a%-20a%-20a\n",
2697 	    bh.bh_disconnect_cb, bh.bh_read_cb, bh.bh_write_cb);
2698 
2699 	mdb_printf("centry %?p %8T next %?p\n",
2700 				bh.bh_centry, bh.bh_next);
2701 	mdb_printf("buffer:\n");
2702 
2703 	mdb_inc_indent(4);
2704 	mdb_printf("fd 0x%p pos %10d len %6d flag 0x%x\n",
2705 		    bh.bh_buf.sb_fd, bh.bh_fba_pos, bh.bh_fba_len, bh.bh_flag);
2706 
2707 	mdb_printf("alloc_thread %p busy_thread %p\n", bh.bh_alloc_thread,
2708 			bh.bh_busy_thread);
2709 
2710 	mdb_printf("err %4d %8T bh_vec 0x%p\n", bh.bh_error, bh.bh_vec);
2711 	mdb_dec_indent(4);
2712 
2713 	mdb_printf("bufvec (scatter gather list): %-?s %8T%-s\n",
2714 						"ADDR", "LEN");
2715 	{
2716 		_sd_bufvec_t *bv, *endvec;
2717 
2718 
2719 		/* todo check for (bh_vec != bh_bufvec) => readahead? */
2720 
2721 		bv = bh.bh_bufvec;
2722 		endvec = bv + _SD_MAX_BLKS;
2723 		mdb_inc_indent(30);
2724 		while (bv->bufaddr) {
2725 			mdb_printf("%p    %8T%d\n", bv->bufaddr, bv->buflen);
2726 			++bv;
2727 			if (bv > endvec) {
2728 				mdb_warn("END of bh_bufvec ARRAY");
2729 				break;
2730 			}
2731 		}
2732 		mdb_dec_indent(30);
2733 	}
2734 
2735 	if (opt_C) {
2736 		mdb_printf("cc_chain: ");
2737 		if (bh.bh_centry)
2738 			mdb_call_dcmd("sdbc`sdbc_cchain",
2739 			    (uintptr_t)bh.bh_centry, DCMD_ADDRSPEC, 0, NULL);
2740 	}
2741 
2742 	mdb_dec_indent(4);
2743 	mdb_printf("\n");
2744 
2745 	return (DCMD_OK);
2746 }
2747 /*
2748  * dcmd to display ss_centry_info_t structures and
2749  * do optional consistency check with the nvram copy
2750  * if configured for nvram safe storage.
2751  */
2752 
2753 static int
2754 sdbc_glcinfo(uintptr_t addr, uint_t flags, int argc,
2755 					const mdb_arg_t *argv)
2756 {
2757 	ss_centry_info_t gl_centry_info;
2758 	/* for doing consistency check */
2759 
2760 	ss_centry_info_t *gl_centry_info_start;
2761 	ss_centry_info_t *nv_gl_centry_info_start;
2762 	uintptr_t nv_addr;
2763 	ss_centry_info_t nv_gl_centry_info;
2764 
2765 	/* options */
2766 	uint_t opt_a = FALSE;
2767 	uintptr_t opt_b = MDB_BLKNUM;	/* fba pos match */
2768 	uintptr_t opt_c = MDB_CD;
2769 	uintptr_t opt_C = FALSE; /* consistency check */
2770 	uint_t opt_d = FALSE;
2771 
2772 
2773 
2774 	if (mdb_getopts(argc, argv,
2775 			'a', MDB_OPT_SETBITS, TRUE, &opt_a,
2776 			'b', MDB_OPT_UINTPTR, &opt_b,
2777 			'c', MDB_OPT_UINTPTR, &opt_c,
2778 			'C', MDB_OPT_SETBITS, TRUE, &opt_C,
2779 			'd', MDB_OPT_SETBITS, TRUE, &opt_d) != argc)
2780 		return (DCMD_USAGE);
2781 
2782 
2783 	if (!(flags & DCMD_ADDRSPEC)) {
2784 		if (mdb_walk_dcmd("sdbc`sdbc_glcinfo", "sdbc`sdbc_glcinfo",
2785 					argc, argv) == -1) {
2786 			mdb_warn("failed to walk global centry info array");
2787 			return (DCMD_ERR);
2788 		}
2789 		return (DCMD_OK);
2790 	}
2791 
2792 	if (DCMD_HDRSPEC(flags)) {
2793 		mdb_printf("global cache entry info:\n");
2794 	}
2795 
2796 	if (mdb_vread(&gl_centry_info, sizeof (ss_centry_info_t), addr) == -1) {
2797 		mdb_warn("failed to read gl_centry_info at 0x%p", addr);
2798 		return (DCMD_ERR);
2799 	}
2800 
2801 
2802 	/*
2803 	 * default is to print entries initialized with a cd.  return if
2804 	 * no options are selected and cd is invalid.
2805 	 */
2806 	if (!opt_a && (!OPT_B_SELECTED) && (!OPT_C_SELECTED) && !opt_d &&
2807 		(gl_centry_info.sc_cd == -1))
2808 		return (DCMD_OK);
2809 
2810 
2811 	/*
2812 	 * opt_c is exclusive filter. if opt_c is selected and there
2813 	 * is no match on the cd then return
2814 	 */
2815 	if (!opt_a &&
2816 		(OPT_C_SELECTED && (gl_centry_info.sc_cd != opt_c)))
2817 		return (DCMD_OK);
2818 
2819 	/*
2820 	 * opt_d and opt_b are inclusive. print if either one is chosen
2821 	 * and the selection condition is true.
2822 	 */
2823 	if (opt_a ||
2824 	    (!opt_d && (!OPT_B_SELECTED)) || /* no options chosen */
2825 	    (opt_d && gl_centry_info.sc_dirty) ||
2826 	    (OPT_B_SELECTED && (gl_centry_info.sc_fpos == opt_b)))
2827 		/*EMPTY*/;
2828 	else
2829 		return (DCMD_OK);
2830 
2831 	mdb_inc_indent(4);
2832 	mdb_printf("%?-p cd %3-d fpos %10-d dirty %04x flag <%b>\n",
2833 		addr,
2834 		gl_centry_info.sc_cd,
2835 		gl_centry_info.sc_fpos,
2836 		gl_centry_info.sc_dirty & 0xffff,
2837 		gl_centry_info.sc_flag, cc_flag_bits);
2838 
2839 	if (opt_C) {
2840 		/* get start of the cache entry metadata */
2841 		if (mdb_readvar(&gl_centry_info_start,
2842 				"_sdbc_gl_centry_info") == -1) {
2843 			mdb_warn("failed to read  _sdbc_gl_centry_info");
2844 			/* not catastrophic */
2845 			goto end;
2846 		}
2847 
2848 		/* get start of the nvram copy cache entry metadata */
2849 		if (mdb_readvar(&nv_gl_centry_info_start,
2850 				"_sdbc_gl_centry_info_nvmem") == -1) {
2851 			mdb_warn("failed to read  _sdbc_gl_centry_info_nvmem");
2852 			/* not catastrophic */
2853 			goto end;
2854 		}
2855 
2856 		nv_addr = (addr - (uintptr_t)gl_centry_info_start) +
2857 				(uintptr_t)nv_gl_centry_info_start;
2858 
2859 		if (mdb_vread(&nv_gl_centry_info, sizeof (ss_centry_info_t),
2860 						    nv_addr) == -1) {
2861 			mdb_warn("failed to read at nvmem_gl_info 0x%p",
2862 					nv_addr);
2863 		    /* not catastophic, continue */
2864 	    } else {
2865 
2866 			/* consistency check */
2867 			mdb_inc_indent(4);
2868 			if (memcmp(&gl_centry_info, &nv_gl_centry_info,
2869 					sizeof (ss_centry_info_t) != 0)) {
2870 				mdb_warn(
2871 				"nvram and host memory are NOT identical!");
2872 				mdb_printf("nvmem_gl_centry_info: ");
2873 				mdb_printf(
2874 			    "%?-p cd %3-d fpos %10-d dirty %04x flag <%b>\n",
2875 				nv_addr,
2876 				nv_gl_centry_info.sc_cd,
2877 				nv_gl_centry_info.sc_fpos,
2878 				nv_gl_centry_info.sc_dirty & 0xffff,
2879 				nv_gl_centry_info.sc_flag, cc_flag_bits);
2880 				mdb_printf("\n");
2881 		    } else
2882 				mdb_printf("NVRAM ok\n");
2883 
2884 		    mdb_dec_indent(4);
2885 
2886 	    }
2887 	}
2888 
2889 	end:
2890 	mdb_dec_indent(4);
2891 	return (DCMD_OK);
2892 }
2893 
2894 /*
2895  * dcmd to display ss_voldata_t structures and
2896  * do optional consistency check with the nvram copy
2897  * if configured for nvram safe storage.
2898  */
2899 
2900 static int
2901 sdbc_glfinfo(uintptr_t addr, uint_t flags, int argc,
2902 					const mdb_arg_t *argv)
2903 {
2904 	ss_voldata_t gl_file_info;
2905 	/* for doing consistency check */
2906 
2907 	ss_voldata_t *gl_file_info_start;
2908 	ss_voldata_t *nv_gl_file_info_start;
2909 	uintptr_t nv_addr;
2910 	ss_voldata_t nv_gl_file_info;
2911 
2912 	/* options  default: valid filename */
2913 	uint_t opt_a = FALSE; /* all */
2914 	uint_t opt_p = FALSE; /* PINNED */
2915 	uint_t opt_t = FALSE; /* attached */
2916 	uint_t opt_C = FALSE; /* consistency check */
2917 
2918 
2919 
2920 	/*
2921 	 * possible enhancement -- match on filename,
2922 	 * or filename part (e.g. controller number)
2923 	 */
2924 	if (mdb_getopts(argc, argv,
2925 			'a', MDB_OPT_SETBITS, TRUE, &opt_a,
2926 			'C', MDB_OPT_SETBITS, TRUE, &opt_C,
2927 			'p', MDB_OPT_SETBITS, TRUE, &opt_p,
2928 			't', MDB_OPT_SETBITS, TRUE, &opt_t) != argc)
2929 		return (DCMD_USAGE);
2930 
2931 
2932 	if (!(flags & DCMD_ADDRSPEC)) {
2933 		if (mdb_walk_dcmd("sdbc`sdbc_glfinfo", "sdbc`sdbc_glfinfo",
2934 					argc, argv) == -1) {
2935 			mdb_warn("failed to walk global file info array");
2936 			return (DCMD_ERR);
2937 		}
2938 		return (DCMD_OK);
2939 	}
2940 
2941 	if (DCMD_HDRSPEC(flags)) {
2942 		mdb_printf("global file entry info:\n");
2943 	}
2944 
2945 	if (mdb_vread(&gl_file_info, sizeof (ss_voldata_t), addr) == -1) {
2946 		mdb_warn("failed to read gl_file_info at 0x%p", addr);
2947 		return (DCMD_ERR);
2948 	}
2949 
2950 
2951 	/*
2952 	 * default is to print entries initialized with non-null filename.
2953 	 * return if no options are selected and filename is invalid.
2954 	 */
2955 	if (!opt_a && !opt_p && !opt_t &&
2956 		(strlen(gl_file_info.sv_volname) == 0))
2957 		return (DCMD_OK);
2958 
2959 
2960 	if (opt_a ||
2961 		(!opt_p && !opt_t) || /* no options chosen */
2962 		(opt_p && (gl_file_info.sv_pinned != _SD_NO_HOST)) ||
2963 		(opt_t && (gl_file_info.sv_attached != _SD_NO_HOST)))
2964 		/*EMPTY*/;
2965 	else
2966 		return (DCMD_OK);
2967 
2968 	mdb_inc_indent(4);
2969 	mdb_printf("%?-p %s\n", addr, gl_file_info.sv_volname);
2970 	mdb_printf("pinned %2-d attached %2-d devidsz %3-d\n",
2971 		gl_file_info.sv_pinned,
2972 		gl_file_info.sv_attached,
2973 		gl_file_info.sv_devidsz);
2974 	mdb_printf("devid %s\n", gl_file_info.sv_devid);
2975 
2976 	if (opt_C) {
2977 		/* get start of the cache entry metadata */
2978 		if (mdb_readvar(&gl_file_info_start,
2979 				"_sdbc_gl_file_info") == -1) {
2980 			mdb_warn("failed to read  _sdbc_gl_file_info");
2981 			/* not catastrophic */
2982 			goto end;
2983 		}
2984 
2985 		/* get start of the nvram copy cache entry metadata */
2986 		if (mdb_readvar(&nv_gl_file_info_start,
2987 				"_sdbc_gl_file_info_nvmem") == -1) {
2988 			mdb_warn("failed to read  _sdbc_gl_file_info_nvmem");
2989 			/* not catastrophic */
2990 			goto end;
2991 		}
2992 
2993 		nv_addr = (addr - (uintptr_t)gl_file_info_start) +
2994 				(uintptr_t)nv_gl_file_info_start;
2995 
2996 		if (mdb_vread(&nv_gl_file_info, sizeof (ss_voldata_t),
2997 						    nv_addr) == -1) {
2998 			mdb_warn("failed to read nvmem_gl_info at 0x%p",
2999 					nv_addr);
3000 		    /* not catastophic, continue */
3001 	    } else {
3002 
3003 		    /* consistency check */
3004 		    mdb_inc_indent(4);
3005 		    if (memcmp(&gl_file_info, &nv_gl_file_info,
3006 				sizeof (ss_centry_info_t) != 0)) {
3007 			mdb_warn("nvram and host memory are NOT identical!");
3008 			mdb_printf("nvmem_gl_file_info: ");
3009 			mdb_printf("%?-p %s\n", nv_addr,
3010 					nv_gl_file_info.sv_volname);
3011 			mdb_printf("pinned %2-d attached %2-d devidsz %3-d\n",
3012 				nv_gl_file_info.sv_pinned,
3013 				nv_gl_file_info.sv_attached,
3014 				nv_gl_file_info.sv_devidsz);
3015 			mdb_printf("devid %s\n", nv_gl_file_info.sv_devid);
3016 		    } else
3017 			mdb_printf("NVRAM ok\n");
3018 
3019 		    mdb_dec_indent(4);
3020 
3021 	    }
3022 	}
3023 
3024 	end:
3025 	mdb_dec_indent(4);
3026 	mdb_printf("\n");
3027 	return (DCMD_OK);
3028 }
3029 
3030 
3031 /*
3032  * MDB module linkage information:
3033  *
3034  * We declare a list of structures describing our dcmds, and a function
3035  * named _mdb_init to return a pointer to our module information.
3036  */
3037 
3038 static const mdb_dcmd_t dcmds[] = {
3039 	/* general dcmds */
3040 	{ "sdbc_config", NULL,
3041 		"display sdbc configuration information",
3042 		sdbc_config },
3043 	{ "sdbc_stats", NULL,
3044 		"display sdbc stats information",
3045 		sdbc_stats },
3046 	{ "sdbc_vars", NULL,
3047 		"display some sdbc variables, counters and addresses",
3048 		sdbc_vars },
3049 
3050 	/* cctl dcmds */
3051 	{"sdbc_cctl", "?[-vdhioV][-c cd][-b blknum]",
3052 		"display sdbc cache ctl structures",
3053 		sdbc_cctl, cctl_help },
3054 	{"sdbc_cchain", ":[-vdhioV][-c cd][-b blknum]",
3055 		"display cache ctl structure cc_chain",
3056 		sdbc_cchain, cchain_help },
3057 	{"sdbc_dchain", ":[-vdhioV][-c cd][-b blknum]",
3058 		"display cache ctl structure dirty chain",
3059 		sdbc_dchain, dchain_help },
3060 	{"sdbc_dmchain", ":[-vdhioV][-c cd][-b blknum]",
3061 		"display dynamic memory cache ctl chain",
3062 		sdbc_dmchain, dmchain_help },
3063 	{"sdbc_hashchain", ":[-vdhioV][-c cd][-b blknum]",
3064 		"display a hash chain", sdbc_hashchain, hashchain_help },
3065 	{"sdbc_hashtable", "?[-vdhioV][-c cd][-b blknum]",
3066 		"display hash table", sdbc_hashtable, hashtable_help },
3067 	{"sdbc_lru", "?[-vdhioV][-c cd][-b blknum]",
3068 		"display the cache lru queue",
3069 		sdbc_lru, lru_help },
3070 #ifdef SAFESTORE
3071 	/* wctl dcmds */
3072 	{"sdbc_wctl", "?[-vd][-c cd]",
3073 		"display the write control structures",
3074 		sdbc_wctl, wctl_help },
3075 	{"sdbc_wrq", "?[-vd][-c cd]",
3076 		"display the write control queue",
3077 		sdbc_wrq, wrq_help },
3078 #endif /* SAFESTORE */
3079 
3080 	/* others */
3081 	{"sdbc_cdinfo", "?[-av][-c cd]",
3082 		"display cache descriptor information",
3083 		sdbc_cdinfo, cdinfo_help },
3084 #ifdef SAFESTORE
3085 	{"sdbc_ftctl", "?[-vd][-c cd]",
3086 		"display the fault tolerant control structures",
3087 		sdbc_ftctl, ftctl_help },
3088 #endif /* SAFESTORE */
3089 	{"sdbc_handles", "?[-avC][-c cd]",
3090 		"display sdbc buffer handle information",
3091 		sdbc_handles, handle_help },
3092 
3093 	{ "sdbc_dmqueues", NULL,
3094 		"display sdbc dynamic memory buffer queues information",
3095 		sdbc_dmqueues },
3096 
3097 	/* "global" metadata dcmds */
3098 	{"sdbc_glcinfo", "?[-adC][-c cd][-b fbapos]",
3099 		"display the global cache entry info structures",
3100 		sdbc_glcinfo, glcinfo_help },
3101 	{"sdbc_glfinfo", "?[-aptC]",
3102 		"display the global file info structures",
3103 		sdbc_glfinfo, glfinfo_help },
3104 	{ NULL }
3105 };
3106 
3107 static const mdb_walker_t walkers[] = {
3108 	/* walkers of cctl list and arrays */
3109 	{ "sdbc_cchain", "walk the cc_chain (alloc chain) of a cache ctl",
3110 		sdbc_cchain_winit, sdbc_cchain_wstep, sdbc_cchain_wfini },
3111 	{ "sdbc_cctl", "walk the cache ctl structure list",
3112 		sdbc_cctl_winit, sdbc_cctl_wstep, sdbc_cctl_wfini },
3113 	{ "sdbc_dchain", "walk the dirty chain of a cache ctl",
3114 		sdbc_dchain_winit, sdbc_dchain_wstep, sdbc_dchain_wfini },
3115 	{ "sdbc_dmchain", "walk the dynamic memory chain of a cache cctl",
3116 		sdbc_dmchain_winit, sdbc_dmchain_wstep, sdbc_dmchain_wfini },
3117 	{ "sdbc_hashchain", "walk a hash chain",
3118 		sdbc_hashchain_winit, sdbc_hashchain_wstep,
3119 					sdbc_hashchain_wfini },
3120 	{ "sdbc_lru", "walk the cache lru queue",
3121 		sdbc_lru_winit, sdbc_lru_wstep, sdbc_lru_wfini },
3122 
3123 #ifdef SAFESTORE
3124 	/* walkers of wctl lists and arrays */
3125 	{ "sdbc_wctl", "walk the allocated write ctl array",
3126 		sdbc_wctl_winit, sdbc_wctl_wstep, sdbc_wctl_wfini },
3127 	{ "sdbc_wrq", "walk the write ctl queue (free list)",
3128 		sdbc_wrq_winit, sdbc_wrq_wstep, sdbc_wrq_wfini },
3129 #endif /* SAFESTORE */
3130 	/* others */
3131 	{ "sdbc_cdinfo",
3132 	    "walk the _sd_cache_files array of cache descriptor information",
3133 		sdbc_cdinfo_winit, sdbc_cdinfo_wstep, sdbc_cdinfo_wfini },
3134 #ifdef SAFESTORE
3135 	{ "sdbc_ftctl",
3136 	    "walk the allocated array of fault tolerant structures",
3137 		sdbc_ftctl_winit, sdbc_ftctl_wstep, sdbc_ftctl_wfini },
3138 #endif /* SAFESTORE */
3139 	{ "sdbc_handles", "walk array of _sd_buf_handle_t structures",
3140 		sdbc_handle_winit, sdbc_handle_wstep, sdbc_handle_wfini },
3141 
3142 	/* walkers for metadata arrays */
3143 	{ "sdbc_glcinfo", "walk the allocated global cache entry info array",
3144 		sdbc_glcinfo_winit, sdbc_glcinfo_wstep, sdbc_glcinfo_wfini },
3145 	{ "sdbc_glfinfo", "walk the allocated global file info array",
3146 		sdbc_glfinfo_winit, sdbc_glfinfo_wstep, sdbc_glfinfo_wfini },
3147 	{ NULL }
3148 };
3149 
3150 static const mdb_modinfo_t modinfo = {
3151 	MDB_API_VERSION, dcmds, walkers
3152 };
3153 
3154 const mdb_modinfo_t *
3155 _mdb_init(void)
3156 {
3157 	return (&modinfo);
3158 }
3159