dbuf_stats.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    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 https://opensource.org/licenses/CDDL-1.0.
   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             "%-96s | %-119s | %s\n"
   50             "%-16s %-8s %-8s %-8s %-8s %-10s %-8s %-5s %-5s %-7s %3s | "
   51             "%-5s %-5s %-9s %-6s %-8s %-12s "
   52             "%-6s %-6s %-6s %-6s %-6s %-8s %-8s %-8s %-6s | "
   53             "%-6s %-6s %-8s %-8s %-6s %-6s %-6s %-8s %-8s\n",
   54             "dbuf", "arcbuf", "dnode", "pool", "objset", "object", "level",
   55             "blkid", "offset", "dbsize", "meta", "state", "dbholds", "dbc",
   56             "list", "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 static 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         __dmu_object_info_from_dnode(dn, &doi);
   76 
   77         nwritten = snprintf(buf, size,
   78             "%-16s %-8llu %-8lld %-8lld %-8lld %-10llu %-8llu %-5d %-5d "
   79             "%-7lu %-3d | %-5d %-5d 0x%-7x %-6lu %-8llu %-12llu "
   80             "%-6lu %-6lu %-6lu %-6lu %-6lu %-8llu %-8llu %-8d %-6lu | "
   81             "%-6d %-6d %-8lu %-8lu %-6llu %-6lu %-6lu %-8llu %-8llu\n",
   82             /* dmu_buf_impl_t */
   83             spa_name(dn->dn_objset->os_spa),
   84             (u_longlong_t)dmu_objset_id(db->db_objset),
   85             (longlong_t)db->db.db_object,
   86             (longlong_t)db->db_level,
   87             (longlong_t)db->db_blkid,
   88             (u_longlong_t)db->db.db_offset,
   89             (u_longlong_t)db->db.db_size,
   90             !!dbuf_is_metadata(db),
   91             db->db_state,
   92             (ulong_t)zfs_refcount_count(&db->db_holds),
   93             multilist_link_active(&db->db_cache_link),
   94             /* arc_buf_info_t */
   95             abi.abi_state_type,
   96             abi.abi_state_contents,
   97             abi.abi_flags,
   98             (ulong_t)abi.abi_bufcnt,
   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)zfs_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         if (size)
  138                 buf[0] = 0;
  139 
  140         mutex_enter(DBUF_HASH_MUTEX(h, dsh->idx));
  141         for (db = h->hash_table[dsh->idx]; db != NULL; db = db->db_hash_next) {
  142                 /*
  143                  * Returning ENOMEM will cause the data and header functions
  144                  * to be called with a larger scratch buffers.
  145                  */
  146                 if (size < 512) {
  147                         error = SET_ERROR(ENOMEM);
  148                         break;
  149                 }
  150 
  151                 mutex_enter(&db->db_mtx);
  152 
  153                 if (db->db_state != DB_EVICTING) {
  154                         length = __dbuf_stats_hash_table_data(buf, size, db);
  155                         buf += length;
  156                         size -= length;
  157                 }
  158 
  159                 mutex_exit(&db->db_mtx);
  160         }
  161         mutex_exit(DBUF_HASH_MUTEX(h, dsh->idx));
  162 
  163         return (error);
  164 }
  165 
  166 static void *
  167 dbuf_stats_hash_table_addr(kstat_t *ksp, loff_t n)
  168 {
  169         dbuf_stats_t *dsh = ksp->ks_private;
  170 
  171         ASSERT(MUTEX_HELD(&dsh->lock));
  172 
  173         if (n <= dsh->hash->hash_table_mask) {
  174                 dsh->idx = n;
  175                 return (dsh);
  176         }
  177 
  178         return (NULL);
  179 }
  180 
  181 static void
  182 dbuf_stats_hash_table_init(dbuf_hash_table_t *hash)
  183 {
  184         dbuf_stats_t *dsh = &dbuf_stats_hash_table;
  185         kstat_t *ksp;
  186 
  187         mutex_init(&dsh->lock, NULL, MUTEX_DEFAULT, NULL);
  188         dsh->hash = hash;
  189 
  190         ksp = kstat_create("zfs", 0, "dbufs", "misc",
  191             KSTAT_TYPE_RAW, 0, KSTAT_FLAG_VIRTUAL);
  192         dsh->kstat = ksp;
  193 
  194         if (ksp) {
  195                 ksp->ks_lock = &dsh->lock;
  196                 ksp->ks_ndata = UINT32_MAX;
  197                 ksp->ks_private = dsh;
  198                 kstat_set_raw_ops(ksp, dbuf_stats_hash_table_headers,
  199                     dbuf_stats_hash_table_data, dbuf_stats_hash_table_addr);
  200                 kstat_install(ksp);
  201         }
  202 }
  203 
  204 static void
  205 dbuf_stats_hash_table_destroy(void)
  206 {
  207         dbuf_stats_t *dsh = &dbuf_stats_hash_table;
  208         kstat_t *ksp;
  209 
  210         ksp = dsh->kstat;
  211         if (ksp)
  212                 kstat_delete(ksp);
  213 
  214         mutex_destroy(&dsh->lock);
  215 }
  216 
  217 void
  218 dbuf_stats_init(dbuf_hash_table_t *hash)
  219 {
  220         dbuf_stats_hash_table_init(hash);
  221 }
  222 
  223 void
  224 dbuf_stats_destroy(void)
  225 {
  226         dbuf_stats_hash_table_destroy();
  227 }
  228 
  229 ZFS_MODULE_PARAM(zfs, zfs_, dbuf_state_index, INT, ZMOD_RW,
  230         "Calculate arc header index");

Cache object: 2c883a375078960df5fe50fc6b1f397c

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/contrib/openzfs/module/zfs/dbuf_stats.c

FreeBSD/Linux Kernel Cross Reference
sys/contrib/openzfs/module/zfs/dbuf_stats.c