[mirror_zfs.git] / module / zfs / dbuf_stats.c

/*
 * 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
 */

#include <sys/zfs_context.h>
#include <sys/dbuf.h>
#include <sys/dmu_objset.h>

/*
 * Calculate the index of the arc header for the state, disabled by default.
 */
int zfs_dbuf_state_index = 0;

/*
 * ==========================================================================
 * Dbuf Hash Read Routines
 * ==========================================================================
 */
typedef struct dbuf_stats_t {
	kmutex_t		lock;
	kstat_t			*kstat;
	dbuf_hash_table_t	*hash;
	int			idx;
} dbuf_stats_t;

static dbuf_stats_t dbuf_stats_hash_table;

static int
dbuf_stats_hash_table_headers(char *buf, size_t size)
{
	(void) snprintf(buf, size,
	    "%-88s | %-124s | %s\n"
	    "%-16s %-8s %-8s %-8s %-8s %-8s %-8s %-5s %-5s %5s | "
	    "%-5s %-5s %-8s %-6s %-8s %-12s "
	    "%-6s %-6s %-6s %-6s %-6s %-8s %-8s %-8s %-5s | "
	    "%-6s %-6s %-8s %-8s %-6s %-6s %-5s %-8s %-8s\n",
	    "dbuf", "arcbuf", "dnode", "pool", "objset", "object", "level",
	    "blkid", "offset", "dbsize", "meta", "state", "dbholds", "list",
	    "atype", "flags", "count", "asize", "access",
	    "mru", "gmru", "mfu", "gmfu", "l2", "l2_dattr", "l2_asize",
	    "l2_comp", "aholds", "dtype", "btype", "data_bs", "meta_bs",
	    "bsize", "lvls", "dholds", "blocks", "dsize");

	return (0);
}

int
__dbuf_stats_hash_table_data(char *buf, size_t size, dmu_buf_impl_t *db)
{
	arc_buf_info_t abi = { 0 };
	dmu_object_info_t doi = { 0 };
	dnode_t *dn = DB_DNODE(db);
	size_t nwritten;

	if (db->db_buf)
		arc_buf_info(db->db_buf, &abi, zfs_dbuf_state_index);

	if (dn)
		__dmu_object_info_from_dnode(dn, &doi);

	nwritten = snprintf(buf, size,
	    "%-16s %-8llu %-8lld %-8lld %-8lld %-8llu %-8llu %-5d %-5d %-5lu | "
	    "%-5d %-5d 0x%-6x %-6lu %-8llu %-12llu "
	    "%-6lu %-6lu %-6lu %-6lu %-6lu %-8llu %-8llu %-8d %-5lu | "
	    "%-6d %-6d %-8lu %-8lu %-6llu %-6lu %-5lu %-8llu %-8llu\n",
	    /* dmu_buf_impl_t */
	    spa_name(dn->dn_objset->os_spa),
	    (u_longlong_t)dmu_objset_id(db->db_objset),
	    (longlong_t)db->db.db_object,
	    (longlong_t)db->db_level,
	    (longlong_t)db->db_blkid,
	    (u_longlong_t)db->db.db_offset,
	    (u_longlong_t)db->db.db_size,
	    !!dbuf_is_metadata(db),
	    db->db_state,
	    (ulong_t)refcount_count(&db->db_holds),
	    /* arc_buf_info_t */
	    abi.abi_state_type,
	    abi.abi_state_contents,
	    abi.abi_flags,
	    (ulong_t)abi.abi_datacnt,
	    (u_longlong_t)abi.abi_size,
	    (u_longlong_t)abi.abi_access,
	    (ulong_t)abi.abi_mru_hits,
	    (ulong_t)abi.abi_mru_ghost_hits,
	    (ulong_t)abi.abi_mfu_hits,
	    (ulong_t)abi.abi_mfu_ghost_hits,
	    (ulong_t)abi.abi_l2arc_hits,
	    (u_longlong_t)abi.abi_l2arc_dattr,
	    (u_longlong_t)abi.abi_l2arc_asize,
	    abi.abi_l2arc_compress,
	    (ulong_t)abi.abi_holds,
	    /* dmu_object_info_t */
	    doi.doi_type,
	    doi.doi_bonus_type,
	    (ulong_t)doi.doi_data_block_size,
	    (ulong_t)doi.doi_metadata_block_size,
	    (u_longlong_t)doi.doi_bonus_size,
	    (ulong_t)doi.doi_indirection,
	    (ulong_t)refcount_count(&dn->dn_holds),
	    (u_longlong_t)doi.doi_fill_count,
	    (u_longlong_t)doi.doi_max_offset);

	if (nwritten >= size)
		return (size);

	return (nwritten + 1);
}

static int
dbuf_stats_hash_table_data(char *buf, size_t size, void *data)
{
	dbuf_stats_t *dsh = (dbuf_stats_t *)data;
	dbuf_hash_table_t *h = dsh->hash;
	dmu_buf_impl_t *db;
	int length, error = 0;

	ASSERT3S(dsh->idx, >=, 0);
	ASSERT3S(dsh->idx, <=, h->hash_table_mask);
	memset(buf, 0, size);

	mutex_enter(DBUF_HASH_MUTEX(h, dsh->idx));
	for (db = h->hash_table[dsh->idx]; db != NULL; db = db->db_hash_next) {
		/*
		 * Returning ENOMEM will cause the data and header functions
		 * to be called with a larger scratch buffers.
		 */
		if (size < 512) {
			error = ENOMEM;
			break;
		}

		mutex_enter(&db->db_mtx);
		mutex_exit(DBUF_HASH_MUTEX(h, dsh->idx));

		if (db->db_state != DB_EVICTING) {
			length = __dbuf_stats_hash_table_data(buf, size, db);
			buf += length;
			size -= length;
		}

		mutex_exit(&db->db_mtx);
		mutex_enter(DBUF_HASH_MUTEX(h, dsh->idx));
	}
	mutex_exit(DBUF_HASH_MUTEX(h, dsh->idx));

	return (error);
}

static void *
dbuf_stats_hash_table_addr(kstat_t *ksp, loff_t n)
{
	dbuf_stats_t *dsh = ksp->ks_private;

	ASSERT(MUTEX_HELD(&dsh->lock));

	if (n <= dsh->hash->hash_table_mask) {
		dsh->idx = n;
		return (dsh);
	}

	return (NULL);
}

static void
dbuf_stats_hash_table_init(dbuf_hash_table_t *hash)
{
	dbuf_stats_t *dsh = &dbuf_stats_hash_table;
	kstat_t *ksp;

	mutex_init(&dsh->lock, NULL, MUTEX_DEFAULT, NULL);
	dsh->hash = hash;

	ksp = kstat_create("zfs", 0, "dbufs", "misc",
	    KSTAT_TYPE_RAW, 0, KSTAT_FLAG_VIRTUAL);
	dsh->kstat = ksp;

	if (ksp) {
		ksp->ks_lock = &dsh->lock;
		ksp->ks_ndata = UINT32_MAX;
		ksp->ks_private = dsh;
		kstat_set_raw_ops(ksp, dbuf_stats_hash_table_headers,
		    dbuf_stats_hash_table_data, dbuf_stats_hash_table_addr);
		kstat_install(ksp);
	}
}

static void
dbuf_stats_hash_table_destroy(void)
{
	dbuf_stats_t *dsh = &dbuf_stats_hash_table;
	kstat_t *ksp;

	ksp = dsh->kstat;
	if (ksp)
		kstat_delete(ksp);

	mutex_destroy(&dsh->lock);
}

void
dbuf_stats_init(dbuf_hash_table_t *hash)
{
	dbuf_stats_hash_table_init(hash);
}

void
dbuf_stats_destroy(void)
{
	dbuf_stats_hash_table_destroy();
}

#if defined(_KERNEL) && defined(HAVE_SPL)
module_param(zfs_dbuf_state_index, int, 0644);
MODULE_PARM_DESC(zfs_dbuf_state_index, "Calculate arc header index");
#endif
Commit	Line	Data
e0b0ca98 BB	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	{
7b2d78a0	48	(void) snprintf(buf, size,
e0b0ca98 BB	49	"%-88s \| %-124s \| %s\n"
e0b0ca98 BB	50	"%-16s %-8s %-8s %-8s %-8s %-8s %-8s %-5s %-5s %5s \| "
ca0bf58d	51	"%-5s %-5s %-8s %-6s %-8s %-12s "
e0b0ca98 BB	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",
ca0bf58d	56	"atype", "flags", "count", "asize", "access",
d1d7e268 MK	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");
e0b0ca98 BB	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);
aa2ef419	70	size_t nwritten;
e0b0ca98 BB	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
aa2ef419	78	nwritten = snprintf(buf, size,
e0b0ca98	79	"%-16s %-8llu %-8lld %-8lld %-8lld %-8llu %-8llu %-5d %-5d %-5lu \| "
ca0bf58d	80	"%-5d %-5d 0x%-6x %-6lu %-8llu %-12llu "
e0b0ca98 BB	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,
e0b0ca98 BB	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);
e0b0ca98	120
aa2ef419 TC	121	if (nwritten >= size)
	122	return (size);
	123
	124	return (nwritten + 1);
e0b0ca98 BB	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	mutex_exit(DBUF_HASH_MUTEX(h, dsh->idx));
	152
e2c4acde BB	153	if (db->db_state != DB_EVICTING) {
	154	length = __dbuf_stats_hash_table_data(buf, size, db);
	155	buf += length;
	156	size -= length;
	157	}
e0b0ca98 BB	158
	159	mutex_exit(&db->db_mtx);
	160	mutex_enter(DBUF_HASH_MUTEX(h, dsh->idx));
	161	}
	162	mutex_exit(DBUF_HASH_MUTEX(h, dsh->idx));
	163
	164	return (error);
	165	}
	166
	167	static void *
	168	dbuf_stats_hash_table_addr(kstat_t *ksp, loff_t n)
	169	{
	170	dbuf_stats_t *dsh = ksp->ks_private;
	171
d1d7e268	172	ASSERT(MUTEX_HELD(&dsh->lock));
e0b0ca98 BB	173
	174	if (n <= dsh->hash->hash_table_mask) {
	175	dsh->idx = n;
	176	return (dsh);
	177	}
	178
	179	return (NULL);
	180	}
	181
	182	static void
	183	dbuf_stats_hash_table_init(dbuf_hash_table_t *hash)
	184	{
	185	dbuf_stats_t *dsh = &dbuf_stats_hash_table;
	186	kstat_t *ksp;
	187
	188	mutex_init(&dsh->lock, NULL, MUTEX_DEFAULT, NULL);
	189	dsh->hash = hash;
	190
	191	ksp = kstat_create("zfs", 0, "dbufs", "misc",
	192	KSTAT_TYPE_RAW, 0, KSTAT_FLAG_VIRTUAL);
	193	dsh->kstat = ksp;
	194
	195	if (ksp) {
	196	ksp->ks_lock = &dsh->lock;
	197	ksp->ks_ndata = UINT32_MAX;
	198	ksp->ks_private = dsh;
	199	kstat_set_raw_ops(ksp, dbuf_stats_hash_table_headers,
	200	dbuf_stats_hash_table_data, dbuf_stats_hash_table_addr);
	201	kstat_install(ksp);
	202	}
	203	}
	204
	205	static void
	206	dbuf_stats_hash_table_destroy(void)
	207	{
	208	dbuf_stats_t *dsh = &dbuf_stats_hash_table;
	209	kstat_t *ksp;
	210
	211	ksp = dsh->kstat;
	212	if (ksp)
	213	kstat_delete(ksp);
	214
	215	mutex_destroy(&dsh->lock);
	216	}
	217
	218	void
	219	dbuf_stats_init(dbuf_hash_table_t *hash)
	220	{
	221	dbuf_stats_hash_table_init(hash);
	222	}
	223
	224	void
	225	dbuf_stats_destroy(void)
	226	{
	227	dbuf_stats_hash_table_destroy();
	228	}
	229
	230	#if defined(_KERNEL) && defined(HAVE_SPL)
	231	module_param(zfs_dbuf_state_index, int, 0644);
	232	MODULE_PARM_DESC(zfs_dbuf_state_index, "Calculate arc header index");
	233	#endif