[mirror_zfs-debian.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);

	__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_bufcnt,
	    (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);

		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_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
a08ee875 LG	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	{
ea04106b	48	(void) snprintf(buf, size,
a08ee875 LG	49	"%-88s \| %-124s \| %s\n"
a08ee875 LG	50	"%-16s %-8s %-8s %-8s %-8s %-8s %-8s %-5s %-5s %5s \| "
e10b0808	51	"%-5s %-5s %-8s %-6s %-8s %-12s "
a08ee875 LG	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",
e10b0808	56	"atype", "flags", "count", "asize", "access",
a08ee875 LG	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");
a08ee875 LG	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);
ea04106b	70	size_t nwritten;
a08ee875 LG	71
	72	if (db->db_buf)
	73	arc_buf_info(db->db_buf, &abi, zfs_dbuf_state_index);
	74
cae5b340	75	__dmu_object_info_from_dnode(dn, &doi);
a08ee875	76
ea04106b	77	nwritten = snprintf(buf, size,
a08ee875	78	"%-16s %-8llu %-8lld %-8lld %-8lld %-8llu %-8llu %-5d %-5d %-5lu \| "
e10b0808	79	"%-5d %-5d 0x%-6x %-6lu %-8llu %-12llu "
a08ee875 LG	80	"%-6lu %-6lu %-6lu %-6lu %-6lu %-8llu %-8llu %-8d %-5lu \| "
	81	"%-6d %-6d %-8lu %-8lu %-6llu %-6lu %-5lu %-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)refcount_count(&db->db_holds),
	93	/* arc_buf_info_t */
	94	abi.abi_state_type,
	95	abi.abi_state_contents,
a08ee875	96	abi.abi_flags,
cae5b340	97	(ulong_t)abi.abi_bufcnt,
a08ee875 LG	98	(u_longlong_t)abi.abi_size,
	99	(u_longlong_t)abi.abi_access,
	100	(ulong_t)abi.abi_mru_hits,
	101	(ulong_t)abi.abi_mru_ghost_hits,
	102	(ulong_t)abi.abi_mfu_hits,
	103	(ulong_t)abi.abi_mfu_ghost_hits,
	104	(ulong_t)abi.abi_l2arc_hits,
	105	(u_longlong_t)abi.abi_l2arc_dattr,
	106	(u_longlong_t)abi.abi_l2arc_asize,
	107	abi.abi_l2arc_compress,
	108	(ulong_t)abi.abi_holds,
	109	/* dmu_object_info_t */
	110	doi.doi_type,
	111	doi.doi_bonus_type,
	112	(ulong_t)doi.doi_data_block_size,
	113	(ulong_t)doi.doi_metadata_block_size,
	114	(u_longlong_t)doi.doi_bonus_size,
	115	(ulong_t)doi.doi_indirection,
	116	(ulong_t)refcount_count(&dn->dn_holds),
	117	(u_longlong_t)doi.doi_fill_count,
	118	(u_longlong_t)doi.doi_max_offset);
a08ee875	119
ea04106b AX	120	if (nwritten >= size)
	121	return (size);
	122
	123	return (nwritten + 1);
a08ee875 LG	124	}
	125
	126	static int
	127	dbuf_stats_hash_table_data(char buf, size_t size, void data)
	128	{
	129	dbuf_stats_t dsh = (dbuf_stats_t )data;
	130	dbuf_hash_table_t *h = dsh->hash;
	131	dmu_buf_impl_t *db;
	132	int length, error = 0;
	133
	134	ASSERT3S(dsh->idx, >=, 0);
	135	ASSERT3S(dsh->idx, <=, h->hash_table_mask);
	136	memset(buf, 0, size);
	137
	138	mutex_enter(DBUF_HASH_MUTEX(h, dsh->idx));
	139	for (db = h->hash_table[dsh->idx]; db != NULL; db = db->db_hash_next) {
	140	/*
	141	* Returning ENOMEM will cause the data and header functions
	142	* to be called with a larger scratch buffers.
	143	*/
	144	if (size < 512) {
	145	error = ENOMEM;
	146	break;
	147	}
	148
	149	mutex_enter(&db->db_mtx);
a08ee875	150
ea04106b AX	151	if (db->db_state != DB_EVICTING) {
	152	length = __dbuf_stats_hash_table_data(buf, size, db);
	153	buf += length;
	154	size -= length;
	155	}
a08ee875 LG	156
a08ee875 LG	157	mutex_exit(&db->db_mtx);
a08ee875 LG	158	}
	159	mutex_exit(DBUF_HASH_MUTEX(h, dsh->idx));
	160
	161	return (error);
	162	}
	163
	164	static void *
	165	dbuf_stats_hash_table_addr(kstat_t *ksp, loff_t n)
	166	{
	167	dbuf_stats_t *dsh = ksp->ks_private;
	168
	169	ASSERT(MUTEX_HELD(&dsh->lock));
	170
	171	if (n <= dsh->hash->hash_table_mask) {
	172	dsh->idx = n;
	173	return (dsh);
	174	}
	175
	176	return (NULL);
	177	}
	178
	179	static void
	180	dbuf_stats_hash_table_init(dbuf_hash_table_t *hash)
	181	{
	182	dbuf_stats_t *dsh = &dbuf_stats_hash_table;
	183	kstat_t *ksp;
	184
	185	mutex_init(&dsh->lock, NULL, MUTEX_DEFAULT, NULL);
	186	dsh->hash = hash;
	187
	188	ksp = kstat_create("zfs", 0, "dbufs", "misc",
	189	KSTAT_TYPE_RAW, 0, KSTAT_FLAG_VIRTUAL);
	190	dsh->kstat = ksp;
	191
	192	if (ksp) {
	193	ksp->ks_lock = &dsh->lock;
	194	ksp->ks_ndata = UINT32_MAX;
	195	ksp->ks_private = dsh;
	196	kstat_set_raw_ops(ksp, dbuf_stats_hash_table_headers,
	197	dbuf_stats_hash_table_data, dbuf_stats_hash_table_addr);
	198	kstat_install(ksp);
	199	}
	200	}
	201
	202	static void
	203	dbuf_stats_hash_table_destroy(void)
	204	{
	205	dbuf_stats_t *dsh = &dbuf_stats_hash_table;
	206	kstat_t *ksp;
	207
	208	ksp = dsh->kstat;
	209	if (ksp)
	210	kstat_delete(ksp);
	211
	212	mutex_destroy(&dsh->lock);
	213	}
	214
	215	void
	216	dbuf_stats_init(dbuf_hash_table_t *hash)
	217	{
	218	dbuf_stats_hash_table_init(hash);
	219	}
	220
	221	void
222	dbuf_stats_destroy(void)
223	{
224	dbuf_stats_hash_table_destroy();
225	}
226
227	#if defined(_KERNEL) && defined(HAVE_SPL)
228	module_param(zfs_dbuf_state_index, int, 0644);
229	MODULE_PARM_DESC(zfs_dbuf_state_index, "Calculate arc header index");
230	#endif