[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",	xfsstats_offset(xs_abt_lookup)	},
		{ "abt",		xfsstats_offset(xs_blk_mapr)	},
		{ "blk_map",		xfsstats_offset(xs_bmbt_lookup)	},
		{ "bmbt",		xfsstats_offset(xs_dir_lookup)	},
		{ "dir",		xfsstats_offset(xs_trans_sync)	},
		{ "trans",		xfsstats_offset(xs_ig_attempts)	},
		{ "ig",			xfsstats_offset(xs_log_writes)	},
		{ "log",		xfsstats_offset(xs_try_logspace)},
		{ "push_ail",		xfsstats_offset(xs_xstrat_quick)},
		{ "xstrat",		xfsstats_offset(xs_write_calls)	},
		{ "rw",			xfsstats_offset(xs_attr_get)	},
		{ "attr",		xfsstats_offset(xs_iflush_count)},
		{ "icluster",		xfsstats_offset(vn_active)	},
		{ "vnodes",		xfsstats_offset(xb_get)		},
		{ "buf",		xfsstats_offset(xs_abtb_2)	},
		{ "abtb2",		xfsstats_offset(xs_abtc_2)	},
		{ "abtc2",		xfsstats_offset(xs_bmbt_2)	},
		{ "bmbt2",		xfsstats_offset(xs_ibt_2)	},
		{ "ibt2",		xfsstats_offset(xs_fibt_2)	},
		{ "fibt2",		xfsstats_offset(xs_rmap_2)	},
		{ "rmapbt",		xfsstats_offset(xs_refcbt_2)	},
		{ "refcntbt",		xfsstats_offset(xs_qm_dqreclaims)},
		/* we print both series of quota information together */
		{ "qm",			xfsstats_offset(xs_xstrat_bytes)},
	};

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

#define XFSSTAT_START_XQMSTAT xfsstats_offset(xs_qm_dqreclaims)
#define XFSSTAT_END_XQMSTAT xfsstats_offset(xs_qm_dquot)

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_START_XQMSTAT; 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[] = {
26ca3901 CM	32	{ "extent_alloc", xfsstats_offset(xs_abt_lookup) },
	33	{ "abt", xfsstats_offset(xs_blk_mapr) },
	34	{ "blk_map", xfsstats_offset(xs_bmbt_lookup) },
	35	{ "bmbt", xfsstats_offset(xs_dir_lookup) },
	36	{ "dir", xfsstats_offset(xs_trans_sync) },
	37	{ "trans", xfsstats_offset(xs_ig_attempts) },
	38	{ "ig", xfsstats_offset(xs_log_writes) },
	39	{ "log", xfsstats_offset(xs_try_logspace)},
	40	{ "push_ail", xfsstats_offset(xs_xstrat_quick)},
	41	{ "xstrat", xfsstats_offset(xs_write_calls) },
	42	{ "rw", xfsstats_offset(xs_attr_get) },
	43	{ "attr", xfsstats_offset(xs_iflush_count)},
	44	{ "icluster", xfsstats_offset(vn_active) },
	45	{ "vnodes", xfsstats_offset(xb_get) },
	46	{ "buf", xfsstats_offset(xs_abtb_2) },
	47	{ "abtb2", xfsstats_offset(xs_abtc_2) },
	48	{ "abtc2", xfsstats_offset(xs_bmbt_2) },
	49	{ "bmbt2", xfsstats_offset(xs_ibt_2) },
	50	{ "ibt2", xfsstats_offset(xs_fibt_2) },
	51	{ "fibt2", xfsstats_offset(xs_rmap_2) },
	52	{ "rmapbt", xfsstats_offset(xs_refcbt_2) },
	53	{ "refcntbt", xfsstats_offset(xs_qm_dqreclaims)},
bb230c12	54	/* we print both series of quota information together */
26ca3901	55	{ "qm", xfsstats_offset(xs_xstrat_bytes)},
bb230c12 BD	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 */
48776fd2 CH	106	#ifdef CONFIG_XFS_QUOTA
26ca3901 CM	107
	108	#define XFSSTAT_START_XQMSTAT xfsstats_offset(xs_qm_dqreclaims)
	109	#define XFSSTAT_END_XQMSTAT xfsstats_offset(xs_qm_dquot)
	110
48776fd2 CH	111	static int xqm_proc_show(struct seq_file m, void v)
	112	{
	113	/* maximum; incore; ratio free to inuse; freelist */
	114	seq_printf(m, "%d\t%d\t%d\t%u\n",
80529c45 BD	115	0, counter_val(xfsstats.xs_stats, XFSSTAT_END_XQMSTAT),
80529c45 BD	116	0, counter_val(xfsstats.xs_stats, XFSSTAT_END_XQMSTAT + 1));
48776fd2 CH	117	return 0;
	118	}
	119
48776fd2 CH	120	/* legacy quota stats interface no 2 */
	121	static int xqmstat_proc_show(struct seq_file m, void v)
	122	{
	123	int j;
	124
	125	seq_printf(m, "qm");
26ca3901	126	for (j = XFSSTAT_START_XQMSTAT; j < XFSSTAT_END_XQMSTAT; j++)
80529c45	127	seq_printf(m, " %u", counter_val(xfsstats.xs_stats, j));
48776fd2 CH	128	seq_putc(m, '\n');
	129	return 0;
	130	}
48776fd2 CH	131	#endif /* CONFIG_XFS_QUOTA */
48776fd2 CH	132
9f8868ff	133	int
1da177e4 LT	134	xfs_init_procfs(void)
	135	{
	136	if (!proc_mkdir("fs/xfs", NULL))
9e92054e	137	return -ENOMEM;
9f8868ff	138
32f0ea05 BD	139	if (!proc_symlink("fs/xfs/stat", NULL,
32f0ea05 BD	140	"/sys/fs/xfs/stats/stats"))
9e92054e	141	goto out;
32f0ea05	142
48776fd2	143	#ifdef CONFIG_XFS_QUOTA
3f3942ac	144	if (!proc_create_single("fs/xfs/xqmstat", 0, NULL, xqmstat_proc_show))
9e92054e	145	goto out;
3f3942ac	146	if (!proc_create_single("fs/xfs/xqm", 0, NULL, xqm_proc_show))
9e92054e	147	goto out;
48776fd2	148	#endif
9f8868ff CH	149	return 0;
9f8868ff CH	150
9e92054e ES	151	out:
9e92054e ES	152	remove_proc_subtree("fs/xfs", NULL);
9f8868ff	153	return -ENOMEM;
1da177e4 LT	154	}
	155
	156	void
	157	xfs_cleanup_procfs(void)
	158	{
9e92054e	159	remove_proc_subtree("fs/xfs", NULL);
1da177e4	160	}
985ef4dc	161	#endif /* CONFIG_PROC_FS */