module/zfs/dbuf_stats.c

   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 #include <sys/zfs_context.h>
  23 #include <sys/dbuf.h>
  24 #include <sys/dmu_objset.h>
  25
  26 /*
  27  * Calculate the index of the arc header for the state, disabled by default.
  28  */
  29 int zfs_dbuf_state_index = 0;
  30
  31 /*
  32  * ==========================================================================
  33  * Dbuf Hash Read Routines
  34  * ==========================================================================
  35  */
  36 typedef struct dbuf_stats_t {
  37         kmutex_t                lock;
  38         kstat_t                 *kstat;
  39         dbuf_hash_table_t       *hash;
  40         int                     idx;
  41 } dbuf_stats_t;
  42
  43 static dbuf_stats_t dbuf_stats_hash_table;
  44
  45 static int
  46 dbuf_stats_hash_table_headers(char *buf, size_t size)
  47 {
  48         (void) snprintf(buf, size,
  49             "%-88s | %-124s | %s\n"
  50             "%-16s %-8s %-8s %-8s %-8s %-8s %-8s %-5s %-5s %5s | "
  51             "%-5s %-5s %-8s %-6s %-8s %-12s "
  52             "%-6s %-6s %-6s %-6s %-6s %-8s %-8s %-8s %-5s | "
  53             "%-6s %-6s %-8s %-8s %-6s %-6s %-5s %-8s %-8s\n",
  54             "dbuf", "arcbuf", "dnode", "pool", "objset", "object", "level",
  55             "blkid", "offset", "dbsize", "meta", "state", "dbholds", "list",
  56             "atype", "flags", "count", "asize", "access",
  57             "mru", "gmru", "mfu", "gmfu", "l2", "l2_dattr", "l2_asize",
  58             "l2_comp", "aholds", "dtype", "btype", "data_bs", "meta_bs",
  59             "bsize", "lvls", "dholds", "blocks", "dsize");
  60
  61         return (0);
  62 }
  63
  64 int
  65 __dbuf_stats_hash_table_data(char *buf, size_t size, dmu_buf_impl_t *db)
  66 {
  67         arc_buf_info_t abi = { 0 };
  68         dmu_object_info_t doi = { 0 };
  69         dnode_t *dn = DB_DNODE(db);
  70         size_t nwritten;
  71
  72         if (db->db_buf)
  73                 arc_buf_info(db->db_buf, &abi, zfs_dbuf_state_index);
  74
  75         if (dn)
  76                 __dmu_object_info_from_dnode(dn, &doi);
  77
  78         nwritten = snprintf(buf, size,
  79             "%-16s %-8llu %-8lld %-8lld %-8lld %-8llu %-8llu %-5d %-5d %-5lu | "
  80             "%-5d %-5d 0x%-6x %-6lu %-8llu %-12llu "
  81             "%-6lu %-6lu %-6lu %-6lu %-6lu %-8llu %-8llu %-8d %-5lu | "
  82             "%-6d %-6d %-8lu %-8lu %-6llu %-6lu %-5lu %-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             !!dbuf_is_metadata(db),
  92             db->db_state,
  93             (ulong_t)refcount_count(&db->db_holds),
  94             /* arc_buf_info_t */
  95             abi.abi_state_type,
  96             abi.abi_state_contents,
  97             abi.abi_flags,
  98             (ulong_t)abi.abi_datacnt,
  99             (u_longlong_t)abi.abi_size,
 100             (u_longlong_t)abi.abi_access,
 101             (ulong_t)abi.abi_mru_hits,
 102             (ulong_t)abi.abi_mru_ghost_hits,
 103             (ulong_t)abi.abi_mfu_hits,
 104             (ulong_t)abi.abi_mfu_ghost_hits,
 105             (ulong_t)abi.abi_l2arc_hits,
 106             (u_longlong_t)abi.abi_l2arc_dattr,
 107             (u_longlong_t)abi.abi_l2arc_asize,
 108             abi.abi_l2arc_compress,
 109             (ulong_t)abi.abi_holds,
 110             /* dmu_object_info_t */
 111             doi.doi_type,
 112             doi.doi_bonus_type,
 113             (ulong_t)doi.doi_data_block_size,
 114             (ulong_t)doi.doi_metadata_block_size,
 115             (u_longlong_t)doi.doi_bonus_size,
 116             (ulong_t)doi.doi_indirection,
 117             (ulong_t)refcount_count(&dn->dn_holds),
 118             (u_longlong_t)doi.doi_fill_count,
 119             (u_longlong_t)doi.doi_max_offset);
 120
 121         if (nwritten >= size)
 122                 return (size);
 123
 124         return (nwritten + 1);
 125 }
 126
 127 static int
 128 dbuf_stats_hash_table_data(char *buf, size_t size, void *data)
 129 {
 130         dbuf_stats_t *dsh = (dbuf_stats_t *)data;
 131         dbuf_hash_table_t *h = dsh->hash;
 132         dmu_buf_impl_t *db;
 133         int length, error = 0;
 134
 135         ASSERT3S(dsh->idx, >=, 0);
 136         ASSERT3S(dsh->idx, <=, h->hash_table_mask);
 137         memset(buf, 0, size);
 138
 139         mutex_enter(DBUF_HASH_MUTEX(h, dsh->idx));
 140         for (db = h->hash_table[dsh->idx]; db != NULL; db = db->db_hash_next) {
 141                 /*
 142                  * Returning ENOMEM will cause the data and header functions
 143                  * to be called with a larger scratch buffers.
 144                  */
 145                 if (size < 512) {
 146                         error = ENOMEM;
 147                         break;
 148                 }
 149
 150                 mutex_enter(&db->db_mtx);
 151
 152                 if (db->db_state != DB_EVICTING) {
 153                         length = __dbuf_stats_hash_table_data(buf, size, db);
 154                         buf += length;
 155                         size -= length;
 156                 }
 157
 158                 mutex_exit(&db->db_mtx);
 159         }
 160         mutex_exit(DBUF_HASH_MUTEX(h, dsh->idx));
 161
 162         return (error);
 163 }
 164
 165 static void *
 166 dbuf_stats_hash_table_addr(kstat_t *ksp, loff_t n)
 167 {
 168         dbuf_stats_t *dsh = ksp->ks_private;
 169
 170         ASSERT(MUTEX_HELD(&dsh->lock));
 171
 172         if (n <= dsh->hash->hash_table_mask) {
 173                 dsh->idx = n;
 174                 return (dsh);
 175         }
 176
 177         return (NULL);
 178 }
 179
 180 static void
 181 dbuf_stats_hash_table_init(dbuf_hash_table_t *hash)
 182 {
 183         dbuf_stats_t *dsh = &dbuf_stats_hash_table;
 184         kstat_t *ksp;
 185
 186         mutex_init(&dsh->lock, NULL, MUTEX_DEFAULT, NULL);
 187         dsh->hash = hash;
 188
 189         ksp = kstat_create("zfs", 0, "dbufs", "misc",
 190             KSTAT_TYPE_RAW, 0, KSTAT_FLAG_VIRTUAL);
 191         dsh->kstat = ksp;
 192
 193         if (ksp) {
 194                 ksp->ks_lock = &dsh->lock;
 195                 ksp->ks_ndata = UINT32_MAX;
 196                 ksp->ks_private = dsh;
 197                 kstat_set_raw_ops(ksp, dbuf_stats_hash_table_headers,
 198                     dbuf_stats_hash_table_data, dbuf_stats_hash_table_addr);
 199                 kstat_install(ksp);
 200         }
 201 }
 202
 203 static void
 204 dbuf_stats_hash_table_destroy(void)
 205 {
 206         dbuf_stats_t *dsh = &dbuf_stats_hash_table;
 207         kstat_t *ksp;
 208
 209         ksp = dsh->kstat;
 210         if (ksp)
 211                 kstat_delete(ksp);
 212
 213         mutex_destroy(&dsh->lock);
 214 }
 215
 216 void
 217 dbuf_stats_init(dbuf_hash_table_t *hash)
 218 {
 219         dbuf_stats_hash_table_init(hash);
 220 }
 221
 222 void
 223 dbuf_stats_destroy(void)
 224 {
 225         dbuf_stats_hash_table_destroy();
 226 }
 227
 228 #if defined(_KERNEL) && defined(HAVE_SPL)
 229 module_param(zfs_dbuf_state_index, int, 0644);
 230 MODULE_PARM_DESC(zfs_dbuf_state_index, "Calculate arc header index");
 231 #endif