[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>

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		},
		/* 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)->xs_xstrat_bytes;
		xs_write_bytes += per_cpu_ptr(stats, i)->xs_write_bytes;
		xs_read_bytes += per_cpu_ptr(stats, 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(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)->vn_active;
		memset(per_cpu_ptr(stats, c), 0, sizeof(*stats));
		per_cpu_ptr(stats, c)->vn_active = vn_active;
		preempt_enable();
	}
}

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

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 = {
	.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(xfsstats.xs_stats, 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 */

#ifdef CONFIG_PROC_FS
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("fs/xfs/xqmstat", 0, NULL,
			 &xqmstat_proc_fops))
		goto out;
	if (!proc_create("fs/xfs/xqm", 0, NULL,
			 &xqm_proc_fops))
		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
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
80529c45	21	struct xstats xfsstats;
1da177e4	22
80529c45	23	static int counter_val(struct xfsstats __percpu *stats, int idx)
48776fd2 CH	24	{
	25	int val = 0, cpu;
	26
	27	for_each_possible_cpu(cpu)
80529c45	28	val += (((__u32 )per_cpu_ptr(stats, cpu) + idx));
48776fd2 CH	29	return val;
	30	}
	31
80529c45	32	int xfs_stats_format(struct xfsstats __percpu stats, char buf)
bb230c12 BD	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 },
00f4e4f9	64	{ "rmapbt", XFSSTAT_END_RMAP_V2 },
bb230c12 BD	65	/* we print both series of quota information together */
	66	{ "qm", XFSSTAT_END_QM },
	67	};
	68
	69	/* Loop over all stats groups */
	70
	71	for (i = j = 0; i < ARRAY_SIZE(xstats); i++) {
	72	len += snprintf(buf + len, PATH_MAX - len, "%s",
	73	xstats[i].desc);
	74	/* inner loop does each group */
	75	for (; j < xstats[i].endpoint; j++)
	76	len += snprintf(buf + len, PATH_MAX - len, " %u",
80529c45	77	counter_val(stats, j));
bb230c12 BD	78	len += snprintf(buf + len, PATH_MAX - len, "\n");
	79	}
	80	/* extra precision counters */
	81	for_each_possible_cpu(i) {
80529c45 BD	82	xs_xstrat_bytes += per_cpu_ptr(stats, i)->xs_xstrat_bytes;
	83	xs_write_bytes += per_cpu_ptr(stats, i)->xs_write_bytes;
	84	xs_read_bytes += per_cpu_ptr(stats, i)->xs_read_bytes;
bb230c12 BD	85	}
	86
	87	len += snprintf(buf + len, PATH_MAX-len, "xpc %Lu %Lu %Lu\n",
	88	xs_xstrat_bytes, xs_write_bytes, xs_read_bytes);
	89	len += snprintf(buf + len, PATH_MAX-len, "debug %u\n",
	90	#if defined(DEBUG)
	91	1);
	92	#else
	93	0);
	94	#endif
	95
	96	return len;
	97	}
	98
80529c45	99	void xfs_stats_clearall(struct xfsstats __percpu *stats)
bb230c12 BD	100	{
	101	int c;
	102	__uint32_t vn_active;
	103
	104	xfs_notice(NULL, "Clearing xfsstats");
	105	for_each_possible_cpu(c) {
	106	preempt_disable();
	107	/* save vn_active, it's a universal truth! */
80529c45 BD	108	vn_active = per_cpu_ptr(stats, c)->vn_active;
	109	memset(per_cpu_ptr(stats, c), 0, sizeof(*stats));
	110	per_cpu_ptr(stats, c)->vn_active = vn_active;
bb230c12 BD	111	preempt_enable();
	112	}
	113	}
	114
48776fd2 CH	115	/* legacy quota interfaces */
	116	#ifdef CONFIG_XFS_QUOTA
	117	static int xqm_proc_show(struct seq_file m, void v)
	118	{
	119	/* maximum; incore; ratio free to inuse; freelist */
	120	seq_printf(m, "%d\t%d\t%d\t%u\n",
80529c45 BD	121	0, counter_val(xfsstats.xs_stats, XFSSTAT_END_XQMSTAT),
80529c45 BD	122	0, counter_val(xfsstats.xs_stats, XFSSTAT_END_XQMSTAT + 1));
48776fd2 CH	123	return 0;
	124	}
	125
	126	static int xqm_proc_open(struct inode inode, struct file file)
	127	{
	128	return single_open(file, xqm_proc_show, NULL);
	129	}
	130
	131	static const struct file_operations xqm_proc_fops = {
48776fd2 CH	132	.open = xqm_proc_open,
	133	.read = seq_read,
	134	.llseek = seq_lseek,
	135	.release = single_release,
	136	};
	137
	138	/* legacy quota stats interface no 2 */
	139	static int xqmstat_proc_show(struct seq_file m, void v)
	140	{
	141	int j;
	142
	143	seq_printf(m, "qm");
	144	for (j = XFSSTAT_END_IBT_V2; j < XFSSTAT_END_XQMSTAT; j++)
80529c45	145	seq_printf(m, " %u", counter_val(xfsstats.xs_stats, j));
48776fd2 CH	146	seq_putc(m, '\n');
	147	return 0;
	148	}
	149
	150	static int xqmstat_proc_open(struct inode inode, struct file file)
	151	{
	152	return single_open(file, xqmstat_proc_show, NULL);
	153	}
	154
	155	static const struct file_operations xqmstat_proc_fops = {
	156	.owner = THIS_MODULE,
	157	.open = xqmstat_proc_open,
	158	.read = seq_read,
	159	.llseek = seq_lseek,
	160	.release = single_release,
	161	};
	162	#endif /* CONFIG_XFS_QUOTA */
	163
985ef4dc	164	#ifdef CONFIG_PROC_FS
9f8868ff	165	int
1da177e4 LT	166	xfs_init_procfs(void)
	167	{
	168	if (!proc_mkdir("fs/xfs", NULL))
9e92054e	169	return -ENOMEM;
9f8868ff	170
32f0ea05 BD	171	if (!proc_symlink("fs/xfs/stat", NULL,
32f0ea05 BD	172	"/sys/fs/xfs/stats/stats"))
9e92054e	173	goto out;
32f0ea05	174
48776fd2 CH	175	#ifdef CONFIG_XFS_QUOTA
	176	if (!proc_create("fs/xfs/xqmstat", 0, NULL,
	177	&xqmstat_proc_fops))
9e92054e	178	goto out;
48776fd2 CH	179	if (!proc_create("fs/xfs/xqm", 0, NULL,
48776fd2 CH	180	&xqm_proc_fops))
9e92054e	181	goto out;
48776fd2	182	#endif
9f8868ff CH	183	return 0;
9f8868ff CH	184
9e92054e ES	185	out:
9e92054e ES	186	remove_proc_subtree("fs/xfs", NULL);
9f8868ff	187	return -ENOMEM;
1da177e4 LT	188	}
	189
	190	void
	191	xfs_cleanup_procfs(void)
	192	{
9e92054e	193	remove_proc_subtree("fs/xfs", NULL);
1da177e4	194	}
985ef4dc	195	#endif /* CONFIG_PROC_FS */