?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / mdb / common / modules / sdbc / sdbc.c
blob14c99abecfc0f846e8a48cbce7672b4db0de7679
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 }
unleashed repo fork