[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 %-6s %-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", "index", "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 %-6lld 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,
	    (longlong_t)abi.abi_state_index,
	    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
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"
	50	"%-16s %-8s %-8s %-8s %-8s %-8s %-8s %-5s %-5s %5s \| "
	51	"%-5s %-5s %-6s %-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", "index", "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");
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
	75	if (dn)
	76	__dmu_object_info_from_dnode(dn, &doi);
	77
ea04106b	78	nwritten = snprintf(buf, size,
a08ee875 LG	79	"%-16s %-8llu %-8lld %-8lld %-8lld %-8llu %-8llu %-5d %-5d %-5lu \| "
	80	"%-5d %-5d %-6lld 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	(longlong_t)abi.abi_state_index,
	98	abi.abi_flags,
	99	(ulong_t)abi.abi_datacnt,
	100	(u_longlong_t)abi.abi_size,
	101	(u_longlong_t)abi.abi_access,
	102	(ulong_t)abi.abi_mru_hits,
	103	(ulong_t)abi.abi_mru_ghost_hits,
	104	(ulong_t)abi.abi_mfu_hits,
	105	(ulong_t)abi.abi_mfu_ghost_hits,
	106	(ulong_t)abi.abi_l2arc_hits,
	107	(u_longlong_t)abi.abi_l2arc_dattr,
	108	(u_longlong_t)abi.abi_l2arc_asize,
	109	abi.abi_l2arc_compress,
	110	(ulong_t)abi.abi_holds,
	111	/* dmu_object_info_t */
	112	doi.doi_type,
	113	doi.doi_bonus_type,
	114	(ulong_t)doi.doi_data_block_size,
	115	(ulong_t)doi.doi_metadata_block_size,
	116	(u_longlong_t)doi.doi_bonus_size,
	117	(ulong_t)doi.doi_indirection,
	118	(ulong_t)refcount_count(&dn->dn_holds),
	119	(u_longlong_t)doi.doi_fill_count,
	120	(u_longlong_t)doi.doi_max_offset);
a08ee875	121
ea04106b AX	122	if (nwritten >= size)
	123	return (size);
	124
	125	return (nwritten + 1);
a08ee875 LG	126	}
	127
	128	static int
	129	dbuf_stats_hash_table_data(char buf, size_t size, void data)
	130	{
	131	dbuf_stats_t dsh = (dbuf_stats_t )data;
	132	dbuf_hash_table_t *h = dsh->hash;
	133	dmu_buf_impl_t *db;
	134	int length, error = 0;
	135
	136	ASSERT3S(dsh->idx, >=, 0);
	137	ASSERT3S(dsh->idx, <=, h->hash_table_mask);
	138	memset(buf, 0, size);
	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 = ENOMEM;
	148	break;
	149	}
	150
	151	mutex_enter(&db->db_mtx);
	152	mutex_exit(DBUF_HASH_MUTEX(h, dsh->idx));
	153
ea04106b AX	154	if (db->db_state != DB_EVICTING) {
	155	length = __dbuf_stats_hash_table_data(buf, size, db);
	156	buf += length;
	157	size -= length;
	158	}
a08ee875 LG	159
	160	mutex_exit(&db->db_mtx);
	161	mutex_enter(DBUF_HASH_MUTEX(h, dsh->idx));
	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	#if defined(_KERNEL) && defined(HAVE_SPL)
232	module_param(zfs_dbuf_state_index, int, 0644);
233	MODULE_PARM_DESC(zfs_dbuf_state_index, "Calculate arc header index");
234	#endif