1 // SPDX-License-Identifier: CDDL-1.0 2 /* 3 * CDDL HEADER START 4 * 5 * The contents of this file are subject to the terms of the 6 * Common Development and Distribution License (the "License"). 7 * You may not use this file except in compliance with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or https://opensource.org/licenses/CDDL-1.0. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 23 #include <sys/zfs_context.h> 24 #include <sys/dbuf.h> 25 #include <sys/dmu_objset.h> 26 27 /* 28 * Calculate the index of the arc header for the state, disabled by default. 29 */ 30 int zfs_dbuf_state_index = 0; 31 32 /* 33 * ========================================================================== 34 * Dbuf Hash Read Routines 35 * ========================================================================== 36 */ 37 typedef struct dbuf_stats_t { 38 kmutex_t lock; 39 kstat_t *kstat; 40 dbuf_hash_table_t *hash; 41 int idx; 42 } dbuf_stats_t; 43 44 static dbuf_stats_t dbuf_stats_hash_table; 45 46 static int 47 dbuf_stats_hash_table_headers(char *buf, size_t size) 48 { 49 (void) snprintf(buf, size, 50 "%-105s | %-119s | %s\n" 51 "%-16s %-8s %-8s %-8s %-8s %-10s %-8s %-8s %-5s %-5s %-7s %3s | " 52 "%-5s %-5s %-9s %-6s %-8s %-12s " 53 "%-6s %-6s %-6s %-6s %-6s %-8s %-8s %-8s %-6s | " 54 "%-6s %-6s %-8s %-8s %-6s %-6s %-6s %-8s %-8s\n", 55 "dbuf", "arcbuf", "dnode", "pool", "objset", "object", "level", 56 "blkid", "offset", "dbsize", "usize", "meta", "state", "dbholds", 57 "dbc", "list", "atype", "flags", "count", "asize", "access", 58 "mru", "gmru", "mfu", "gmfu", "l2", "l2_dattr", "l2_asize", 59 "l2_comp", "aholds", "dtype", "btype", "data_bs", "meta_bs", 60 "bsize", "lvls", "dholds", "blocks", "dsize"); 61 62 return (0); 63 } 64 65 static int 66 __dbuf_stats_hash_table_data(char *buf, size_t size, dmu_buf_impl_t *db) 67 { 68 arc_buf_info_t abi = { 0 }; 69 dmu_object_info_t doi = { 0 }; 70 dnode_t *dn = DB_DNODE(db); 71 size_t nwritten; 72 73 if (db->db_buf) 74 arc_buf_info(db->db_buf, &abi, zfs_dbuf_state_index); 75 76 __dmu_object_info_from_dnode(dn, &doi); 77 78 nwritten = snprintf(buf, size, 79 "%-16s %-8llu %-8lld %-8lld %-8lld %-10llu %-8llu %-8llu " 80 "%-5d %-5d %-7lu %-3d | %-5d %-5d 0x%-7x %-6lu %-8llu %-12llu " 81 "%-6lu %-6lu %-6lu %-6lu %-6lu %-8llu %-8llu %-8d %-6lu | " 82 "%-6d %-6d %-8lu %-8lu %-6llu %-6lu %-6lu %-8llu %-8llu\n", 83 /* dmu_buf_impl_t */ 84 spa_name(dn->dn_objset->os_spa), 85 (u_longlong_t)dmu_objset_id(db->db_objset), 86 (longlong_t)db->db.db_object, 87 (longlong_t)db->db_level, 88 (longlong_t)db->db_blkid, 89 (u_longlong_t)db->db.db_offset, 90 (u_longlong_t)db->db.db_size, 91 (u_longlong_t)dmu_buf_user_size(&db->db), 92 !!dbuf_is_metadata(db), 93 db->db_state, 94 (ulong_t)zfs_refcount_count(&db->db_holds), 95 multilist_link_active(&db->db_cache_link), 96 /* arc_buf_info_t */ 97 abi.abi_state_type, 98 abi.abi_state_contents, 99 abi.abi_flags, 100 (ulong_t)abi.abi_bufcnt, 101 (u_longlong_t)abi.abi_size, 102 (u_longlong_t)abi.abi_access, 103 (ulong_t)abi.abi_mru_hits, 104 (ulong_t)abi.abi_mru_ghost_hits, 105 (ulong_t)abi.abi_mfu_hits, 106 (ulong_t)abi.abi_mfu_ghost_hits, 107 (ulong_t)abi.abi_l2arc_hits, 108 (u_longlong_t)abi.abi_l2arc_dattr, 109 (u_longlong_t)abi.abi_l2arc_asize, 110 abi.abi_l2arc_compress, 111 (ulong_t)abi.abi_holds, 112 /* dmu_object_info_t */ 113 doi.doi_type, 114 doi.doi_bonus_type, 115 (ulong_t)doi.doi_data_block_size, 116 (ulong_t)doi.doi_metadata_block_size, 117 (u_longlong_t)doi.doi_bonus_size, 118 (ulong_t)doi.doi_indirection, 119 (ulong_t)zfs_refcount_count(&dn->dn_holds), 120 (u_longlong_t)doi.doi_fill_count, 121 (u_longlong_t)doi.doi_max_offset); 122 123 if (nwritten >= size) 124 return (size); 125 126 return (nwritten + 1); 127 } 128 129 static int 130 dbuf_stats_hash_table_data(char *buf, size_t size, void *data) 131 { 132 dbuf_stats_t *dsh = (dbuf_stats_t *)data; 133 dbuf_hash_table_t *h = dsh->hash; 134 dmu_buf_impl_t *db; 135 int length, error = 0; 136 137 ASSERT3S(dsh->idx, >=, 0); 138 ASSERT3S(dsh->idx, <=, h->hash_table_mask); 139 if (size) 140 buf[0] = 0; 141 142 mutex_enter(DBUF_HASH_MUTEX(h, dsh->idx)); 143 for (db = h->hash_table[dsh->idx]; db != NULL; db = db->db_hash_next) { 144 /* 145 * Returning ENOMEM will cause the data and header functions 146 * to be called with a larger scratch buffers. 147 */ 148 if (size < 512) { 149 error = SET_ERROR(ENOMEM); 150 break; 151 } 152 153 mutex_enter(&db->db_mtx); 154 155 if (db->db_state != DB_EVICTING) { 156 length = __dbuf_stats_hash_table_data(buf, size, db); 157 buf += length; 158 size -= length; 159 } 160 161 mutex_exit(&db->db_mtx); 162 } 163 mutex_exit(DBUF_HASH_MUTEX(h, dsh->idx)); 164 165 return (error); 166 } 167 168 static void * 169 dbuf_stats_hash_table_addr(kstat_t *ksp, loff_t n) 170 { 171 dbuf_stats_t *dsh = ksp->ks_private; 172 173 ASSERT(MUTEX_HELD(&dsh->lock)); 174 175 if (n <= dsh->hash->hash_table_mask) { 176 dsh->idx = n; 177 return (dsh); 178 } 179 180 return (NULL); 181 } 182 183 static void 184 dbuf_stats_hash_table_init(dbuf_hash_table_t *hash) 185 { 186 dbuf_stats_t *dsh = &dbuf_stats_hash_table; 187 kstat_t *ksp; 188 189 mutex_init(&dsh->lock, NULL, MUTEX_DEFAULT, NULL); 190 dsh->hash = hash; 191 192 ksp = kstat_create("zfs", 0, "dbufs", "misc", 193 KSTAT_TYPE_RAW, 0, KSTAT_FLAG_VIRTUAL); 194 dsh->kstat = ksp; 195 196 if (ksp) { 197 ksp->ks_lock = &dsh->lock; 198 ksp->ks_ndata = UINT32_MAX; 199 ksp->ks_private = dsh; 200 kstat_set_raw_ops(ksp, dbuf_stats_hash_table_headers, 201 dbuf_stats_hash_table_data, dbuf_stats_hash_table_addr); 202 kstat_install(ksp); 203 } 204 } 205 206 static void 207 dbuf_stats_hash_table_destroy(void) 208 { 209 dbuf_stats_t *dsh = &dbuf_stats_hash_table; 210 kstat_t *ksp; 211 212 ksp = dsh->kstat; 213 if (ksp) 214 kstat_delete(ksp); 215 216 mutex_destroy(&dsh->lock); 217 } 218 219 void 220 dbuf_stats_init(dbuf_hash_table_t *hash) 221 { 222 dbuf_stats_hash_table_init(hash); 223 } 224 225 void 226 dbuf_stats_destroy(void) 227 { 228 dbuf_stats_hash_table_destroy(); 229 } 230 231 ZFS_MODULE_PARAM(zfs, zfs_, dbuf_state_index, INT, ZMOD_RW, 232 "Calculate arc header index"); 233