[deliverable/linux.git] / fs / xfs / xfs_stats.c

/*
 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#include "xfs.h"
#include <linux/proc_fs.h>

DEFINE_PER_CPU(struct xfsstats, xfsstats);

static int counter_val(int idx)
{
	int val = 0, cpu;

	for_each_possible_cpu(cpu)
		val += *(((__u32 *)&per_cpu(xfsstats, cpu) + idx));
	return val;
}

int xfs_stats_format(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		},
		/* 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(j));
		len += snprintf(buf + len, PATH_MAX - len, "\n");
	}
	/* extra precision counters */
	for_each_possible_cpu(i) {
		xs_xstrat_bytes += per_cpu(xfsstats, i).xs_xstrat_bytes;
		xs_write_bytes += per_cpu(xfsstats, i).xs_write_bytes;
		xs_read_bytes += per_cpu(xfsstats, i).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(void)
{
	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(xfsstats, c).vn_active;
		memset(&per_cpu(xfsstats, c), 0, sizeof(struct xfsstats));
		per_cpu(xfsstats, c).vn_active = vn_active;
		preempt_enable();
	}
}

static int xfs_stat_proc_show(struct seq_file *m, void *v)
{
	int		i, j;
	__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		},
		/* 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++) {
		seq_printf(m, "%s", xstats[i].desc);
		/* inner loop does each group */
		for (; j < xstats[i].endpoint; j++)
			seq_printf(m, " %u", counter_val(j));
		seq_putc(m, '\n');
	}
	/* extra precision counters */
	for_each_possible_cpu(i) {
		xs_xstrat_bytes += per_cpu(xfsstats, i).xs_xstrat_bytes;
		xs_write_bytes += per_cpu(xfsstats, i).xs_write_bytes;
		xs_read_bytes += per_cpu(xfsstats, i).xs_read_bytes;
	}

	seq_printf(m, "xpc %Lu %Lu %Lu\n",
			xs_xstrat_bytes, xs_write_bytes, xs_read_bytes);
	seq_printf(m, "debug %u\n",
#if defined(DEBUG)
		1);
#else
		0);
#endif
	return 0;
}

static int xfs_stat_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, xfs_stat_proc_show, NULL);
}

static const struct file_operations xfs_stat_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= xfs_stat_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

/* 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(XFSSTAT_END_XQMSTAT),
			0,
			counter_val(XFSSTAT_END_XQMSTAT + 1));
	return 0;
}

static int xqm_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, xqm_proc_show, NULL);
}

static const struct file_operations xqm_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= xqm_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

/* 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(j));
	seq_putc(m, '\n');
	return 0;
}

static int xqmstat_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, xqmstat_proc_show, NULL);
}

static const struct file_operations xqmstat_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= xqmstat_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};
#endif /* CONFIG_XFS_QUOTA */

int
xfs_init_procfs(void)
{
	if (!proc_mkdir("fs/xfs", NULL))
		goto out;

	if (!proc_create("fs/xfs/stat", 0, NULL,
			 &xfs_stat_proc_fops))
		goto out_remove_xfs_dir;
#ifdef CONFIG_XFS_QUOTA
	if (!proc_create("fs/xfs/xqmstat", 0, NULL,
			 &xqmstat_proc_fops))
		goto out_remove_stat_file;
	if (!proc_create("fs/xfs/xqm", 0, NULL,
			 &xqm_proc_fops))
		goto out_remove_xqmstat_file;
#endif
	return 0;

#ifdef CONFIG_XFS_QUOTA
 out_remove_xqmstat_file:
	remove_proc_entry("fs/xfs/xqmstat", NULL);
 out_remove_stat_file:
	remove_proc_entry("fs/xfs/stat", NULL);
#endif
 out_remove_xfs_dir:
	remove_proc_entry("fs/xfs", NULL);
 out:
	return -ENOMEM;
}

void
xfs_cleanup_procfs(void)
{
#ifdef CONFIG_XFS_QUOTA
	remove_proc_entry("fs/xfs/xqm", NULL);
	remove_proc_entry("fs/xfs/xqmstat", NULL);
#endif
	remove_proc_entry("fs/xfs/stat", NULL);
	remove_proc_entry("fs/xfs", NULL);
}
Commit	Line	Data
1da177e4	1	/*
7b718769 NS	2	* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
7b718769 NS	3	* All Rights Reserved.
1da177e4	4	*
7b718769 NS	5	* This program is free software; you can redistribute it and/or
7b718769 NS	6	* modify it under the terms of the GNU General Public License as
1da177e4 LT	7	* published by the Free Software Foundation.
1da177e4 LT	8	*
7b718769 NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
1da177e4	13	*
7b718769 NS	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1da177e4	17	*/
1da177e4 LT	18	#include "xfs.h"
	19	#include <linux/proc_fs.h>
	20
	21	DEFINE_PER_CPU(struct xfsstats, xfsstats);
	22
48776fd2 CH	23	static int counter_val(int idx)
	24	{
	25	int val = 0, cpu;
	26
	27	for_each_possible_cpu(cpu)
	28	val += (((__u32 )&per_cpu(xfsstats, cpu) + idx));
	29	return val;
	30	}
	31
bb230c12 BD	32	int xfs_stats_format(char *buf)
	33	{
	34	int i, j;
	35	int len = 0;
	36	__uint64_t xs_xstrat_bytes = 0;
	37	__uint64_t xs_write_bytes = 0;
	38	__uint64_t xs_read_bytes = 0;
	39
	40	static const struct xstats_entry {
	41	char *desc;
	42	int endpoint;
	43	} xstats[] = {
	44	{ "extent_alloc", XFSSTAT_END_EXTENT_ALLOC },
	45	{ "abt", XFSSTAT_END_ALLOC_BTREE },
	46	{ "blk_map", XFSSTAT_END_BLOCK_MAPPING },
	47	{ "bmbt", XFSSTAT_END_BLOCK_MAP_BTREE },
	48	{ "dir", XFSSTAT_END_DIRECTORY_OPS },
	49	{ "trans", XFSSTAT_END_TRANSACTIONS },
	50	{ "ig", XFSSTAT_END_INODE_OPS },
	51	{ "log", XFSSTAT_END_LOG_OPS },
	52	{ "push_ail", XFSSTAT_END_TAIL_PUSHING },
	53	{ "xstrat", XFSSTAT_END_WRITE_CONVERT },
	54	{ "rw", XFSSTAT_END_READ_WRITE_OPS },
	55	{ "attr", XFSSTAT_END_ATTRIBUTE_OPS },
	56	{ "icluster", XFSSTAT_END_INODE_CLUSTER },
	57	{ "vnodes", XFSSTAT_END_VNODE_OPS },
	58	{ "buf", XFSSTAT_END_BUF },
	59	{ "abtb2", XFSSTAT_END_ABTB_V2 },
	60	{ "abtc2", XFSSTAT_END_ABTC_V2 },
	61	{ "bmbt2", XFSSTAT_END_BMBT_V2 },
	62	{ "ibt2", XFSSTAT_END_IBT_V2 },
	63	{ "fibt2", XFSSTAT_END_FIBT_V2 },
	64	/* we print both series of quota information together */
	65	{ "qm", XFSSTAT_END_QM },
	66	};
	67
	68	/* Loop over all stats groups */
	69
	70	for (i = j = 0; i < ARRAY_SIZE(xstats); i++) {
	71	len += snprintf(buf + len, PATH_MAX - len, "%s",
	72	xstats[i].desc);
	73	/* inner loop does each group */
	74	for (; j < xstats[i].endpoint; j++)
	75	len += snprintf(buf + len, PATH_MAX - len, " %u",
	76	counter_val(j));
	77	len += snprintf(buf + len, PATH_MAX - len, "\n");
	78	}
	79	/* extra precision counters */
	80	for_each_possible_cpu(i) {
	81	xs_xstrat_bytes += per_cpu(xfsstats, i).xs_xstrat_bytes;
	82	xs_write_bytes += per_cpu(xfsstats, i).xs_write_bytes;
	83	xs_read_bytes += per_cpu(xfsstats, i).xs_read_bytes;
	84	}
	85
	86	len += snprintf(buf + len, PATH_MAX-len, "xpc %Lu %Lu %Lu\n",
	87	xs_xstrat_bytes, xs_write_bytes, xs_read_bytes);
	88	len += snprintf(buf + len, PATH_MAX-len, "debug %u\n",
	89	#if defined(DEBUG)
	90	1);
	91	#else
	92	0);
	93	#endif
	94
	95	return len;
96	}
97
98	void xfs_stats_clearall(void)
99	{
100	int c;
101	__uint32_t vn_active;
102
103	xfs_notice(NULL, "Clearing xfsstats");
104	for_each_possible_cpu(c) {
105	preempt_disable();
106	/* save vn_active, it's a universal truth! */
107	vn_active = per_cpu(xfsstats, c).vn_active;
108	memset(&per_cpu(xfsstats, c), 0, sizeof(struct xfsstats));
109	per_cpu(xfsstats, c).vn_active = vn_active;
110	preempt_enable();
111	}
112	}
113
361735fd	114	static int xfs_stat_proc_show(struct seq_file m, void v)
1da177e4	115	{
48776fd2	116	int i, j;
1da177e4 LT	117	__uint64_t xs_xstrat_bytes = 0;
	118	__uint64_t xs_write_bytes = 0;
	119	__uint64_t xs_read_bytes = 0;
	120
1df84c93	121	static const struct xstats_entry {
1da177e4 LT	122	char *desc;
	123	int endpoint;
	124	} xstats[] = {
	125	{ "extent_alloc", XFSSTAT_END_EXTENT_ALLOC },
	126	{ "abt", XFSSTAT_END_ALLOC_BTREE },
	127	{ "blk_map", XFSSTAT_END_BLOCK_MAPPING },
	128	{ "bmbt", XFSSTAT_END_BLOCK_MAP_BTREE },
	129	{ "dir", XFSSTAT_END_DIRECTORY_OPS },
	130	{ "trans", XFSSTAT_END_TRANSACTIONS },
	131	{ "ig", XFSSTAT_END_INODE_OPS },
	132	{ "log", XFSSTAT_END_LOG_OPS },
	133	{ "push_ail", XFSSTAT_END_TAIL_PUSHING },
	134	{ "xstrat", XFSSTAT_END_WRITE_CONVERT },
	135	{ "rw", XFSSTAT_END_READ_WRITE_OPS },
	136	{ "attr", XFSSTAT_END_ATTRIBUTE_OPS },
	137	{ "icluster", XFSSTAT_END_INODE_CLUSTER },
	138	{ "vnodes", XFSSTAT_END_VNODE_OPS },
	139	{ "buf", XFSSTAT_END_BUF },
854929f0 DC	140	{ "abtb2", XFSSTAT_END_ABTB_V2 },
	141	{ "abtc2", XFSSTAT_END_ABTC_V2 },
	142	{ "bmbt2", XFSSTAT_END_BMBT_V2 },
	143	{ "ibt2", XFSSTAT_END_IBT_V2 },
aafc3c24	144	{ "fibt2", XFSSTAT_END_FIBT_V2 },
48776fd2 CH	145	/* we print both series of quota information together */
48776fd2 CH	146	{ "qm", XFSSTAT_END_QM },
1da177e4 LT	147	};
	148
	149	/* Loop over all stats groups */
48776fd2	150	for (i = j = 0; i < ARRAY_SIZE(xstats); i++) {
361735fd	151	seq_printf(m, "%s", xstats[i].desc);
1da177e4	152	/* inner loop does each group */
48776fd2 CH	153	for (; j < xstats[i].endpoint; j++)
48776fd2 CH	154	seq_printf(m, " %u", counter_val(j));
361735fd	155	seq_putc(m, '\n');
1da177e4 LT	156	}
1da177e4 LT	157	/* extra precision counters */
6f0419e0	158	for_each_possible_cpu(i) {
1da177e4 LT	159	xs_xstrat_bytes += per_cpu(xfsstats, i).xs_xstrat_bytes;
	160	xs_write_bytes += per_cpu(xfsstats, i).xs_write_bytes;
	161	xs_read_bytes += per_cpu(xfsstats, i).xs_read_bytes;
	162	}
	163
361735fd	164	seq_printf(m, "xpc %Lu %Lu %Lu\n",
1da177e4	165	xs_xstrat_bytes, xs_write_bytes, xs_read_bytes);
361735fd	166	seq_printf(m, "debug %u\n",
1da177e4 LT	167	#if defined(DEBUG)
	168	1);
	169	#else
	170	0);
	171	#endif
361735fd AD	172	return 0;
361735fd AD	173	}
1da177e4	174
361735fd AD	175	static int xfs_stat_proc_open(struct inode inode, struct file file)
	176	{
	177	return single_open(file, xfs_stat_proc_show, NULL);
1da177e4 LT	178	}
1da177e4 LT	179
361735fd AD	180	static const struct file_operations xfs_stat_proc_fops = {
	181	.owner = THIS_MODULE,
	182	.open = xfs_stat_proc_open,
	183	.read = seq_read,
	184	.llseek = seq_lseek,
	185	.release = single_release,
	186	};
	187
48776fd2 CH	188	/* legacy quota interfaces */
	189	#ifdef CONFIG_XFS_QUOTA
	190	static int xqm_proc_show(struct seq_file m, void v)
	191	{
	192	/* maximum; incore; ratio free to inuse; freelist */
	193	seq_printf(m, "%d\t%d\t%d\t%u\n",
	194	0,
	195	counter_val(XFSSTAT_END_XQMSTAT),
	196	0,
	197	counter_val(XFSSTAT_END_XQMSTAT + 1));
	198	return 0;
	199	}
	200
	201	static int xqm_proc_open(struct inode inode, struct file file)
	202	{
	203	return single_open(file, xqm_proc_show, NULL);
	204	}
	205
	206	static const struct file_operations xqm_proc_fops = {
	207	.owner = THIS_MODULE,
	208	.open = xqm_proc_open,
	209	.read = seq_read,
	210	.llseek = seq_lseek,
	211	.release = single_release,
	212	};
	213
	214	/* legacy quota stats interface no 2 */
	215	static int xqmstat_proc_show(struct seq_file m, void v)
	216	{
	217	int j;
	218
	219	seq_printf(m, "qm");
	220	for (j = XFSSTAT_END_IBT_V2; j < XFSSTAT_END_XQMSTAT; j++)
	221	seq_printf(m, " %u", counter_val(j));
	222	seq_putc(m, '\n');
	223	return 0;
	224	}
	225
	226	static int xqmstat_proc_open(struct inode inode, struct file file)
	227	{
	228	return single_open(file, xqmstat_proc_show, NULL);
	229	}
	230
	231	static const struct file_operations xqmstat_proc_fops = {
	232	.owner = THIS_MODULE,
	233	.open = xqmstat_proc_open,
	234	.read = seq_read,
	235	.llseek = seq_lseek,
	236	.release = single_release,
	237	};
	238	#endif /* CONFIG_XFS_QUOTA */
	239
9f8868ff	240	int
1da177e4 LT	241	xfs_init_procfs(void)
	242	{
	243	if (!proc_mkdir("fs/xfs", NULL))
9f8868ff CH	244	goto out;
9f8868ff CH	245
361735fd AD	246	if (!proc_create("fs/xfs/stat", 0, NULL,
361735fd AD	247	&xfs_stat_proc_fops))
48776fd2 CH	248	goto out_remove_xfs_dir;
	249	#ifdef CONFIG_XFS_QUOTA
	250	if (!proc_create("fs/xfs/xqmstat", 0, NULL,
	251	&xqmstat_proc_fops))
	252	goto out_remove_stat_file;
	253	if (!proc_create("fs/xfs/xqm", 0, NULL,
	254	&xqm_proc_fops))
	255	goto out_remove_xqmstat_file;
	256	#endif
9f8868ff CH	257	return 0;
9f8868ff CH	258
48776fd2 CH	259	#ifdef CONFIG_XFS_QUOTA
	260	out_remove_xqmstat_file:
	261	remove_proc_entry("fs/xfs/xqmstat", NULL);
	262	out_remove_stat_file:
	263	remove_proc_entry("fs/xfs/stat", NULL);
	264	#endif
	265	out_remove_xfs_dir:
9f8868ff CH	266	remove_proc_entry("fs/xfs", NULL);
	267	out:
	268	return -ENOMEM;
1da177e4 LT	269	}
	270
	271	void
	272	xfs_cleanup_procfs(void)
	273	{
48776fd2 CH	274	#ifdef CONFIG_XFS_QUOTA
	275	remove_proc_entry("fs/xfs/xqm", NULL);
	276	remove_proc_entry("fs/xfs/xqmstat", NULL);
	277	#endif
1da177e4 LT	278	remove_proc_entry("fs/xfs/stat", NULL);
	279	remove_proc_entry("fs/xfs", NULL);
	280	}