/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include #include /* needed to maintain identical _sd_bitmap_t sizes */ #define _SD_8K_BLKSIZE #include #include #include #include /* * initialize cd filter options to this * to differentiate with kernel values in range [-1, sdbc_max_devs] */ #define MDB_CD ((uintptr_t)~1) #define OPT_C_SELECTED (opt_c != MDB_CD) /* initialize block filters to this */ #define MDB_BLKNUM ((uintptr_t)~1) #define OPT_B_SELECTED (opt_b != MDB_BLKNUM) enum vartype { UINTTYPE = 0, ADDRTYPE, LOCKTYPE, CVTYPE }; static void display_var(char *, enum vartype); #ifdef SAFESTORE static void print_wrq(_sd_writeq_t *, uint_t); #endif struct walk_info { uintptr_t w_start; uintptr_t w_end; }; mdb_bitmask_t host_states[] = { { "HOST_NONE", 0xff, _SD_HOST_NONE }, { "HOST_CONFIGURED", 0xff, _SD_HOST_CONFIGURED }, { "HOST_DECONFIGURED", 0xff, _SD_HOST_DECONFIGURED }, { "HOST_NOCACHE", 0xff, _SD_HOST_NOCACHE }, { NULL, 0, 0 } }; mdb_bitmask_t cache_hints[] = { { "WRTHRU", NSC_WRTHRU, NSC_WRTHRU }, { "FORCED_WRTHRU", NSC_FORCED_WRTHRU, NSC_FORCED_WRTHRU }, { "NOCACHE", NSC_NOCACHE, NSC_NOCACHE }, { "QUEUE", NSC_QUEUE, NSC_QUEUE }, { "RDAHEAD", NSC_RDAHEAD, NSC_RDAHEAD }, { "NO_FORCED_WRTHRU", NSC_NO_FORCED_WRTHRU, NSC_NO_FORCED_WRTHRU }, { "METADATA", NSC_METADATA, NSC_METADATA }, { "SEQ_IO", NSC_SEQ_IO, NSC_SEQ_IO }, { NULL, 0, 0 } }; /* * some cache general dcmds that do not use walkers */ /*ARGSUSED*/ static int sdbc_config(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { _sd_cache_param_t _sd_cache_config; _sd_net_t _sd_net_config; _sd_ft_info_t _sd_ft_data; uint_t _sd_node_hint; char sdbc_version[17]; if (mdb_readvar(sdbc_version, "sdbc_version") == -1) { mdb_warn("failed to read sdbc_version symbol"); } else { sdbc_version[16] = '\0'; /* make sure string is terminated */ mdb_printf("sdbc_version %s\n", sdbc_version); } if (mdb_readvar(&_sd_cache_config, "_sd_cache_config") == -1) { mdb_warn("failed to read _sd_cache_config symbol"); } else { mdb_printf("SDBC Configuration:\n"); mdb_inc_indent(4); mdb_printf("user magic: %X kernel magic: %X (should match)\n", _SD_MAGIC, _sd_cache_config.magic); mdb_printf( "mirror host: %2d Block size: %4d threads %4d " "write cache: %4dM\n", _sd_cache_config.mirror_host, _sd_cache_config.blk_size, _sd_cache_config.threads, _sd_cache_config.write_cache); mdb_printf("num_handles %4-d cache_mem %4dM prot_lru %d\n", _sd_cache_config.num_handles, _sd_cache_config.cache_mem[0], _sd_cache_config.prot_lru); mdb_printf("gen_pattern %d fill_pattern %?-p num_nodes %d\n", _sd_cache_config.gen_pattern, _sd_cache_config.fill_pattern, _sd_cache_config.num_nodes); mdb_dec_indent(4); } if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) { mdb_warn("failed to read _sd_net_config symbol"); } else { mdb_inc_indent(4); mdb_printf( "psize %4-d configured %d csize %10-d wsize %10-d cpages %6d\n", _sd_net_config.sn_psize, _sd_net_config.sn_configured, _sd_net_config.sn_csize, _sd_net_config.sn_wsize, _sd_net_config.sn_cpages); mdb_dec_indent(4); #ifdef SAFESTORE print_wrq(&(_sd_net_config.sn_wr_queue), FALSE); #endif } if (mdb_readvar(&_sd_ft_data, "_sd_ft_data") == -1) { mdb_warn("failed to read _sd_ft_data symbol"); } else { mdb_printf("FT data:\n"); mdb_inc_indent(4); mdb_printf("crashed %d host_state <%b> numio %d\n", _sd_ft_data.fi_crashed, _sd_ft_data.fi_host_state, host_states, _sd_ft_data.fi_numio); mdb_printf("lock %?-p (owner) rem_sv %h-x sleep %?-p (owner)\n", _sd_ft_data.fi_lock._opaque[0], _sd_ft_data.fi_rem_sv._opaque, _sd_ft_data.fi_sleep._opaque[0]); mdb_dec_indent(4); } if (mdb_readvar(&_sd_node_hint, "_sd_node_hint") == -1) { mdb_warn("failed to read _sd_node_hint symbol"); } else mdb_printf("Node Hints: %08x <%b>\n", _sd_node_hint, cache_hints); display_var("sdbc_wrthru_len", UINTTYPE); display_var("_sd_debug_level", UINTTYPE); display_var("_sdbc_attached", UINTTYPE); return (DCMD_OK); } static void sdbc_hit_percent(uint_t hits, uint_t misses, char *type) { uint64_t dhits, dmisses; uint64_t hit_rate = 0; mdb_printf("%s hits: %u\t %s misses: %u\n", type, hits, type, misses); /* a little crude. anything less than 1 percent will show as 0 */ if (hits > 0 || misses > 0) { dhits = (uint64_t)hits; dmisses = (uint64_t)misses; hit_rate = (dhits * 100)/ (dhits + dmisses); mdb_printf("%s hit rate: %lld %%\n", type, hit_rate); } mdb_printf("\n"); } /*ARGSUSED*/ static int sdbc_stats(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { int i; char *fn; _sd_stats_t *_sd_cache_stats; /* local memory */ uintptr_t _sd_cache_statsp; /* kernel pointer */ _sd_shared_t *sh; int statssize; GElf_Sym sym; int maxdevs; if (argc != 0) return (DCMD_USAGE); /* get the number of volumes */ if (mdb_readvar(&maxdevs, "sdbc_max_devs") == -1) { mdb_warn("failed to read sdbc_max_devs"); return (DCMD_ERR); } statssize = sizeof (_sd_stats_t) + (maxdevs - 1) * sizeof (_sd_shared_t); _sd_cache_stats = mdb_zalloc(statssize, UM_SLEEP); if (mdb_lookup_by_obj("sdbc", "_sd_cache_stats", &sym) == -1) { mdb_warn("failed to lookup _sd_cache_stats symbol"); return (DCMD_ERR); } if (mdb_vread(&_sd_cache_statsp, sizeof (uintptr_t), sym.st_value) == -1) { mdb_warn("failed to read _sd_stats_t pointer"); return (DCMD_ERR); } if (mdb_vread(_sd_cache_stats, statssize, _sd_cache_statsp) == -1) { mdb_warn("failed to read _sd_stats_t structure"); return (DCMD_ERR); } mdb_printf("Storage Device Block Cache Statistics\n"); mdb_printf("-------------------------------------\n"); i = _sd_cache_stats->st_blksize; mdb_printf("Blocksize: 0x%x (%d)\n", i, i); mdb_printf("\n"); sdbc_hit_percent(_sd_cache_stats->st_rdhits, _sd_cache_stats->st_rdmiss, "Read"); sdbc_hit_percent(_sd_cache_stats->st_wrhits, _sd_cache_stats->st_wrmiss, "Write"); mdb_printf("%3s %10s %8s %8s %8s %8s %8s %7s %4s %4s %s\n", "Cd", "Dev", "Size", "CacheRd", "CacheWr", "DiskRd", "DiskWr", "DirtyBl", "#IO", "Fail", "F"); for (i = 0; i < maxdevs; i++) { sh = &_sd_cache_stats->st_shared[i]; if (!sh->sh_alloc) continue; fn = strrchr(sh->sh_filename, '/'); fn = fn ? fn+1 : sh->sh_filename; mdb_printf("%3d %10s %7d %8d %8d %8d %8d %7d %4d %4d %d\n", sh->sh_cd, fn, sh->sh_filesize, sh->sh_cache_read, sh->sh_cache_write, sh->sh_disk_read, sh->sh_disk_write, sh->sh_numdirty, sh->sh_numio, sh->sh_numfail, sh->sh_failed); } mdb_free(_sd_cache_stats, statssize); return (DCMD_OK); } /* * display some variables and counters */ static void display_var(char *name, enum vartype type) { uint_t uintval; uintptr_t addrval; kmutex_t lockval; kcondvar_t cvval; switch (type) { case UINTTYPE: if (mdb_readvar(&uintval, name) == -1) { mdb_warn("failed to read %s variable", name); } else mdb_printf("%s =\t%8x %12u\n", name, uintval, uintval); break; case ADDRTYPE: if (mdb_readvar(&addrval, name) == -1) { mdb_warn("failed to read %s variable", name); } else mdb_printf("%s =\t%?-p\n", name, addrval); break; case LOCKTYPE: if (mdb_readvar(&lockval, name) == -1) { mdb_warn("failed to read %s lock variable", name); } else mdb_printf("%s =\t%-p (owner)\n", name, lockval._opaque[0]); break; case CVTYPE: if (mdb_readvar(&cvval, name) == -1) { mdb_warn("failed to read %s condvar variable", name); } else mdb_printf("%s = \t%h-x\n", name, cvval._opaque); break; default: mdb_warn("display_var: unknown type"); } } mdb_bitmask_t dealloc_flag_vals[] = { { "PROCESS_CACHE_DM", (u_longlong_t)~0, PROCESS_CACHE_DM }, { "CACHE_SHUTDOWN_DM", (u_longlong_t)~0, CACHE_SHUTDOWN_DM }, { "CACHE_THREAD_TERMINATED_DM", (u_longlong_t)~0, CACHE_THREAD_TERMINATED_DM }, { "TIME_DELAY_LVL0", (u_longlong_t)~0, TIME_DELAY_LVL0 }, { "TIME_DELAY_LVL1", (u_longlong_t)~0, TIME_DELAY_LVL1 }, { "TIME_DELAY_LVL2", (u_longlong_t)~0, TIME_DELAY_LVL2 }, { NULL, 0, 0 } }; mdb_bitmask_t mdp_bits[] = { { "MONITOR_DYNMEM_PROCESS_DEFAULT", (u_longlong_t)~0, MONITOR_DYNMEM_PROCESS_DEFAULT}, { "RPT_SHUTDOWN_PROCESS_DM", RPT_SHUTDOWN_PROCESS_DM, RPT_SHUTDOWN_PROCESS_DM }, { "RPT_DEALLOC_STATS1_DM", RPT_DEALLOC_STATS1_DM, RPT_DEALLOC_STATS1_DM }, { "RPT_DEALLOC_STATS2_DM", RPT_DEALLOC_STATS2_DM, RPT_DEALLOC_STATS2_DM }, { NULL, 0, 0 } }; mdb_bitmask_t process_directive_bits[] = { { "PROCESS_DIRECTIVE_DEFAULT", (u_longlong_t)~0, PROCESS_DIRECTIVE_DEFAULT }, { "WAKE_DEALLOC_THREAD_DM", WAKE_DEALLOC_THREAD_DM, WAKE_DEALLOC_THREAD_DM }, { "MAX_OUT_ACCEL_HIST_FLAG_DM", MAX_OUT_ACCEL_HIST_FLAG_DM, MAX_OUT_ACCEL_HIST_FLAG_DM}, { NULL, 0, 0 } }; /*ARGSUSED*/ static int sdbc_vars(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { int sd_dealloc_flag_dm; _dm_process_vars_t dynmem_processing_dm; if (argc != 0) return (DCMD_USAGE); mdb_printf("counters and other variables:\n"); mdb_inc_indent(4); display_var("xmem_inval_hit", UINTTYPE); display_var("xmem_inval_miss", UINTTYPE); display_var("xmem_inval_inuse", UINTTYPE); display_var("sdbc_allocb_pageio1", UINTTYPE); display_var("sdbc_allocb_pageio2", UINTTYPE); display_var("sdbc_allocb_inuse", UINTTYPE); display_var("sdbc_allocb_hit", UINTTYPE); display_var("sdbc_allocb_lost", UINTTYPE); display_var("sdbc_pageio_always", UINTTYPE); display_var("sdbc_do_page", UINTTYPE); display_var("sdbc_flush_pageio", UINTTYPE); display_var("sdbc_centry_hit", UINTTYPE); display_var("sdbc_centry_inuse", UINTTYPE); display_var("sdbc_centry_lost", UINTTYPE); display_var("sdbc_centry_deallocd", UINTTYPE); display_var("_sd_prefetch_opt", UINTTYPE); display_var("sdbc_ra_hash", UINTTYPE); display_var("sdbc_ra_none", UINTTYPE); display_var("sdbc_static_cache", UINTTYPE); display_var("sdbc_use_dmchain", UINTTYPE); /* in no particular order ... */ display_var("sdbc_check_cot", UINTTYPE); display_var("_sd_cctl_groupsz", UINTTYPE); display_var("CBLOCKS", UINTTYPE); display_var("_SD_SELF_HOST", UINTTYPE); display_var("_SD_MIRROR_HOST", UINTTYPE); display_var("sdbc_bio_count", UINTTYPE); display_var("_sd_cblock_shift", UINTTYPE); display_var("_sd_nodes_configured", UINTTYPE); display_var("nv_alloc_factor", UINTTYPE); display_var("_sd_ft_exit", UINTTYPE); display_var("_sd_flush_exit", UINTTYPE); display_var("_sd_node_recovery", UINTTYPE); display_var("_sd_async_recovery", UINTTYPE); display_var("_sdbc_ft_hold_io", UINTTYPE); display_var("mirror_clean_shutdown", UINTTYPE); display_var("_sd_ft_warm_start", UINTTYPE); mdb_dec_indent(4); mdb_printf("\n"); /* some addresses of various lists and tables */ mdb_printf("Addresses:\n"); mdb_inc_indent(4); display_var("_sd_htable", ADDRTYPE); display_var("_sdbc_gl_centry_info", ADDRTYPE); display_var("_sdbc_gl_centry_info_nvmem", ADDRTYPE); display_var("_sdbc_gl_centry_info_size", ADDRTYPE); /* size_t */ display_var("_sdbc_gl_file_info", ADDRTYPE); display_var("_sdbc_gl_file_info_size", ADDRTYPE); /* size_t */ mdb_dec_indent(4); mdb_printf("\n"); /* dynamic memory variables */ mdb_printf("Dynamic Memory variables and stats:\n"); mdb_inc_indent(4); display_var("_sdbc_memtype_deconfigure_delayed", UINTTYPE); if (mdb_readvar(&sd_dealloc_flag_dm, "sd_dealloc_flag_dm") == -1) { mdb_warn("failed to read sd_dealloc_flag_dm symbol"); } else mdb_printf("sd_dealloc_flag_dm %08x <%b>\n", sd_dealloc_flag_dm, sd_dealloc_flag_dm, dealloc_flag_vals); if (mdb_readvar(&dynmem_processing_dm, "dynmem_processing_dm") == -1) { mdb_warn("failed to read dynmem_processing_dm structure"); } else { _dm_process_vars_t *dp; dp = &dynmem_processing_dm; mdb_printf( "thread_dm_cv %h-x thread_dm_lock %?-p (owner)\n", dp->thread_dm_cv._opaque, dp->thread_dm_lock._opaque[0]); mdb_printf("sd_dealloc_flagx %x %8Tmax_dyn_list %3-d\n", dp->sd_dealloc_flagx, dp->max_dyn_list); mdb_printf("monitor_dynmem_process <%b>\n", dp->monitor_dynmem_process, mdp_bits); mdb_printf( "cache_aging_ct1 %3-d %8Tcache_aging_ct2 %3-d cache_aging_ct3 %3-d\n", dp->cache_aging_ct1, dp->cache_aging_ct2, dp->cache_aging_ct3); mdb_printf( "cache_aging_sec1 %3-d %8Tcache_aging_sec2 %3-d" " cache_aging_sec3 %3-d\n", dp->cache_aging_sec1, dp->cache_aging_sec2, dp->cache_aging_sec3); mdb_printf("cache_aging_pcnt1 %3-d %8Tcache_aging_pcnt2 %3-d\n", dp->cache_aging_pcnt1, dp->cache_aging_pcnt2); mdb_printf( "max_holds_pcnt %3-d %8Talloc_ct %8-d dealloc_ct %8-d\n", dp->max_holds_pcnt, dp->alloc_ct, dp->dealloc_ct); mdb_printf( "history %4x %8Tnodatas %8-d notavail %8-d candidates %8-d\n", dp->history, dp->nodatas, dp->notavail, dp->candidates); mdb_printf( "deallocs %8-d %8Thosts %8-d pests %8-d metas %8-d\n", dp->deallocs, dp->hosts, dp->pests, dp->metas); mdb_printf("holds %8-d %8Tothers %8-d\n", dp->holds, dp->others); mdb_printf("process_directive <%b>\n", dp->process_directive, process_directive_bits); mdb_printf("read_hits %8-d %8Tread_misses %8-d\n", dp->read_hits, dp->read_misses); mdb_printf( "write_thru %8-d %8Twrite_hits %8-d write_misses %8-d\n", dp->write_hits, dp->write_misses, dp->write_thru); mdb_printf("prefetch_hits %8-d prefetch_misses %8-d\n", dp->prefetch_hits, dp->prefetch_misses); } mdb_dec_indent(4); mdb_printf("\n"); /* some locks and condition variables */ mdb_printf("Locks:\n"); mdb_inc_indent(4); display_var("mutex_and_condvar_flag", UINTTYPE); display_var("_sd_cache_lock", LOCKTYPE); display_var("_sd_block_lk", LOCKTYPE); display_var("_sdbc_config_lock", LOCKTYPE); display_var("_sdbc_ft_hold_io_lk", LOCKTYPE); display_var("_sd_flush_cv", CVTYPE); display_var("_sdbc_ft_hold_io_cv", CVTYPE); mdb_dec_indent(4); mdb_printf("\n"); return (DCMD_OK); } const mdb_bitmask_t nsc_buf_bits[] = { {"HALLOCATED", NSC_HALLOCATED, NSC_HALLOCATED}, {"HACTIVE", NSC_HACTIVE, NSC_HACTIVE}, {"RDBUF", NSC_RDBUF, NSC_RDBUF}, {"WRBUF", NSC_WRBUF, NSC_WRBUF}, {"NOBLOCK", NSC_NOBLOCK, NSC_NOBLOCK}, {"WRTHRU", NSC_WRTHRU, NSC_WRTHRU}, {"NOCACHE", NSC_NOCACHE, NSC_NOCACHE}, {"BCOPY", NSC_BCOPY, NSC_BCOPY}, {"PAGEIO", NSC_PAGEIO, NSC_PAGEIO}, {"PINNABLE", NSC_PINNABLE, NSC_PINNABLE}, {"FORCED_WRTHRU", NSC_FORCED_WRTHRU, NSC_FORCED_WRTHRU}, {"METADATA", NSC_METADATA, NSC_METADATA}, {"MIXED", NSC_MIXED, NSC_MIXED}, {NULL, 0, 0} }; /* * HELP functions for cache ctl type dcmds */ static void cctl_help_common(char *name) { mdb_inc_indent(4); mdb_printf("-c cd displays cctls for cache descriptor 'cd'\n"); mdb_dec_indent(4); mdb_printf("inclusive filters:\n"); mdb_inc_indent(4); mdb_printf("-b blk displays cctls for cache block number 'blk'\n"); mdb_printf("-d displays cctls with dirty bits\n"); mdb_printf("-h displays cctls that are hashed\n"); mdb_printf("-i displays cctls that are inuse\n"); mdb_printf("-o displays cctls that have I/O in progress\n"); mdb_printf("-p displays cctls that have pagio set\n"); mdb_printf("-B displays cctls that are marked BAD\n"); mdb_printf("-H displays cctls that are HOSTS\n"); mdb_printf("-P displays cctls that are PARASITES\n"); mdb_printf("-R displays cctls that are explicit (NSC_RDAHEAD) " "Prefetch bufs\n"); mdb_printf("-r displays cctls that are implicit Prefetch bufs\n"); mdb_printf("-V displays cctls that have valid bits set\n"); mdb_printf("-v verbose\n"); mdb_dec_indent(4); mdb_printf("Default: %s displays all cctls in the list\n", name); mdb_printf("\n"); mdb_printf("Example:\n"); mdb_inc_indent(4); mdb_printf("%s -io -c 5 displays all cctls for cd 5 that are\n" "in use or have I/O in progress\n", name); mdb_dec_indent(4); } #define CCTL_OPTIONSTRING "[-vdhiopBHPV][-c cd][-b blknum]" void cctl_help() { mdb_printf("sdbc_cctl displays cache ctl structures\n"); mdb_printf("Usage: [address]::sdbc_cctl " CCTL_OPTIONSTRING "\n"); cctl_help_common("sdbc_cctl"); } void cchain_help() { mdb_printf("sdbc_cchain displays cache ctl structures in a" " (alloc) cc_chain\n"); mdb_printf("Usage: address::sdbc_cchain " CCTL_OPTIONSTRING "\n"); cctl_help_common("sdbc_cchain"); } void dchain_help() { mdb_printf("sdbc_dchain displays cache ctl structures in a" " dirty chain\n"); mdb_printf("Usage: address::sdbc_dchain " CCTL_OPTIONSTRING "\n"); cctl_help_common("sdbc_dchain"); } void dmchain_help() { mdb_printf("sdbc_dmchain displays cache ctl structures in a" " dynamic memory allocation chain\n"); mdb_printf("order of display is:\n" "the cctl represented by the given address,\n" "the cc_head_dm cctl,\n" "the chain starting at cc_next_dm of the head cctl\n"); mdb_printf("Usage: address::sdbc_dmchain " CCTL_OPTIONSTRING "\n"); cctl_help_common("sdbc_dmchain"); } void hashchain_help() { mdb_printf("sdbc_hashchain displays cache ctl structures in a" " hash chain\n"); mdb_printf("Usage: address::sdbc_hashchain " CCTL_OPTIONSTRING "\n"); cctl_help_common("sdbc_hashchain"); } void hashtable_help() { mdb_printf("sdbc_hashtable displays the hash table and its chains\n"); mdb_printf("Usage: address::sdbc_hashtable " CCTL_OPTIONSTRING "\n"); cctl_help_common("sdbc_hashtable"); } void lru_help() { mdb_printf("sdbc_lru displays cache ctl structures in the LRU queue\n"); mdb_printf("Usage: [address]::sdbc_lru " CCTL_OPTIONSTRING "\n"); cctl_help_common("sdbc_lru"); } /* * help functions for write ctl dcmds */ void wctl_help_common(char *name) { mdb_inc_indent(4); mdb_printf("-v verbose\n"); mdb_printf("-c cd show ctl structs for cache descriptor 'cd'\n"); mdb_printf("-d show ctl structs that have dirty bits set\n"); mdb_dec_indent(4); mdb_printf("Default: %s displays all write ctl in the list\n", name); } void wctl_help() { mdb_printf( "sdbc_wctl displays the allocated array of write ctl structures\n"); mdb_printf("Usage: [address]::sdbc_wctl [-vd][-c cd]\n"); wctl_help_common("sdbc_wctl"); } void wrq_help() { mdb_printf("sdbc_wrq displays the write ctl queue (wctl free list)\n"); mdb_printf("Usage: [address]::sdbc_wrq [-vd][-c cd]\n"); wctl_help_common("sdbc_wrq"); } /* help function for the sdbc_cdinfo dcmd */ void cdinfo_help() { mdb_printf( "sdbc_cdinfo displays cd information from the _sd_cache_files table\n"); mdb_printf("Usage: [address]::sdbc_cdfinfo [-av][-c cd]\n"); mdb_inc_indent(4); mdb_printf("-a displays info for all cd_info structures\n"); mdb_printf("-c cd displays info for cache descriptor 'cd'\n"); mdb_printf("-v verbose\n"); mdb_dec_indent(4); mdb_printf("Default: display info for cd's that are allocated\n"); } void ftctl_help() { mdb_printf( "sdbc_ftctl displays the array of fault tolerant structures \n"); mdb_printf("Usage: [address]::sdbc_ftctl [-vd][-c cd]\n"); wctl_help_common("sdbc_ftctl"); } /* * help function for the sdbc_handles dcmd */ void handle_help() { mdb_printf("sdbc_handles displays active or allocated" " cache buffer handles\n"); mdb_printf("Usage: [address]::sdbc_handles [-avC][-c cd]\n"); mdb_inc_indent(4); mdb_printf("-a displays all handles\n"); mdb_printf("-c n displays handle for cd n\n"); mdb_printf("-v displays detailed handle data\n"); mdb_printf("-C displays the handle cc_chain\n"); mdb_dec_indent(4); mdb_printf("Default: display only allocated or active handles\n"); } /* * help functions for the "global" memory dcmds */ void glcinfo_help() { mdb_printf("sdbc_glcinfo displays the global cache entry info\n"); mdb_printf("Usage: [address]::sdbc_glcinfo [-adC][-c cd][-b fbapos]\n"); mdb_inc_indent(4); mdb_printf("-a displays all global info structs\n"); mdb_printf("-b fbapos displays structs that match FBA block" "(not cache block) 'fbapos'\n"); mdb_printf("-c cd displays structs that match cache descriptor 'cd'\n"); mdb_printf("-d displays structs with dirty bits set\n"); mdb_printf("-C does consistency check against nvram copy\n"); mdb_dec_indent(4); mdb_printf("Default: display entries with a valid cd\n"); } void glfinfo_help() { mdb_printf("sdbc_glfinfo displays the global file info\n"); mdb_printf("Usage: [address]::sdbc_glfinfo [-aptC]\n"); mdb_inc_indent(4); mdb_printf("-a displays all global info structs\n"); mdb_printf("-p displays structs for pinned volumes\n"); mdb_printf("-t displays structs for attached volumes\n"); mdb_printf("-C does consistency check against nvram copy\n"); mdb_dec_indent(4); mdb_printf("Default: display entries with non-null filename\n"); } /* * WALKERS */ /* * walker for the cctl list using the cc_link_list_dm pointers */ static int sdbc_cctl_winit(mdb_walk_state_t *wsp) { _sd_cctl_t *_sd_cctl[_SD_CCTL_GROUPS]; /* for getting first entry */ struct walk_info *winfo; winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP); if (wsp->walk_addr == NULL) { /* * we get the "first" cctl from memory and then traverse * the cc_link_list_dm pointers. * this traversal could start from any cctl. here we start with * the first cctl in the _sd_cctl[] array. */ if (mdb_readvar(_sd_cctl, "_sd_cctl") == -1) { mdb_warn("failed to read _sd_cctl array"); return (DCMD_ERR); } wsp->walk_addr = (uintptr_t)_sd_cctl[0]; } winfo->w_start = 0; winfo->w_end = wsp->walk_addr; wsp->walk_data = winfo; return (WALK_NEXT); } static int sdbc_cctl_wstep(mdb_walk_state_t *wsp) { struct walk_info *winfo = wsp->walk_data; _sd_cctl_t centry; int status; if (wsp->walk_addr == NULL) /* should not happen */ return (WALK_DONE); /* * w_start is 0 on the first iteration so the test * will fail, allowing the first centry to be processed */ if (wsp->walk_addr == winfo->w_start) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); if (mdb_vread(¢ry, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) { mdb_warn("failed to read centry at %p", wsp->walk_addr); return (WALK_ERR); } wsp->walk_addr = (uintptr_t)(centry.cc_link_list_dm); /* set termination condition. only needs to be done once */ winfo->w_start = winfo->w_end; return (status); } static void sdbc_cctl_wfini(mdb_walk_state_t *wsp) { mdb_free(wsp->walk_data, sizeof (struct walk_info)); } /* * walk the cc_chain list of a _sd_cctl_t * no global walks -- must be called with an address */ static int sdbc_cchain_winit(mdb_walk_state_t *wsp) { if (wsp->walk_addr == NULL) return (WALK_ERR); wsp->walk_data = mdb_zalloc(sizeof (_sd_cctl_t), UM_SLEEP); return (WALK_NEXT); } static int sdbc_cchain_wstep(mdb_walk_state_t *wsp) { int status; if (wsp->walk_addr == NULL) return (WALK_DONE); if (mdb_vread(wsp->walk_data, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) { mdb_warn("sdbc_cchain_wstep failed to read centry at %p", wsp->walk_addr); return (WALK_ERR); } status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); wsp->walk_addr = (uintptr_t)(((_sd_cctl_t *) (wsp->walk_data))->cc_chain); return (status); } static void sdbc_cchain_wfini(mdb_walk_state_t *wsp) { mdb_free(wsp->walk_data, sizeof (_sd_cctl_t)); } /* * walk the dirty chain list of a _sd_cctl_t * no global walks -- must be called with an address */ static int sdbc_dchain_winit(mdb_walk_state_t *wsp) { if (wsp->walk_addr == NULL) return (WALK_ERR); wsp->walk_data = mdb_zalloc(sizeof (_sd_cctl_t), UM_SLEEP); /* walk data stores the first and subsequent cc_dirty_link */ if (mdb_vread(wsp->walk_data, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) { mdb_warn("sdbc_dchain_winit failed to read centry at %p", wsp->walk_addr); return (WALK_ERR); } return (WALK_NEXT); } static int sdbc_dchain_wstep(mdb_walk_state_t *wsp) { _sd_cctl_t centry; int status; if (wsp->walk_addr == NULL) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); if (mdb_vread(¢ry, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) { mdb_warn("sdbc_dchain_wstep failed to read centry at %p", wsp->walk_addr); return (WALK_ERR); } wsp->walk_addr = (uintptr_t)(centry.cc_dirty_next); /* end of dirty_next chain? start on subsequent dirty_link */ if (wsp->walk_addr == NULL) { wsp->walk_addr = (uintptr_t)(((_sd_cctl_t *)(wsp->walk_data))->cc_dirty_link); /* update dirty link */ /* walk data stores the first and subsequent cc_dirty_link */ if (wsp->walk_addr) { if (mdb_vread(wsp->walk_data, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) { mdb_warn( "sdbc_dchain_wstep failed to read centry at %p", wsp->walk_addr); return (WALK_ERR); } } } return (status); } static void sdbc_dchain_wfini(mdb_walk_state_t *wsp) { mdb_free(wsp->walk_data, sizeof (_sd_cctl_t)); } /* for stepping thru the dynmem chain */ #define GET_HEAD_DM 0x1 #define GET_NEXT_DM 0x2 /* * walk the dm chain of a cctl * start with current address, then cc_head_dm, then the cc_next_dm chain */ static int sdbc_dmchain_winit(mdb_walk_state_t *wsp) { if (wsp->walk_addr == NULL) return (WALK_ERR); wsp->walk_data = (void *)GET_HEAD_DM; return (WALK_NEXT); } static int sdbc_dmchain_wstep(mdb_walk_state_t *wsp) { _sd_cctl_t centry; int status; if (wsp->walk_addr == NULL) return (WALK_DONE); if (mdb_vread(¢ry, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) { mdb_warn("sdbc_dmchain_wstep failed to read centry at %p", wsp->walk_addr); return (WALK_ERR); } status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); if (wsp->walk_data == (void *)GET_HEAD_DM) { wsp->walk_addr = (uintptr_t)centry.cc_head_dm; wsp->walk_data = (void *)GET_NEXT_DM; } else wsp->walk_addr = (uintptr_t)centry.cc_next_dm; return (status); } /*ARGSUSED*/ static void sdbc_dmchain_wfini(mdb_walk_state_t *wsp) { } /* * walk a hash chain * requires an address */ /*ARGSUSED*/ static int sdbc_hashchain_winit(mdb_walk_state_t *wsp) { if (wsp->walk_addr == NULL) return (WALK_ERR); return (WALK_NEXT); } static int sdbc_hashchain_wstep(mdb_walk_state_t *wsp) { int status; _sd_hash_hd_t hash_entry; if (wsp->walk_addr == NULL) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); if (mdb_vread(&hash_entry, sizeof (_sd_hash_hd_t), wsp->walk_addr) == -1) { mdb_warn( "sdbc_hashchain_wstep failed to read hash_entry at %p", wsp->walk_addr); return (WALK_ERR); /* will upper layer continue ? */ } wsp->walk_addr = (uintptr_t)hash_entry.hh_next; return (status); } /*ARGSUSED*/ static void sdbc_hashchain_wfini(mdb_walk_state_t *wsp) { } /* * walk the sdbc lru list */ static int sdbc_lru_winit(mdb_walk_state_t *wsp) { struct walk_info *winfo; GElf_Sym sym; winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP); /* if called without an address, start at the head of the queue */ if (wsp->walk_addr == NULL) { if (mdb_lookup_by_obj("sdbc", "_sd_lru_q", &sym) == -1) { mdb_warn("failed to lookup _sd_lru_q symbol"); return (WALK_ERR); } /* &(_sd_lru_q.sq_qhead) */ wsp->walk_addr = (uintptr_t)(sym.st_value); } winfo->w_start = 0; winfo->w_end = wsp->walk_addr; wsp->walk_data = winfo; return (WALK_NEXT); } static int sdbc_lru_wstep(mdb_walk_state_t *wsp) { struct walk_info *winfo = wsp->walk_data; _sd_cctl_t centry; int status; if (wsp->walk_addr == NULL) /* should not happen */ return (WALK_DONE); /* * w_start is 0 on the first iteration so the test * will fail, allowing the first centry to be processed */ if (wsp->walk_addr == winfo->w_start) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); if (mdb_vread(¢ry, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) { mdb_warn("failed to read centry at %p", wsp->walk_addr); return (WALK_ERR); } wsp->walk_addr = (uintptr_t)(centry.cc_next); /* set termination condition. only needs to be done once */ winfo->w_start = winfo->w_end; return (status); } static void sdbc_lru_wfini(mdb_walk_state_t *wsp) { mdb_free(wsp->walk_data, sizeof (struct walk_info)); } #ifdef SAFESTORE /* * walk the array of allocated write control structures */ static int sdbc_wctl_winit(mdb_walk_state_t *wsp) { _sd_net_t _sd_net_config; _sd_writeq_t wrq; struct walk_info *winfo; int blk_shft; int count; winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP); /* need to calculate the end of the array */ if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) { mdb_warn("failed to read _sd_net_config structure"); return (WALK_ERR); } if (wsp->walk_addr == NULL) wsp->walk_addr = (uintptr_t)(_sd_net_config.sn_wr_cctl); /* * this module assumes 8k block size so this code can * be commented out if necessary. */ if (mdb_readvar(&blk_shft, "_sd_cblock_shift") == -1) { mdb_warn("failed to read _sd_cblock_shift." "assuming 8k cache block size"); blk_shft = 13; } count = (_sd_net_config.sn_wpages * _sd_net_config.sn_psize) / (1 << blk_shft); winfo->w_end = (uintptr_t)(_sd_net_config.sn_wr_cctl + count); wsp->walk_data = winfo; return (WALK_NEXT); } static int sdbc_wctl_wstep(mdb_walk_state_t *wsp) { struct walk_info *winfo = wsp->walk_data; int status; if (wsp->walk_addr == NULL) return (WALK_DONE); if (wsp->walk_addr >= winfo->w_end) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); wsp->walk_addr += sizeof (_sd_wr_cctl_t); return (status); } static void sdbc_wctl_wfini(mdb_walk_state_t *wsp) { mdb_free(wsp->walk_data, sizeof (struct walk_info)); } /* * walk the queue (free list) of write control structures */ static int sdbc_wrq_winit(mdb_walk_state_t *wsp) { _sd_net_t _sd_net_config; _sd_writeq_t wrq; /* if called without an address, start at the head of the queue */ if (wsp->walk_addr == NULL) { if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) { mdb_warn("failed to read _sd_net_config structure"); return (WALK_ERR); } wsp->walk_addr = (uintptr_t) (_sd_net_config.sn_wr_queue.wq_qtop); } return (WALK_NEXT); } static int sdbc_wrq_wstep(mdb_walk_state_t *wsp) { _sd_wr_cctl_t wctl; int status; if (wsp->walk_addr == NULL) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); if (mdb_vread(&wctl, sizeof (_sd_wr_cctl_t), wsp->walk_addr) == -1) { mdb_warn("sdbc_cchain_wstep failed to read wctl at %p", wsp->walk_addr); return (WALK_ERR); } /* special case -- mini-DSP fake wr_cctl */ if (wsp->walk_addr == (uintptr_t)wctl.wc_next) return (WALK_DONE); wsp->walk_addr = (uintptr_t)(wctl.wc_next); return (WALK_NEXT); } static void sdbc_wrq_wfini(mdb_walk_state_t *wsp) { } #endif /* SAFESTORE */ /* * walk the _sd_cache_files array of cd_info structures */ static int sdbc_cdinfo_winit(mdb_walk_state_t *wsp) { struct walk_info *winfo; _sd_cd_info_t *_sd_cache_files_addr; int maxdevs; winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP); /* get the address of the cdinfo table */ if (mdb_readvar(&_sd_cache_files_addr, "_sd_cache_files") == -1) { mdb_warn("failed to read _sd_cache_files address\n"); return (WALK_ERR); } /* if called without an address, start at the head of the queue */ if (wsp->walk_addr == NULL) { /* address of first _sd_cd_info_t */ wsp->walk_addr = (uintptr_t)(_sd_cache_files_addr); } /* get the number of volumes */ if (mdb_readvar(&maxdevs, "sdbc_max_devs") == -1) { mdb_warn("failed to read sdbc_max_devs"); return (WALK_ERR); } winfo->w_end = (uintptr_t)(_sd_cache_files_addr + maxdevs); wsp->walk_data = winfo; return (WALK_NEXT); } static int sdbc_cdinfo_wstep(mdb_walk_state_t *wsp) { struct walk_info *winfo = wsp->walk_data; int status; if (wsp->walk_addr >= winfo->w_end) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); wsp->walk_addr += sizeof (_sd_cd_info_t); return (status); } static void sdbc_cdinfo_wfini(mdb_walk_state_t *wsp) { mdb_free(wsp->walk_data, sizeof (struct walk_info)); } #ifdef SAFESTORE /* * walk the array of allocated fault tolerant control structures */ static int sdbc_ftctl_winit(mdb_walk_state_t *wsp) { _sd_net_t _sd_net_config; struct walk_info *winfo; int blk_shft = 13; /* 8k default */ int count; winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP); /* need to calculate the end of the array */ if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) { mdb_warn("failed to read _sd_net_config structure"); return (WALK_ERR); } if (wsp->walk_addr == NULL) wsp->walk_addr = (uintptr_t)(_sd_net_config.sn_ft_cctl); /* * this module assumes 8k block size so this code can * be commented out if necessary. */ if (mdb_readvar(&blk_shft, "_sd_cblock_shift") == -1) { mdb_warn("failed to read _sd_cblock_shift." "assuming 8k cache block size"); blk_shft = 13; } count = (_sd_net_config.sn_wpages * _sd_net_config.sn_psize) / (1 << blk_shft); winfo->w_end = (uintptr_t)(_sd_net_config.sn_ft_cctl + count); wsp->walk_data = winfo; return (WALK_NEXT); } static int sdbc_ftctl_wstep(mdb_walk_state_t *wsp) { struct walk_info *winfo = wsp->walk_data; int status; if (wsp->walk_addr == NULL) return (WALK_DONE); if (wsp->walk_addr >= winfo->w_end) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); wsp->walk_addr += sizeof (_sd_ft_cctl_t); return (status); } static void sdbc_ftctl_wfini(mdb_walk_state_t *wsp) { mdb_free(wsp->walk_data, sizeof (struct walk_info)); } #endif /* SAFESTORE */ /* * walk the handle list */ static int sdbc_handle_winit(mdb_walk_state_t *wsp) { _sd_buf_hlist_t hl; struct walk_info *winfo; GElf_Sym sym; if (mdb_readvar(&hl, "_sd_handle_list") == -1) { mdb_warn("failed to read _sd_handle_list structure"); return (WALK_ERR); } if (mdb_lookup_by_obj("sdbc", "_sd_handle_list", &sym) == -1) { mdb_warn("failed to lookup _sd_handle_list symbol"); return (WALK_ERR); } /* if called without an address, start at first element in list */ if (wsp->walk_addr == NULL) wsp->walk_addr = (uintptr_t)(hl.hl_top.bh_next); winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP); winfo->w_end = (uintptr_t)(sym.st_value); /* &_sd_handle_list.hl_top */ wsp->walk_data = winfo; return (WALK_NEXT); } static int sdbc_handle_wstep(mdb_walk_state_t *wsp) { struct walk_info *winfo = wsp->walk_data; _sd_buf_handle_t handle; int status; if (wsp->walk_addr == NULL) return (WALK_DONE); if (wsp->walk_addr == winfo->w_end) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); if (mdb_vread(&handle, sizeof (_sd_buf_handle_t), wsp->walk_addr) == -1) { mdb_warn("failed to read handle at %p", wsp->walk_addr); return (WALK_ERR); } wsp->walk_addr = (uintptr_t)(handle.bh_next); return (status); } static void sdbc_handle_wfini(mdb_walk_state_t *wsp) { mdb_free(wsp->walk_data, sizeof (struct walk_info)); } /* * walk the global info array (dirty bits) */ static int sdbc_glcinfo_winit(mdb_walk_state_t *wsp) { ss_centry_info_t *gl_centry_info; size_t gl_centry_info_size; struct walk_info *winfo; winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP); /* get start of the cache entry metadata */ if (mdb_readvar(&gl_centry_info, "_sdbc_gl_centry_info") == -1) { mdb_warn("failed to read _sdbc_gl_centry_info"); return (WALK_ERR); } /* need to calculate the end of the array */ if (mdb_readvar(&gl_centry_info_size, "_sdbc_gl_centry_info_size") == -1) { mdb_warn("failed to read _sdbc_gl_centry_info_size"); return (WALK_ERR); } if (wsp->walk_addr == NULL) wsp->walk_addr = (uintptr_t)(gl_centry_info); winfo->w_end = ((uintptr_t)(gl_centry_info)) + gl_centry_info_size; wsp->walk_data = winfo; return (WALK_NEXT); } static int sdbc_glcinfo_wstep(mdb_walk_state_t *wsp) { struct walk_info *winfo = wsp->walk_data; int status; if (wsp->walk_addr == NULL) return (WALK_DONE); if (wsp->walk_addr >= winfo->w_end) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); wsp->walk_addr += sizeof (ss_centry_info_t); return (status); } static void sdbc_glcinfo_wfini(mdb_walk_state_t *wsp) { mdb_free(wsp->walk_data, sizeof (struct walk_info)); } /* * walk the global file info array */ static int sdbc_glfinfo_winit(mdb_walk_state_t *wsp) { ss_voldata_t *gl_file_info; struct walk_info *winfo; int maxdevs; winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP); /* get start of the cache entry metadata */ if (mdb_readvar(&gl_file_info, "_sdbc_gl_file_info") == -1) { mdb_warn("failed to read _sdbc_gl_file_info"); return (WALK_ERR); } if (wsp->walk_addr == NULL) wsp->walk_addr = (uintptr_t)(gl_file_info); /* get the number of volumes */ if (mdb_readvar(&maxdevs, "sdbc_max_devs") == -1) { mdb_warn("failed to read sdbc_max_devs"); return (WALK_ERR); } /* end of the array */ winfo->w_end = (uintptr_t)((gl_file_info) + maxdevs); wsp->walk_data = winfo; return (WALK_NEXT); } static int sdbc_glfinfo_wstep(mdb_walk_state_t *wsp) { struct walk_info *winfo = wsp->walk_data; int status; if (wsp->walk_addr == NULL) return (WALK_DONE); if (wsp->walk_addr >= winfo->w_end) return (WALK_DONE); status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data, wsp->walk_cbdata); wsp->walk_addr += sizeof (ss_voldata_t); return (status); } static void sdbc_glfinfo_wfini(mdb_walk_state_t *wsp) { mdb_free(wsp->walk_data, sizeof (struct walk_info)); } /* end of WALKERS section */ const mdb_bitmask_t cc_flag_bits[] = { {"PEND_DIRTY", CC_PEND_DIRTY, CC_PEND_DIRTY}, {"PINNED", CC_PINNED, CC_PINNED}, {"PINNABLE", CC_PINNABLE, CC_PINNABLE}, {"QHEAD", CC_QHEAD, CC_QHEAD}, {NULL, 0, 0} }; const mdb_bitmask_t io_status_bits[] = { {"IO_NONE", 0xff, _SD_IO_NONE}, {"IO_INITIATE", 0xff, _SD_IO_INITIATE}, {"IO_DONE", 0xff, _SD_IO_DONE}, {"IO_FAILED", 0xff, _SD_IO_FAILED}, {"IO_DISCARDED", 0xff, _SD_IO_DISCARDED}, {NULL, 0, 0} }; const mdb_bitmask_t cc_aging_bits[] = { {"FOUND_IN_HASH", FOUND_IN_HASH_DM, FOUND_IN_HASH_DM}, {"FOUND_HOLD_OVER", FOUND_HOLD_OVER_DM, FOUND_HOLD_OVER_DM}, {"HOST_ENTRY", HOST_ENTRY_DM, HOST_ENTRY_DM}, {"PARASITIC_ENTRY", PARASITIC_ENTRY_DM, PARASITIC_ENTRY_DM}, {"STICKY_METADATA", STICKY_METADATA_DM, STICKY_METADATA_DM}, {"ELIGIBLE_ENTRY", ELIGIBLE_ENTRY_DM, ELIGIBLE_ENTRY_DM}, {"HASH_ENTRY", HASH_ENTRY_DM, HASH_ENTRY_DM}, {"HOLD_ENTRY", HOLD_ENTRY_DM, HOLD_ENTRY_DM}, {"AVAIL_ENTRY", AVAIL_ENTRY_DM, AVAIL_ENTRY_DM}, {"BAD_CHAIN", BAD_CHAIN_DM, BAD_CHAIN_DM}, {"BAD_ENTRY", BAD_ENTRY_DM, BAD_ENTRY_DM}, {"PREFETCH_I", PREFETCH_BUF_I, PREFETCH_BUF_I}, {"PREFETCH_E", PREFETCH_BUF_E, PREFETCH_BUF_E}, {NULL, 0, 0} }; /* DCMDS that use walkers */ /* * dcmd to display cache entry control structures */ static int sdbc_cctl(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { uint_t opt_a = FALSE; uintptr_t opt_c = MDB_CD; /* cd */ uintptr_t opt_b = MDB_BLKNUM; /* block num */ uint_t opt_B = FALSE; /* BAD CHAIN or ENTRY */ uint_t opt_d = FALSE; /* dirty */ uint_t opt_H = FALSE; /* HOST */ uint_t opt_h = FALSE; /* hashed */ uint_t opt_i = FALSE; /* inuse */ uint_t opt_p = FALSE; /* pageio */ uint_t opt_P = FALSE; /* PARASITE */ uint_t opt_R = FALSE; /* explicit read-ahead (prefetch) */ uint_t opt_r = FALSE; /* implicit read-ahead (prefetch) */ uint_t opt_o = FALSE; /* io in progress */ uint_t opt_m = FALSE; /* has memory allocated */ uint_t opt_V = FALSE; /* valid bits */ uint_t opt_v = FALSE; /* verbose */ uint_t nofilter = FALSE; /* true if b, d, h, i, o, p, V are all false */ _sd_cctl_t centry; _sd_cctl_sync_t cc_sync; /* * possible enhancements -- option to filter on flag bits * option that toggles other options. */ if (mdb_getopts(argc, argv, 'a', MDB_OPT_SETBITS, TRUE, &opt_a, 'B', MDB_OPT_SETBITS, TRUE, &opt_B, 'b', MDB_OPT_UINTPTR, &opt_b, 'c', MDB_OPT_UINTPTR, &opt_c, 'd', MDB_OPT_SETBITS, TRUE, &opt_d, 'H', MDB_OPT_SETBITS, TRUE, &opt_H, 'h', MDB_OPT_SETBITS, TRUE, &opt_h, 'i', MDB_OPT_SETBITS, TRUE, &opt_i, 'o', MDB_OPT_SETBITS, TRUE, &opt_o, 'm', MDB_OPT_SETBITS, TRUE, &opt_m, 'P', MDB_OPT_SETBITS, TRUE, &opt_P, 'p', MDB_OPT_SETBITS, TRUE, &opt_p, 'R', MDB_OPT_SETBITS, TRUE, &opt_R, 'r', MDB_OPT_SETBITS, TRUE, &opt_r, 'V', MDB_OPT_SETBITS, TRUE, &opt_V, 'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc) return (DCMD_USAGE); nofilter = (!OPT_B_SELECTED && !opt_d && !opt_h && !opt_i && !opt_o && !opt_m && !opt_p && !opt_V && !opt_B && !opt_P && !opt_H && !opt_R && !opt_r); /* no options */ if (!(flags & DCMD_ADDRSPEC)) { if (mdb_walk_dcmd("sdbc`sdbc_cctl", "sdbc`sdbc_cctl", argc, argv) == -1) { mdb_warn("failed to walk 'cctl' list"); return (DCMD_ERR); } return (DCMD_OK); } if (DCMD_HDRSPEC(flags)) { mdb_printf("sdbc cache ctl structures:\n"); } if (mdb_vread(¢ry, sizeof (_sd_cctl_t), addr) == -1) { mdb_warn("dcmd failed to read centry at %p", addr); return (DCMD_ERR); } /* filter exclusively on a cd number if specified */ if (OPT_C_SELECTED && (centry.cc_head.hh_cd != opt_c)) return (DCMD_OK); /* all other filters are inclusive */ if ((nofilter) || (OPT_B_SELECTED && (centry.cc_head.hh_blk_num == opt_b)) || (opt_B && (centry.cc_aging_dm & (BAD_ENTRY_DM | BAD_CHAIN_DM))) || (opt_d && (centry.cc_dirty)) || (opt_H && (centry.cc_aging_dm & HOST_ENTRY_DM)) || (opt_h && (centry.cc_head.hh_hashed)) || (opt_i && (centry.cc_inuse)) || (opt_p && (centry.cc_pageio)) || (opt_P && (centry.cc_aging_dm & PARASITIC_ENTRY_DM)) || (opt_R && (centry.cc_aging_dm & PREFETCH_BUF_E)) || (opt_r && (centry.cc_aging_dm & PREFETCH_BUF_I)) || (opt_V && (centry.cc_valid)) || (opt_m && (centry.cc_alloc_size_dm)) || (opt_o && (centry.cc_iostatus != _SD_IO_NONE))) /*EMPTY*/; else return (DCMD_OK); mdb_inc_indent(4); mdb_printf( "%-?p cd %3-d blk_num %10-d valid %04hx dirty %04hx flag %02x\n", addr, centry.cc_head.hh_cd, centry.cc_head.hh_blk_num, centry.cc_valid, centry.cc_dirty, centry.cc_flag); mdb_dec_indent(4); if (!opt_v) return (DCMD_OK); /* verbose */ mdb_inc_indent(4); mdb_printf( "hashed %d seq %4-d toflush %04hx %8Tawait_use %4-d await_page %4-d\n", centry.cc_head.hh_hashed, centry.cc_seq, centry.cc_toflush, centry.cc_await_use, centry.cc_await_page); mdb_printf("inuse %d pageio %d cc_flag <%b>\n", centry.cc_inuse, centry.cc_pageio, centry.cc_flag, cc_flag_bits); mdb_printf("iocount %2d iostatus <%b>\n", centry.cc_iocount, centry.cc_iostatus, io_status_bits); if (mdb_vread(&cc_sync, sizeof (struct _sd_cctl_sync), (uintptr_t)centry.cc_sync) == -1) mdb_warn("failed to read cc_sync"); /* not catastophic */ else mdb_printf("cc_sync blkcv: %h-x %8Tlock: 0x%p (owner)\n", cc_sync._cc_blkcv._opaque, cc_sync._cc_lock._opaque[0]); mdb_printf("dynamic memory allocation:\n"); mdb_inc_indent(4); mdb_printf("aging_dm age %3d %4Tage flags: <%b> 0x%x\n", centry.cc_aging_dm & 0xff, centry.cc_aging_dm, cc_aging_bits, centry.cc_aging_dm); mdb_printf("alloc_size_dm %10-d head_dm %?-p\n", centry.cc_alloc_size_dm, centry.cc_head_dm); mdb_printf("next_dm %?-p link_list_dm %?-p\n", centry.cc_next_dm, centry.cc_link_list_dm); mdb_printf("alloc_ct_dm %10-d dealloc_ct_dm %10-d\n", centry.cc_alloc_ct_dm, centry.cc_dealloc_ct_dm); mdb_dec_indent(4); /* pointers */ mdb_printf("cctl pointers:\n"); mdb_inc_indent(4); mdb_printf("next %?-p prev %?-p chain %?-p\n", centry.cc_next, centry.cc_prev, centry.cc_chain); mdb_printf("dirty_next %?-p dirty_link %?-p\n", centry.cc_dirty_next, centry.cc_dirty_link); mdb_printf("data %?-p write ctl %?-p\n", centry.cc_data, centry.cc_write); mdb_dec_indent(4); /* dynmem chain */ mdb_printf("cctl dmqueue index cc_blocks %4-d\n", centry.cc_cblocks); mdb_printf("anon_addr %?-p anon_len %8-d\n", centry.cc_anon_addr.sa_virt, centry.cc_anon_len); /* stats */ mdb_printf("cctl stats: "); mdb_inc_indent(4); mdb_printf("hits %8-d creat time %?-p\n", centry.cc_hits, centry.cc_creat); mdb_dec_indent(4); mdb_printf("\n"); mdb_dec_indent(4); return (DCMD_OK); } /* * convenience dcmd to display the _sd_cctl cc_chain list (alloc list) * Must be called with an address of a cache entry (_sd_cctl_t) * same options as sdbc_cctl(). * alternatively the user can call the sdbc_cchain walker * and pipe the addresses to sdbc_cctl dcmd. */ static int sdbc_cchain(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { if (!(flags & DCMD_ADDRSPEC)) return (DCMD_USAGE); if (mdb_pwalk_dcmd("sdbc`sdbc_cchain", "sdbc`sdbc_cctl", argc, argv, addr) == -1) { mdb_warn("failed to walk cc_chain at addr %p", addr); return (DCMD_ERR); } return (DCMD_OK); } /* * convenience dcmd to cdisplay the _sd_cctl dirty chain * (which is really a 2d chain). * Must be called with an address of a cache entry (_sd_cctl_t) * same options as sdbc_cctl(). * alternatively the user can call the sdbc_dchain walker * and pipe the addresses to sdbc_cctl dcmd. */ static int sdbc_dchain(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { if (!(flags & DCMD_ADDRSPEC)) return (DCMD_USAGE); if (mdb_pwalk_dcmd("sdbc`sdbc_dchain", "sdbc`sdbc_cctl", argc, argv, addr) == -1) { mdb_warn("failed to walk dirty chain at addr %p", addr); return (DCMD_ERR); } return (DCMD_OK); } /* * convenience dcmd to display the _sd_cctl dm chain list * Must be called with an address of a cache entry (_sd_cctl_t) * same options as sdbc_cctl(). * alternatively the user can call the sdbc_dmchain walker * and pipe the addresses to sdbc_cctl dcmd. */ static int sdbc_dmchain(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { if (!(flags & DCMD_ADDRSPEC)) return (DCMD_USAGE); if (mdb_pwalk_dcmd("sdbc`sdbc_dmchain", "sdbc`sdbc_cctl", argc, argv, addr) == -1) { mdb_warn("failed to walk dm chain at addr %p", addr); return (DCMD_ERR); } return (DCMD_OK); } /* * dcmd to walk a hash chain * requires an address. same options as sdbc_cctl dcmd */ static int sdbc_hashchain(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { if (!(flags & DCMD_ADDRSPEC)) return (DCMD_USAGE); if (mdb_pwalk_dcmd("sdbc`sdbc_hashchain", "sdbc`sdbc_cctl", argc, argv, addr) == -1) { mdb_warn("failed to walk hashchain at %p", addr); return (DCMD_ERR); } return (DCMD_OK); } static void display_hash_table(_sd_hash_table_t *addr, _sd_hash_table_t *ht) { mdb_printf("hash table (%p):\n", addr); mdb_inc_indent(4); mdb_printf("size %7-d bits %2-d mask %8-x nmask %8-x buckets %p\n", ht->ht_size, ht->ht_bits, ht->ht_mask, ht->ht_nmask, ht->ht_buckets); mdb_dec_indent(4); } static void display_hash_bucket(_sd_hash_bucket_t *addr, _sd_hash_bucket_t *hb) { kmutex_t lock; int rc; if ((rc = mdb_vread(&lock, sizeof (kmutex_t), (uintptr_t)hb->hb_lock)) == -1) mdb_warn("failed to read bucket lock at %p", hb->hb_lock); mdb_printf("hash bucket (%p):\n", addr); mdb_inc_indent(4); mdb_printf("head %?-p tail %?-p lock %?-p %s\n", hb->hb_head, hb->hb_tail, (rc == -1) ? hb->hb_lock : lock._opaque[0], (rc == -1) ? "" : "(owner)"); mdb_printf("inlist %d seq %d\n", hb->hb_inlist, hb->hb_seq); mdb_dec_indent(4); } /* * dcmd to walk the hash table * defaults to _sd_htable the cache hash table, * but wil accept an address which is probably only useful * in the event that other hash tables are implemented in * the cache. * * calls sdbc_hashchain dcmd. same options as sdbc_cctl dcmd. */ static int sdbc_hashtable(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { _sd_hash_table_t *sd_htable_addr; _sd_hash_table_t _sd_htable; _sd_hash_bucket_t hash_bucket; int i; if (!(flags & DCMD_ADDRSPEC)) { /* get the address of the standard cache hash table */ if (mdb_readvar(&sd_htable_addr, "_sd_htable") == -1) { mdb_warn("failed to read _sd_htable address\n"); return (DCMD_ERR); } } else sd_htable_addr = (_sd_hash_table_t *)addr; /* read in the hash table structure */ if (mdb_vread(&_sd_htable, sizeof (_sd_hash_table_t), (uintptr_t)sd_htable_addr) == -1) { mdb_warn("failed to read _sd_htable structure at %p\n", sd_htable_addr); return (DCMD_ERR); } display_hash_table(sd_htable_addr, &_sd_htable); /* * read in the hash buckets * and display chains if there are any */ for (i = 0; i < _sd_htable.ht_size; ++i) { if (mdb_vread(&hash_bucket, sizeof (_sd_hash_bucket_t), (uintptr_t)(_sd_htable.ht_buckets + i)) == -1) { mdb_warn("failed to read ht_buckets at %p\n", _sd_htable.ht_buckets + i); return (DCMD_ERR); } if (hash_bucket.hb_head != NULL) { display_hash_bucket(_sd_htable.ht_buckets + i, &hash_bucket); /* * if this walk fails, continue trying * to read hash buckets */ if (mdb_call_dcmd("sdbc`sdbc_hashchain", (uintptr_t)hash_bucket.hb_head, flags|DCMD_ADDRSPEC, argc, argv) == -1) mdb_warn( "failed to walk hash chain at %p", hash_bucket.hb_head); mdb_printf("\n"); } } return (DCMD_OK); } /* * dcmd to display the sdbc lru queue * same options as sdbc_cctl(). * alternatively the user can call the sdbc_lru walker * and pipe the addresses to sdbc_cctl dcmd. */ static int sdbc_lru(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { _sd_queue_t _sd_lru_q; GElf_Sym sym; if (!(flags & DCMD_ADDRSPEC)) { if (mdb_lookup_by_obj("sdbc", "_sd_lru_q", &sym) == -1) { mdb_warn("failed to lookup _sd_lru_q symbol"); return (DCMD_ERR); } if (mdb_vread(&_sd_lru_q, sizeof (_sd_queue_t), sym.st_value) == -1) { mdb_warn("failed to read _sd_lru_q structure"); return (DCMD_ERR); } mdb_printf("Cache LRU Queue\n"); mdb_inc_indent(4); mdb_printf( "qlock: 0x%-p (owner) await %d seq %d inq %d req %d noreq %d\n", _sd_lru_q.sq_qlock._opaque[0], _sd_lru_q.sq_await, _sd_lru_q.sq_seq, _sd_lru_q.sq_inq, _sd_lru_q.sq_req_stat, _sd_lru_q.sq_noreq_stat); addr = (uintptr_t)(sym.st_value); } if (mdb_pwalk_dcmd("sdbc`sdbc_lru", "sdbc`sdbc_cctl", argc, argv, addr) == -1) { mdb_warn("failed to walk lru at addr %p", addr); return (DCMD_ERR); } return (DCMD_OK); } #ifdef SAFESTORE static void print_wrq(_sd_writeq_t *wrq, uint_t verbose) { int i; mdb_printf("Cache Write Ctl Queue:\n"); mdb_inc_indent(4); mdb_printf("qtop %-p qlock: %-p (owner) inq %d\n", wrq->wq_qtop, wrq->wq_qlock._opaque[0], wrq->wq_inq); mdb_printf("slp_top %3-d slp_index %3-d slp_inq %3-d\n", wrq->wq_slp_top, wrq->wq_slp_index, wrq->wq_slp_inq); for (i = 0; verbose && i < SD_WR_SLP_Q_MAX; i += 2) { mdb_printf("%3d: cv %h-x wq_need %3-d wq_held %3-d%4T", i, wrq->wq_slp[i].slp_wqcv._opaque, wrq->wq_slp[i].slp_wqneed, wrq->wq_slp[i].slp_wqheld); if (SD_WR_SLP_Q_MAX > (i + 1)) { mdb_printf( "%3d: cv %h-x wq_need %3-d wq_held %3-d%\n", i+1, wrq->wq_slp[i+1].slp_wqcv._opaque, wrq->wq_slp[i+1].slp_wqneed, wrq->wq_slp[i+1].slp_wqheld); } } mdb_dec_indent(4); } /* * dcmd to display write control structures */ static int sdbc_wctl(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { _sd_wr_cctl_t wctl; ss_centry_info_t gl_info; ss_centry_info_t nv_gl_info; uintptr_t opt_c = MDB_CD; uint_t opt_d = FALSE; uint_t opt_v = FALSE; /* TODO option for fba pos */ if (mdb_getopts(argc, argv, 'd', MDB_OPT_SETBITS, TRUE, &opt_d, 'c', MDB_OPT_UINTPTR, &opt_c, 'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc) return (DCMD_USAGE); if (!(flags & DCMD_ADDRSPEC)) { if (mdb_walk_dcmd("sdbc`sdbc_wctl", "sdbc`sdbc_wctl", argc, argv) == -1) { mdb_warn("failed to walk write ctl array"); return (DCMD_ERR); } return (DCMD_OK); } if (DCMD_HDRSPEC(flags)) { mdb_printf("write control block structures:\n"); } if (mdb_vread(&wctl, sizeof (_sd_wr_cctl_t), addr) == -1) { mdb_warn("failed to read wctl at 0x%p", addr); return (DCMD_ERR); } /* * print "all" is the default. * filter conditions can only be checked by reading in wc_gl_info */ if (opt_c || opt_d || opt_v) if (mdb_vread(&gl_info, sizeof (ss_centry_info_t), (uintptr_t)wctl.wc_gl_info) == -1) { mdb_warn("failed to read at wc_gl_info 0x%p", addr); return (DCMD_ERR); } if (OPT_C_SELECTED && (gl_info.gl_cd != opt_c)) return (DCMD_OK); if (opt_d && !(gl_info.gl_dirty)) return (DCMD_OK); mdb_inc_indent(4); mdb_printf("%-p data %-p gl_info %-p Ngl_info %-p flg %02x\n", addr, wctl.wc_data, wctl.wc_gl_info, wctl.wc_nvmem_gl_info, wctl.wc_flag); mdb_dec_indent(4); /* verbose */ if (!opt_v) return (DCMD_OK); mdb_inc_indent(4); mdb_printf("next %?-p prev %?-p\n", wctl.wc_next, wctl.wc_prev); mdb_printf(" gl_info: "); mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n", gl_info.gl_cd, gl_info.gl_fpos, gl_info.gl_dirty & 0xffff, gl_info.gl_flag, cc_flag_bits); if (wctl.wc_nvmem_gl_info) { if (mdb_vread(&nv_gl_info, sizeof (ss_centry_info_t), (uintptr_t)wctl.wc_nvmem_gl_info) == -1) { mdb_warn("failed to read at wc_nvmem_gl_info 0x%p", wctl.wc_nvmem_gl_info); /* not catastophic, continue */ } else { /* consistency check */ if (memcmp(&gl_info, &nv_gl_info, sizeof (ss_centry_info_t) != 0)) { mdb_warn("nvram and host memory are NOT identical!"); mdb_printf("nvmem_gl_info: "); mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n", nv_gl_info.gl_cd, nv_gl_info.gl_fpos, nv_gl_info.gl_dirty & 0xffff, nv_gl_info.gl_flag, cc_flag_bits); } } } mdb_dec_indent(4); mdb_printf("\n"); return (DCMD_OK); } /* * dcmd to display write control structures in the free list * same options as sdbc_wctl */ static int sdbc_wrq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { _sd_net_t _sd_net_config; uintptr_t opt_c = MDB_CD; uint_t opt_d = FALSE; uint_t opt_v = FALSE; /* look for verbose option */ if (mdb_getopts(argc, argv, 'd', MDB_OPT_SETBITS, TRUE, &opt_d, 'c', MDB_OPT_UINTPTR, &opt_c, 'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc) return (DCMD_USAGE); if (!(flags & DCMD_ADDRSPEC)) { if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) { mdb_warn("failed to read _sd_net_config structure"); return (DCMD_ERR); } print_wrq(&(_sd_net_config.sn_wr_queue), opt_v); addr = (uintptr_t)(_sd_net_config.sn_wr_queue.wq_qtop); } if (mdb_pwalk_dcmd("sdbc`sdbc_wrq", "sdbc`sdbc_wctl", argc, argv, addr) == -1) { mdb_warn("failed to walk write ctl queue at addr %p", addr); return (DCMD_ERR); } return (DCMD_OK); } #endif /* * dcmd to display the dm queues * use sdbc_lru walker to walk each queue. */ /*ARGSUSED*/ static int sdbc_dmqueues(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { _sd_queue_t *sdbc_dm_queues; /* kernel address of dm queues */ int max_dm_queues; _sd_queue_t *queues = NULL; /* local copy */ int i; if (argc != 0) return (DCMD_USAGE); if (!(flags & DCMD_ADDRSPEC)) { if (mdb_readvar(&sdbc_dm_queues, "sdbc_dm_queues") == -1) { mdb_warn("failed to read sdbc_dm_queues address\n"); return (DCMD_ERR); } if (mdb_readvar(&max_dm_queues, "max_dm_queues") == -1) { mdb_warn("failed to read max_dm_queues variable\n"); return (DCMD_ERR); } queues = mdb_zalloc(max_dm_queues * sizeof (_sd_queue_t), UM_SLEEP); mdb_printf("max_dm_queues %d sdbc_dm_queues %p queues %p\n", max_dm_queues, sdbc_dm_queues, queues); if (mdb_vread(queues, max_dm_queues * sizeof (_sd_queue_t), (uintptr_t)sdbc_dm_queues) == -1) { mdb_warn("failed to read sdbc_dm_queues"); return (DCMD_ERR); } for (i = 0; i < max_dm_queues; ++i) { mdb_printf("Cache DM Queue %d %p\n", queues[i].sq_dmchain_cblocks, sdbc_dm_queues +i); mdb_inc_indent(4); mdb_printf("qlock: 0x%-p (owner) await %d " "seq %d inq %d req %d noreq %d\n", queues[i].sq_qlock._opaque[0], queues[i].sq_await, queues[i].sq_seq, queues[i].sq_inq, queues[i].sq_req_stat, queues[i].sq_noreq_stat); mdb_dec_indent(4); } } return (DCMD_OK); } mdb_bitmask_t cd_writer_bits[] = { { "NONE ", (u_longlong_t)~0, _SD_WRITER_NONE }, { "CREATE ", (u_longlong_t)~0, _SD_WRITER_CREATE }, { "RUNNING", (u_longlong_t)~0, _SD_WRITER_RUNNING }, { NULL, 0, 0 } }; mdb_bitmask_t sh_failed_status[] = { { "STATUS OK", (u_longlong_t)~0, 0 }, { "I/O ERROR", (u_longlong_t)~0, 1 }, { "OPEN FAIL", (u_longlong_t)~0, 2 }, { NULL, 0, 0 } }; mdb_bitmask_t sh_flag_bits[] = { { "ATTACHED", CD_ATTACHED, CD_ATTACHED }, { NULL, 0, 0 } }; mdb_bitmask_t sh_alloc_bits[] = { { "ALLOC_IN_PROGRESS", CD_ALLOC_IN_PROGRESS, CD_ALLOC_IN_PROGRESS }, { "ALLOCATED", CD_ALLOCATED, CD_ALLOCATED }, { "CLOSE_IN_PROGRESS", CD_CLOSE_IN_PROGRESS, CD_CLOSE_IN_PROGRESS }, { NULL, 0, 0 } }; /* * dcmd to display cd information */ static int sdbc_cdinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { _sd_shared_t sd_shared; _sd_cd_info_t cdi; ss_voldata_t gl_file; char *fn = "nopath"; /* filename if sd_shared info cannot be read */ uchar_t sh_alloc = 0; /* assume not alloc'd if sd_shared info unavail */ uintptr_t opt_c = MDB_CD; uint_t opt_a = FALSE; uint_t opt_v = FALSE; int dev_t_chars; dev_t_chars = sizeof (dev_t) * 2; /* # chars to display dev_t */ if (mdb_getopts(argc, argv, 'a', MDB_OPT_SETBITS, TRUE, &opt_a, 'c', MDB_OPT_UINTPTR, &opt_c, 'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc) return (DCMD_USAGE); if (!(flags & DCMD_ADDRSPEC)) { if (mdb_walk_dcmd("sdbc`sdbc_cdinfo", "sdbc`sdbc_cdinfo", argc, argv) == -1) { mdb_warn("failed to walk cd info array"); return (DCMD_ERR); } return (DCMD_OK); } if (DCMD_HDRSPEC(flags)) { mdb_printf("cd info structures:\n"); } if (mdb_vread(&cdi, sizeof (_sd_cd_info_t), addr) == -1) { mdb_warn("failed to read cd info at 0x%p", addr); return (DCMD_ERR); } /* * need to do this read even for non-verbose option to * get the filename and the sh_alloc field */ if (cdi.cd_info) { if (mdb_vread(&sd_shared, sizeof (_sd_shared_t), (uintptr_t)cdi.cd_info) == -1) { mdb_warn("failed to read shared cd info at 0x%p", cdi.cd_info); /* not catastrophic, keep truckin' */ } else { fn = sd_shared.sh_filename; sh_alloc = sd_shared.sh_alloc; } } if (!opt_a && (sh_alloc == 0)) return (DCMD_OK); if (OPT_C_SELECTED && (opt_c != cdi.cd_desc)) return (DCMD_OK); mdb_inc_indent(4); mdb_printf("%p cd %3-d filename %s\n", addr, cdi.cd_desc, fn); mdb_printf("alloc <%b> hint <%b>\n", sh_alloc, sh_alloc_bits, cdi.cd_hint, cache_hints); mdb_dec_indent(4); if (!opt_v) return (DCMD_OK); /* verbose */ mdb_inc_indent(4); mdb_printf("rawfd %?-p crdev %0*lx iodev %?-p\n", cdi.cd_rawfd, dev_t_chars, cdi.cd_crdev, cdi.cd_iodev); mdb_printf("flag %x %8Tlock %?-p writer <%b>\n", cdi.cd_flag, cdi.cd_lock._opaque[0], cdi.cd_writer, cd_writer_bits); mdb_printf("global %?-p dirty_head %?-p\n", cdi.cd_global, cdi.cd_dirty_head); mdb_printf("last_ent %?-p lastchain_ptr %?-p lastchain %d\n", cdi.cd_last_ent, cdi.cd_lastchain_ptr, cdi.cd_lastchain); mdb_printf("io_head %?-p io_tail %?-p fail_head %?-p\n", cdi.cd_io_head, cdi.cd_io_tail, cdi.cd_fail_head); mdb_printf( "cd_info %?-p failover %d recovering %d write_inprogress %d\n", cdi.cd_info, cdi.cd_failover, cdi.cd_recovering, cdi.cd_write_inprogress); if (cdi.cd_global != NULL) { if (mdb_vread(&gl_file, sizeof (ss_voldata_t), (uintptr_t)cdi.cd_global) == -1) mdb_warn("failed to read cd_global at %p", cdi.cd_global); else { mdb_printf("cd_global: %s\n", gl_file.sv_volname); mdb_printf("pinned %2-d attached %2-d devidsz %3-d\n", gl_file.sv_pinned, gl_file.sv_attached, gl_file.sv_devidsz); mdb_printf("devid %s\n", gl_file.sv_devid); mdb_printf("vol %?p\n", gl_file.sv_vol); } /* TODO do a consistency check here against the nvram copy */ } if (cdi.cd_info == NULL) { mdb_printf("no shared info\n"); } else { mdb_printf("shared:\n"); mdb_printf("failed <%b> cd %3-d", sd_shared.sh_failed, sh_failed_status, sd_shared.sh_cd); mdb_printf("cache_read %10-d cache_write %10-d\n", sd_shared.sh_cache_read, sd_shared.sh_cache_write); mdb_printf("disk_read %10-d disk_write %10-d filesize %10-d\n", sd_shared.sh_disk_read, sd_shared.sh_disk_write, sd_shared.sh_filesize); mdb_printf("numdirty %8-d numio %8-d numfail %8-d\n", sd_shared.sh_numdirty, sd_shared.sh_numio, sd_shared.sh_numfail); mdb_printf("flushloop %2-d sh_flag <%b>\n", sd_shared.sh_flushloop, sd_shared.sh_flag, sh_flag_bits); /* this can be really verbose */ if (cdi.cd_dirty_head) { mdb_printf("Dirty Chain (cd_dirty_head):"); /* TODO reconstruct argv without opt_a */ if (!opt_a) mdb_call_dcmd("sdbc_dchain", (uintptr_t)cdi.cd_dirty_head, flags, argc, argv); else /* print with no options */ mdb_call_dcmd("sdbc_dchain", (uintptr_t)cdi.cd_dirty_head, flags, 0, NULL); } if (cdi.cd_io_head) { mdb_printf("I/O Pending Chain (cd_io_head):"); /* TODO reconstruct argv without opt_a */ if (!opt_a) mdb_call_dcmd("sdbc_dchain", (uintptr_t)cdi.cd_io_head, flags, argc, argv); else /* print with no options */ mdb_call_dcmd("sdbc_dchain", (uintptr_t)cdi.cd_dirty_head, flags, 0, NULL); } if (cdi.cd_fail_head) { mdb_printf("Failed Chain (cd_fail_head):"); /* TODO reconstruct argv without opt_a */ if (!opt_a) mdb_call_dcmd("sdbc_dchain", (uintptr_t)cdi.cd_fail_head, flags, argc, argv); else /* print with no options */ mdb_call_dcmd("sdbc_dchain", (uintptr_t)cdi.cd_dirty_head, flags, 0, NULL); } } mdb_dec_indent(4); mdb_printf("\n"); return (DCMD_OK); } #ifdef SAFESTORE /* * dcmd to display fault tolerant control structures */ static int sdbc_ftctl(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { _sd_ft_cctl_t ft_cent; ss_centry_info_t gl_info; ss_centry_info_t nv_gl_info; uintptr_t opt_c = MDB_CD; uint_t opt_d = FALSE; uint_t opt_v = FALSE; /* TODO option to select on fpos */ if (mdb_getopts(argc, argv, 'd', MDB_OPT_SETBITS, TRUE, &opt_d, 'c', MDB_OPT_UINTPTR, &opt_c, 'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc) return (DCMD_USAGE); if (!(flags & DCMD_ADDRSPEC)) { if (mdb_walk_dcmd("sdbc`sdbc_ftctl", "sdbc`sdbc_ftctl", argc, argv) == -1) { mdb_warn("failed to walk write ctl array"); return (DCMD_ERR); } return (DCMD_OK); } if (DCMD_HDRSPEC(flags)) { mdb_printf("Ft control block structures:\n"); } if (mdb_vread(&ft_cent, sizeof (_sd_ft_cctl_t), addr) == -1) { mdb_warn("failed to read ft_cent at 0x%p", addr); return (DCMD_ERR); } /* * print "all" is the default. * filter conditions can only be checked by reading in wc_gl_info */ if (opt_c || opt_d || opt_v) if (mdb_vread(&gl_info, sizeof (ss_centry_info_t), (uintptr_t)ft_cent.ft_gl_info) == -1) { mdb_warn("failed to read at wc_gl_info 0x%p", addr); return (DCMD_ERR); } if (OPT_C_SELECTED && (gl_info.gl_cd != opt_c)) return (DCMD_OK); if (opt_d && !(gl_info.gl_dirty)) return (DCMD_OK); mdb_inc_indent(4); mdb_printf("%-p data %?-p qnext %?-p\n", addr, ft_cent.ft_qnext, ft_cent.ft_data); mdb_printf("gl_info %?-p nvmem_gl_info %?-p\n", ft_cent.ft_gl_info, ft_cent.ft_nvmem_gl_info); mdb_dec_indent(4); /* verbose */ if (!opt_v) { mdb_printf("\n"); return (DCMD_OK); } mdb_inc_indent(4); mdb_printf(" gl_info: "); mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n", gl_info.gl_cd, gl_info.gl_fpos, gl_info.gl_dirty & 0xffff, gl_info.gl_flag, cc_flag_bits); if (ft_cent.ft_nvmem_gl_info) { if (mdb_vread(&nv_gl_info, sizeof (ss_centry_info_t), (uintptr_t)ft_cent.ft_nvmem_gl_info) == -1) { mdb_warn("failed to read at ft_nvmem_gl_info 0x%p", ft_cent.ft_nvmem_gl_info); /* not catastophic, continue */ } else { mdb_printf("nvmem_gl_info: "); mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n", nv_gl_info.gl_cd, nv_gl_info.gl_fpos, nv_gl_info.gl_dirty & 0xffff, nv_gl_info.gl_flag, cc_flag_bits); /* consistency check */ if (memcmp(&gl_info, &nv_gl_info, sizeof (ss_centry_info_t)) != 0) { mdb_warn("nvram and host memory are NOT identical!"); } } } mdb_dec_indent(4); mdb_printf("\n"); return (DCMD_OK); } #endif /* SAFESTORE */ /* dcmd to display buffer handles */ static int sdbc_handles(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { uint_t opt_a = FALSE; uintptr_t opt_c = MDB_CD; uint_t opt_v = FALSE; uint_t opt_C = FALSE; _sd_buf_hlist_t hl; _sd_buf_handle_t bh; if (mdb_getopts(argc, argv, 'a', MDB_OPT_SETBITS, TRUE, &opt_a, 'c', MDB_OPT_UINTPTR, &opt_c, 'C', MDB_OPT_SETBITS, TRUE, &opt_C, 'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc) return (DCMD_USAGE); if (mdb_readvar(&hl, "_sd_handle_list") == -1) { mdb_warn("failed to read _sd_handle_list structure"); return (DCMD_ERR); } if (!(flags & DCMD_ADDRSPEC)) { if (mdb_walk_dcmd("sdbc`sdbc_handles", "sdbc`sdbc_handles", argc, argv) == -1) { mdb_warn("failed to walk 'sdbc_handle_list'"); return (DCMD_ERR); } return (DCMD_OK); } if (DCMD_HDRSPEC(flags)) { mdb_printf("Handle List Info:\n"); mdb_inc_indent(4); mdb_printf("hl_top.bh_next: 0x%p\n", hl.hl_top.bh_next); mdb_printf("hl_lock: 0x%p (owner)\n", hl.hl_lock._opaque[0]); mdb_printf("hl_count: %hd\n", hl.hl_count); mdb_dec_indent(4); mdb_printf("buf handles:\n"); } if (mdb_vread(&bh, sizeof (bh), addr) == -1) { mdb_warn("failed to read buf handle at 0x%p", addr); return (DCMD_ERR); } if (!opt_a && !(bh.bh_flag & (NSC_HALLOCATED | NSC_HACTIVE))) return (DCMD_OK); /* * may get false matches on cd option -- * a cleared bh_cd field will match if user specified cd 0 */ if (OPT_C_SELECTED && (bh.bh_cd != opt_c)) return (DCMD_OK); mdb_inc_indent(4); mdb_printf("%p %8T cd %3-d %4T<%b> %x\n", addr, bh.bh_cd, bh.bh_flag, nsc_buf_bits, bh.bh_flag); /* check for verbose, avoid printing twice */ if (!opt_v && opt_C) { mdb_printf("cc_chain: "); if (bh.bh_centry) mdb_call_dcmd("sdbc`sdbc_cchain", (uintptr_t)bh.bh_centry, DCMD_ADDRSPEC, 0, NULL); } mdb_dec_indent(4); if (!opt_v) return (DCMD_OK); /* verbose */ mdb_inc_indent(4); mdb_printf("callbacks: %-20a%-20a%-20a\n", bh.bh_disconnect_cb, bh.bh_read_cb, bh.bh_write_cb); mdb_printf("centry %?p %8T next %?p\n", bh.bh_centry, bh.bh_next); mdb_printf("buffer:\n"); mdb_inc_indent(4); mdb_printf("fd 0x%p pos %10d len %6d flag 0x%x\n", bh.bh_buf.sb_fd, bh.bh_fba_pos, bh.bh_fba_len, bh.bh_flag); mdb_printf("alloc_thread %p busy_thread %p\n", bh.bh_alloc_thread, bh.bh_busy_thread); mdb_printf("err %4d %8T bh_vec 0x%p\n", bh.bh_error, bh.bh_vec); mdb_dec_indent(4); mdb_printf("bufvec (scatter gather list): %-?s %8T%-s\n", "ADDR", "LEN"); { _sd_bufvec_t *bv, *endvec; /* todo check for (bh_vec != bh_bufvec) => readahead? */ bv = bh.bh_bufvec; endvec = bv + _SD_MAX_BLKS; mdb_inc_indent(30); while (bv->bufaddr) { mdb_printf("%p %8T%d\n", bv->bufaddr, bv->buflen); ++bv; if (bv > endvec) { mdb_warn("END of bh_bufvec ARRAY"); break; } } mdb_dec_indent(30); } if (opt_C) { mdb_printf("cc_chain: "); if (bh.bh_centry) mdb_call_dcmd("sdbc`sdbc_cchain", (uintptr_t)bh.bh_centry, DCMD_ADDRSPEC, 0, NULL); } mdb_dec_indent(4); mdb_printf("\n"); return (DCMD_OK); } /* * dcmd to display ss_centry_info_t structures and * do optional consistency check with the nvram copy * if configured for nvram safe storage. */ static int sdbc_glcinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { ss_centry_info_t gl_centry_info; /* for doing consistency check */ ss_centry_info_t *gl_centry_info_start; ss_centry_info_t *nv_gl_centry_info_start; uintptr_t nv_addr; ss_centry_info_t nv_gl_centry_info; /* options */ uint_t opt_a = FALSE; uintptr_t opt_b = MDB_BLKNUM; /* fba pos match */ uintptr_t opt_c = MDB_CD; uintptr_t opt_C = FALSE; /* consistency check */ uint_t opt_d = FALSE; if (mdb_getopts(argc, argv, 'a', MDB_OPT_SETBITS, TRUE, &opt_a, 'b', MDB_OPT_UINTPTR, &opt_b, 'c', MDB_OPT_UINTPTR, &opt_c, 'C', MDB_OPT_SETBITS, TRUE, &opt_C, 'd', MDB_OPT_SETBITS, TRUE, &opt_d) != argc) return (DCMD_USAGE); if (!(flags & DCMD_ADDRSPEC)) { if (mdb_walk_dcmd("sdbc`sdbc_glcinfo", "sdbc`sdbc_glcinfo", argc, argv) == -1) { mdb_warn("failed to walk global centry info array"); return (DCMD_ERR); } return (DCMD_OK); } if (DCMD_HDRSPEC(flags)) { mdb_printf("global cache entry info:\n"); } if (mdb_vread(&gl_centry_info, sizeof (ss_centry_info_t), addr) == -1) { mdb_warn("failed to read gl_centry_info at 0x%p", addr); return (DCMD_ERR); } /* * default is to print entries initialized with a cd. return if * no options are selected and cd is invalid. */ if (!opt_a && (!OPT_B_SELECTED) && (!OPT_C_SELECTED) && !opt_d && (gl_centry_info.sc_cd == -1)) return (DCMD_OK); /* * opt_c is exclusive filter. if opt_c is selected and there * is no match on the cd then return */ if (!opt_a && (OPT_C_SELECTED && (gl_centry_info.sc_cd != opt_c))) return (DCMD_OK); /* * opt_d and opt_b are inclusive. print if either one is chosen * and the selection condition is true. */ if (opt_a || (!opt_d && (!OPT_B_SELECTED)) || /* no options chosen */ (opt_d && gl_centry_info.sc_dirty) || (OPT_B_SELECTED && (gl_centry_info.sc_fpos == opt_b))) /*EMPTY*/; else return (DCMD_OK); mdb_inc_indent(4); mdb_printf("%?-p cd %3-d fpos %10-d dirty %04x flag <%b>\n", addr, gl_centry_info.sc_cd, gl_centry_info.sc_fpos, gl_centry_info.sc_dirty & 0xffff, gl_centry_info.sc_flag, cc_flag_bits); if (opt_C) { /* get start of the cache entry metadata */ if (mdb_readvar(&gl_centry_info_start, "_sdbc_gl_centry_info") == -1) { mdb_warn("failed to read _sdbc_gl_centry_info"); /* not catastrophic */ goto end; } /* get start of the nvram copy cache entry metadata */ if (mdb_readvar(&nv_gl_centry_info_start, "_sdbc_gl_centry_info_nvmem") == -1) { mdb_warn("failed to read _sdbc_gl_centry_info_nvmem"); /* not catastrophic */ goto end; } nv_addr = (addr - (uintptr_t)gl_centry_info_start) + (uintptr_t)nv_gl_centry_info_start; if (mdb_vread(&nv_gl_centry_info, sizeof (ss_centry_info_t), nv_addr) == -1) { mdb_warn("failed to read at nvmem_gl_info 0x%p", nv_addr); /* not catastophic, continue */ } else { /* consistency check */ mdb_inc_indent(4); if (memcmp(&gl_centry_info, &nv_gl_centry_info, sizeof (ss_centry_info_t) != 0)) { mdb_warn( "nvram and host memory are NOT identical!"); mdb_printf("nvmem_gl_centry_info: "); mdb_printf( "%?-p cd %3-d fpos %10-d dirty %04x flag <%b>\n", nv_addr, nv_gl_centry_info.sc_cd, nv_gl_centry_info.sc_fpos, nv_gl_centry_info.sc_dirty & 0xffff, nv_gl_centry_info.sc_flag, cc_flag_bits); mdb_printf("\n"); } else mdb_printf("NVRAM ok\n"); mdb_dec_indent(4); } } end: mdb_dec_indent(4); return (DCMD_OK); } /* * dcmd to display ss_voldata_t structures and * do optional consistency check with the nvram copy * if configured for nvram safe storage. */ static int sdbc_glfinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) { ss_voldata_t gl_file_info; /* for doing consistency check */ ss_voldata_t *gl_file_info_start; ss_voldata_t *nv_gl_file_info_start; uintptr_t nv_addr; ss_voldata_t nv_gl_file_info; /* options default: valid filename */ uint_t opt_a = FALSE; /* all */ uint_t opt_p = FALSE; /* PINNED */ uint_t opt_t = FALSE; /* attached */ uint_t opt_C = FALSE; /* consistency check */ /* * possible enhancement -- match on filename, * or filename part (e.g. controller number) */ if (mdb_getopts(argc, argv, 'a', MDB_OPT_SETBITS, TRUE, &opt_a, 'C', MDB_OPT_SETBITS, TRUE, &opt_C, 'p', MDB_OPT_SETBITS, TRUE, &opt_p, 't', MDB_OPT_SETBITS, TRUE, &opt_t) != argc) return (DCMD_USAGE); if (!(flags & DCMD_ADDRSPEC)) { if (mdb_walk_dcmd("sdbc`sdbc_glfinfo", "sdbc`sdbc_glfinfo", argc, argv) == -1) { mdb_warn("failed to walk global file info array"); return (DCMD_ERR); } return (DCMD_OK); } if (DCMD_HDRSPEC(flags)) { mdb_printf("global file entry info:\n"); } if (mdb_vread(&gl_file_info, sizeof (ss_voldata_t), addr) == -1) { mdb_warn("failed to read gl_file_info at 0x%p", addr); return (DCMD_ERR); } /* * default is to print entries initialized with non-null filename. * return if no options are selected and filename is invalid. */ if (!opt_a && !opt_p && !opt_t && (strlen(gl_file_info.sv_volname) == 0)) return (DCMD_OK); if (opt_a || (!opt_p && !opt_t) || /* no options chosen */ (opt_p && (gl_file_info.sv_pinned != _SD_NO_HOST)) || (opt_t && (gl_file_info.sv_attached != _SD_NO_HOST))) /*EMPTY*/; else return (DCMD_OK); mdb_inc_indent(4); mdb_printf("%?-p %s\n", addr, gl_file_info.sv_volname); mdb_printf("pinned %2-d attached %2-d devidsz %3-d\n", gl_file_info.sv_pinned, gl_file_info.sv_attached, gl_file_info.sv_devidsz); mdb_printf("devid %s\n", gl_file_info.sv_devid); if (opt_C) { /* get start of the cache entry metadata */ if (mdb_readvar(&gl_file_info_start, "_sdbc_gl_file_info") == -1) { mdb_warn("failed to read _sdbc_gl_file_info"); /* not catastrophic */ goto end; } /* get start of the nvram copy cache entry metadata */ if (mdb_readvar(&nv_gl_file_info_start, "_sdbc_gl_file_info_nvmem") == -1) { mdb_warn("failed to read _sdbc_gl_file_info_nvmem"); /* not catastrophic */ goto end; } nv_addr = (addr - (uintptr_t)gl_file_info_start) + (uintptr_t)nv_gl_file_info_start; if (mdb_vread(&nv_gl_file_info, sizeof (ss_voldata_t), nv_addr) == -1) { mdb_warn("failed to read nvmem_gl_info at 0x%p", nv_addr); /* not catastophic, continue */ } else { /* consistency check */ mdb_inc_indent(4); if (memcmp(&gl_file_info, &nv_gl_file_info, sizeof (ss_centry_info_t) != 0)) { mdb_warn("nvram and host memory are NOT identical!"); mdb_printf("nvmem_gl_file_info: "); mdb_printf("%?-p %s\n", nv_addr, nv_gl_file_info.sv_volname); mdb_printf("pinned %2-d attached %2-d devidsz %3-d\n", nv_gl_file_info.sv_pinned, nv_gl_file_info.sv_attached, nv_gl_file_info.sv_devidsz); mdb_printf("devid %s\n", nv_gl_file_info.sv_devid); } else mdb_printf("NVRAM ok\n"); mdb_dec_indent(4); } } end: mdb_dec_indent(4); mdb_printf("\n"); return (DCMD_OK); } /* * MDB module linkage information: * * We declare a list of structures describing our dcmds, and a function * named _mdb_init to return a pointer to our module information. */ static const mdb_dcmd_t dcmds[] = { /* general dcmds */ { "sdbc_config", NULL, "display sdbc configuration information", sdbc_config }, { "sdbc_stats", NULL, "display sdbc stats information", sdbc_stats }, { "sdbc_vars", NULL, "display some sdbc variables, counters and addresses", sdbc_vars }, /* cctl dcmds */ {"sdbc_cctl", "?[-vdhioV][-c cd][-b blknum]", "display sdbc cache ctl structures", sdbc_cctl, cctl_help }, {"sdbc_cchain", ":[-vdhioV][-c cd][-b blknum]", "display cache ctl structure cc_chain", sdbc_cchain, cchain_help }, {"sdbc_dchain", ":[-vdhioV][-c cd][-b blknum]", "display cache ctl structure dirty chain", sdbc_dchain, dchain_help }, {"sdbc_dmchain", ":[-vdhioV][-c cd][-b blknum]", "display dynamic memory cache ctl chain", sdbc_dmchain, dmchain_help }, {"sdbc_hashchain", ":[-vdhioV][-c cd][-b blknum]", "display a hash chain", sdbc_hashchain, hashchain_help }, {"sdbc_hashtable", "?[-vdhioV][-c cd][-b blknum]", "display hash table", sdbc_hashtable, hashtable_help }, {"sdbc_lru", "?[-vdhioV][-c cd][-b blknum]", "display the cache lru queue", sdbc_lru, lru_help }, #ifdef SAFESTORE /* wctl dcmds */ {"sdbc_wctl", "?[-vd][-c cd]", "display the write control structures", sdbc_wctl, wctl_help }, {"sdbc_wrq", "?[-vd][-c cd]", "display the write control queue", sdbc_wrq, wrq_help }, #endif /* SAFESTORE */ /* others */ {"sdbc_cdinfo", "?[-av][-c cd]", "display cache descriptor information", sdbc_cdinfo, cdinfo_help }, #ifdef SAFESTORE {"sdbc_ftctl", "?[-vd][-c cd]", "display the fault tolerant control structures", sdbc_ftctl, ftctl_help }, #endif /* SAFESTORE */ {"sdbc_handles", "?[-avC][-c cd]", "display sdbc buffer handle information", sdbc_handles, handle_help }, { "sdbc_dmqueues", NULL, "display sdbc dynamic memory buffer queues information", sdbc_dmqueues }, /* "global" metadata dcmds */ {"sdbc_glcinfo", "?[-adC][-c cd][-b fbapos]", "display the global cache entry info structures", sdbc_glcinfo, glcinfo_help }, {"sdbc_glfinfo", "?[-aptC]", "display the global file info structures", sdbc_glfinfo, glfinfo_help }, { NULL } }; static const mdb_walker_t walkers[] = { /* walkers of cctl list and arrays */ { "sdbc_cchain", "walk the cc_chain (alloc chain) of a cache ctl", sdbc_cchain_winit, sdbc_cchain_wstep, sdbc_cchain_wfini }, { "sdbc_cctl", "walk the cache ctl structure list", sdbc_cctl_winit, sdbc_cctl_wstep, sdbc_cctl_wfini }, { "sdbc_dchain", "walk the dirty chain of a cache ctl", sdbc_dchain_winit, sdbc_dchain_wstep, sdbc_dchain_wfini }, { "sdbc_dmchain", "walk the dynamic memory chain of a cache cctl", sdbc_dmchain_winit, sdbc_dmchain_wstep, sdbc_dmchain_wfini }, { "sdbc_hashchain", "walk a hash chain", sdbc_hashchain_winit, sdbc_hashchain_wstep, sdbc_hashchain_wfini }, { "sdbc_lru", "walk the cache lru queue", sdbc_lru_winit, sdbc_lru_wstep, sdbc_lru_wfini }, #ifdef SAFESTORE /* walkers of wctl lists and arrays */ { "sdbc_wctl", "walk the allocated write ctl array", sdbc_wctl_winit, sdbc_wctl_wstep, sdbc_wctl_wfini }, { "sdbc_wrq", "walk the write ctl queue (free list)", sdbc_wrq_winit, sdbc_wrq_wstep, sdbc_wrq_wfini }, #endif /* SAFESTORE */ /* others */ { "sdbc_cdinfo", "walk the _sd_cache_files array of cache descriptor information", sdbc_cdinfo_winit, sdbc_cdinfo_wstep, sdbc_cdinfo_wfini }, #ifdef SAFESTORE { "sdbc_ftctl", "walk the allocated array of fault tolerant structures", sdbc_ftctl_winit, sdbc_ftctl_wstep, sdbc_ftctl_wfini }, #endif /* SAFESTORE */ { "sdbc_handles", "walk array of _sd_buf_handle_t structures", sdbc_handle_winit, sdbc_handle_wstep, sdbc_handle_wfini }, /* walkers for metadata arrays */ { "sdbc_glcinfo", "walk the allocated global cache entry info array", sdbc_glcinfo_winit, sdbc_glcinfo_wstep, sdbc_glcinfo_wfini }, { "sdbc_glfinfo", "walk the allocated global file info array", sdbc_glfinfo_winit, sdbc_glfinfo_wstep, sdbc_glfinfo_wfini }, { NULL } }; static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers }; const mdb_modinfo_t * _mdb_init(void) { return (&modinfo); }