[linux-2.6-block.git] / fs / xfs / xfs_stats.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 */
#include "xfs.h"
#include <linux/proc_fs.h>

struct xstats xfsstats;

static int counter_val(struct xfsstats __percpu *stats, int idx)
{
	int val = 0, cpu;

	for_each_possible_cpu(cpu)
		val += *(((__u32 *)per_cpu_ptr(stats, cpu) + idx));
	return val;
}

int xfs_stats_format(struct xfsstats __percpu *stats, char *buf)
{
	int		i, j;
	int		len = 0;
	uint64_t	xs_xstrat_bytes = 0;
	uint64_t	xs_write_bytes = 0;
	uint64_t	xs_read_bytes = 0;

	static const struct xstats_entry {
		char	*desc;
		int	endpoint;
	} xstats[] = {
		{ "extent_alloc",	XFSSTAT_END_EXTENT_ALLOC	},
		{ "abt",		XFSSTAT_END_ALLOC_BTREE		},
		{ "blk_map",		XFSSTAT_END_BLOCK_MAPPING	},
		{ "bmbt",		XFSSTAT_END_BLOCK_MAP_BTREE	},
		{ "dir",		XFSSTAT_END_DIRECTORY_OPS	},
		{ "trans",		XFSSTAT_END_TRANSACTIONS	},
		{ "ig",			XFSSTAT_END_INODE_OPS		},
		{ "log",		XFSSTAT_END_LOG_OPS		},
		{ "push_ail",		XFSSTAT_END_TAIL_PUSHING	},
		{ "xstrat",		XFSSTAT_END_WRITE_CONVERT	},
		{ "rw",			XFSSTAT_END_READ_WRITE_OPS	},
		{ "attr",		XFSSTAT_END_ATTRIBUTE_OPS	},
		{ "icluster",		XFSSTAT_END_INODE_CLUSTER	},
		{ "vnodes",		XFSSTAT_END_VNODE_OPS		},
		{ "buf",		XFSSTAT_END_BUF			},
		{ "abtb2",		XFSSTAT_END_ABTB_V2		},
		{ "abtc2",		XFSSTAT_END_ABTC_V2		},
		{ "bmbt2",		XFSSTAT_END_BMBT_V2		},
		{ "ibt2",		XFSSTAT_END_IBT_V2		},
		{ "fibt2",		XFSSTAT_END_FIBT_V2		},
		{ "rmapbt",		XFSSTAT_END_RMAP_V2		},
		{ "refcntbt",		XFSSTAT_END_REFCOUNT		},
		/* we print both series of quota information together */
		{ "qm",			XFSSTAT_END_QM			},
	};

	/* Loop over all stats groups */

	for (i = j = 0; i < ARRAY_SIZE(xstats); i++) {
		len += snprintf(buf + len, PATH_MAX - len, "%s",
				xstats[i].desc);
		/* inner loop does each group */
		for (; j < xstats[i].endpoint; j++)
			len += snprintf(buf + len, PATH_MAX - len, " %u",
					counter_val(stats, j));
		len += snprintf(buf + len, PATH_MAX - len, "\n");
	}
	/* extra precision counters */
	for_each_possible_cpu(i) {
		xs_xstrat_bytes += per_cpu_ptr(stats, i)->s.xs_xstrat_bytes;
		xs_write_bytes += per_cpu_ptr(stats, i)->s.xs_write_bytes;
		xs_read_bytes += per_cpu_ptr(stats, i)->s.xs_read_bytes;
	}

	len += snprintf(buf + len, PATH_MAX-len, "xpc %Lu %Lu %Lu\n",
			xs_xstrat_bytes, xs_write_bytes, xs_read_bytes);
	len += snprintf(buf + len, PATH_MAX-len, "debug %u\n",
#if defined(DEBUG)
		1);
#else
		0);
#endif

	return len;
}

void xfs_stats_clearall(struct xfsstats __percpu *stats)
{
	int		c;
	uint32_t	vn_active;

	xfs_notice(NULL, "Clearing xfsstats");
	for_each_possible_cpu(c) {
		preempt_disable();
		/* save vn_active, it's a universal truth! */
		vn_active = per_cpu_ptr(stats, c)->s.vn_active;
		memset(per_cpu_ptr(stats, c), 0, sizeof(*stats));
		per_cpu_ptr(stats, c)->s.vn_active = vn_active;
		preempt_enable();
	}
}

#ifdef CONFIG_PROC_FS
/* legacy quota interfaces */
#ifdef CONFIG_XFS_QUOTA
static int xqm_proc_show(struct seq_file *m, void *v)
{
	/* maximum; incore; ratio free to inuse; freelist */
	seq_printf(m, "%d\t%d\t%d\t%u\n",
		   0, counter_val(xfsstats.xs_stats, XFSSTAT_END_XQMSTAT),
		   0, counter_val(xfsstats.xs_stats, XFSSTAT_END_XQMSTAT + 1));
	return 0;
}

/* legacy quota stats interface no 2 */
static int xqmstat_proc_show(struct seq_file *m, void *v)
{
	int j;

	seq_printf(m, "qm");
	for (j = XFSSTAT_END_IBT_V2; j < XFSSTAT_END_XQMSTAT; j++)
		seq_printf(m, " %u", counter_val(xfsstats.xs_stats, j));
	seq_putc(m, '\n');
	return 0;
}
#endif /* CONFIG_XFS_QUOTA */

int
xfs_init_procfs(void)
{
	if (!proc_mkdir("fs/xfs", NULL))
		return -ENOMEM;

	if (!proc_symlink("fs/xfs/stat", NULL,
			  "/sys/fs/xfs/stats/stats"))
		goto out;

#ifdef CONFIG_XFS_QUOTA
	if (!proc_create_single("fs/xfs/xqmstat", 0, NULL, xqmstat_proc_show))
		goto out;
	if (!proc_create_single("fs/xfs/xqm", 0, NULL, xqm_proc_show))
		goto out;
#endif
	return 0;

out:
	remove_proc_subtree("fs/xfs", NULL);
	return -ENOMEM;
}

void
xfs_cleanup_procfs(void)
{
	remove_proc_subtree("fs/xfs", NULL);
}
#endif /* CONFIG_PROC_FS */
Commit	Line	Data
0b61f8a4	1	// SPDX-License-Identifier: GPL-2.0
1da177e4	2	/*
7b718769 NS	3	* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
7b718769 NS	4	* All Rights Reserved.
1da177e4	5	*/
1da177e4 LT	6	#include "xfs.h"
	7	#include <linux/proc_fs.h>
	8
80529c45	9	struct xstats xfsstats;
1da177e4	10
80529c45	11	static int counter_val(struct xfsstats __percpu *stats, int idx)
48776fd2 CH	12	{
	13	int val = 0, cpu;
	14
	15	for_each_possible_cpu(cpu)
80529c45	16	val += (((__u32 )per_cpu_ptr(stats, cpu) + idx));
48776fd2 CH	17	return val;
	18	}
	19
80529c45	20	int xfs_stats_format(struct xfsstats __percpu stats, char buf)
bb230c12 BD	21	{
	22	int i, j;
	23	int len = 0;
c8ce540d DW	24	uint64_t xs_xstrat_bytes = 0;
	25	uint64_t xs_write_bytes = 0;
	26	uint64_t xs_read_bytes = 0;
bb230c12 BD	27
	28	static const struct xstats_entry {
	29	char *desc;
	30	int endpoint;
	31	} xstats[] = {
	32	{ "extent_alloc", XFSSTAT_END_EXTENT_ALLOC },
	33	{ "abt", XFSSTAT_END_ALLOC_BTREE },
	34	{ "blk_map", XFSSTAT_END_BLOCK_MAPPING },
	35	{ "bmbt", XFSSTAT_END_BLOCK_MAP_BTREE },
	36	{ "dir", XFSSTAT_END_DIRECTORY_OPS },
	37	{ "trans", XFSSTAT_END_TRANSACTIONS },
	38	{ "ig", XFSSTAT_END_INODE_OPS },
	39	{ "log", XFSSTAT_END_LOG_OPS },
	40	{ "push_ail", XFSSTAT_END_TAIL_PUSHING },
	41	{ "xstrat", XFSSTAT_END_WRITE_CONVERT },
	42	{ "rw", XFSSTAT_END_READ_WRITE_OPS },
	43	{ "attr", XFSSTAT_END_ATTRIBUTE_OPS },
	44	{ "icluster", XFSSTAT_END_INODE_CLUSTER },
	45	{ "vnodes", XFSSTAT_END_VNODE_OPS },
	46	{ "buf", XFSSTAT_END_BUF },
	47	{ "abtb2", XFSSTAT_END_ABTB_V2 },
	48	{ "abtc2", XFSSTAT_END_ABTC_V2 },
	49	{ "bmbt2", XFSSTAT_END_BMBT_V2 },
	50	{ "ibt2", XFSSTAT_END_IBT_V2 },
	51	{ "fibt2", XFSSTAT_END_FIBT_V2 },
00f4e4f9	52	{ "rmapbt", XFSSTAT_END_RMAP_V2 },
46eeb521	53	{ "refcntbt", XFSSTAT_END_REFCOUNT },
bb230c12 BD	54	/* we print both series of quota information together */
	55	{ "qm", XFSSTAT_END_QM },
	56	};
	57
	58	/* Loop over all stats groups */
	59
	60	for (i = j = 0; i < ARRAY_SIZE(xstats); i++) {
	61	len += snprintf(buf + len, PATH_MAX - len, "%s",
	62	xstats[i].desc);
	63	/* inner loop does each group */
	64	for (; j < xstats[i].endpoint; j++)
	65	len += snprintf(buf + len, PATH_MAX - len, " %u",
80529c45	66	counter_val(stats, j));
bb230c12 BD	67	len += snprintf(buf + len, PATH_MAX - len, "\n");
	68	}
	69	/* extra precision counters */
	70	for_each_possible_cpu(i) {
11ef38af DC	71	xs_xstrat_bytes += per_cpu_ptr(stats, i)->s.xs_xstrat_bytes;
	72	xs_write_bytes += per_cpu_ptr(stats, i)->s.xs_write_bytes;
	73	xs_read_bytes += per_cpu_ptr(stats, i)->s.xs_read_bytes;
bb230c12 BD	74	}
	75
	76	len += snprintf(buf + len, PATH_MAX-len, "xpc %Lu %Lu %Lu\n",
	77	xs_xstrat_bytes, xs_write_bytes, xs_read_bytes);
	78	len += snprintf(buf + len, PATH_MAX-len, "debug %u\n",
	79	#if defined(DEBUG)
	80	1);
	81	#else
	82	0);
	83	#endif
	84
	85	return len;
	86	}
	87
80529c45	88	void xfs_stats_clearall(struct xfsstats __percpu *stats)
bb230c12 BD	89	{
bb230c12 BD	90	int c;
c8ce540d	91	uint32_t vn_active;
bb230c12 BD	92
	93	xfs_notice(NULL, "Clearing xfsstats");
	94	for_each_possible_cpu(c) {
	95	preempt_disable();
	96	/* save vn_active, it's a universal truth! */
11ef38af	97	vn_active = per_cpu_ptr(stats, c)->s.vn_active;
80529c45	98	memset(per_cpu_ptr(stats, c), 0, sizeof(*stats));
11ef38af	99	per_cpu_ptr(stats, c)->s.vn_active = vn_active;
bb230c12 BD	100	preempt_enable();
	101	}
	102	}
	103
5ef03dbd	104	#ifdef CONFIG_PROC_FS
48776fd2 CH	105	/* legacy quota interfaces */
	106	#ifdef CONFIG_XFS_QUOTA
	107	static int xqm_proc_show(struct seq_file m, void v)
	108	{
	109	/* maximum; incore; ratio free to inuse; freelist */
	110	seq_printf(m, "%d\t%d\t%d\t%u\n",
80529c45 BD	111	0, counter_val(xfsstats.xs_stats, XFSSTAT_END_XQMSTAT),
80529c45 BD	112	0, counter_val(xfsstats.xs_stats, XFSSTAT_END_XQMSTAT + 1));
48776fd2 CH	113	return 0;
	114	}
	115
48776fd2 CH	116	/* legacy quota stats interface no 2 */
	117	static int xqmstat_proc_show(struct seq_file m, void v)
	118	{
	119	int j;
	120
	121	seq_printf(m, "qm");
	122	for (j = XFSSTAT_END_IBT_V2; j < XFSSTAT_END_XQMSTAT; j++)
80529c45	123	seq_printf(m, " %u", counter_val(xfsstats.xs_stats, j));
48776fd2 CH	124	seq_putc(m, '\n');
	125	return 0;
	126	}
48776fd2 CH	127	#endif /* CONFIG_XFS_QUOTA */
48776fd2 CH	128
9f8868ff	129	int
1da177e4 LT	130	xfs_init_procfs(void)
	131	{
	132	if (!proc_mkdir("fs/xfs", NULL))
9e92054e	133	return -ENOMEM;
9f8868ff	134
32f0ea05 BD	135	if (!proc_symlink("fs/xfs/stat", NULL,
32f0ea05 BD	136	"/sys/fs/xfs/stats/stats"))
9e92054e	137	goto out;
32f0ea05	138
48776fd2	139	#ifdef CONFIG_XFS_QUOTA
3f3942ac	140	if (!proc_create_single("fs/xfs/xqmstat", 0, NULL, xqmstat_proc_show))
9e92054e	141	goto out;
3f3942ac	142	if (!proc_create_single("fs/xfs/xqm", 0, NULL, xqm_proc_show))
9e92054e	143	goto out;
48776fd2	144	#endif
9f8868ff CH	145	return 0;
9f8868ff CH	146
9e92054e ES	147	out:
9e92054e ES	148	remove_proc_subtree("fs/xfs", NULL);
9f8868ff	149	return -ENOMEM;
1da177e4 LT	150	}
	151
	152	void
	153	xfs_cleanup_procfs(void)
	154	{
9e92054e	155	remove_proc_subtree("fs/xfs", NULL);
1da177e4	156	}
985ef4dc	157	#endif /* CONFIG_PROC_FS */