Linux Audio

Check our new training course

Loading...
v3.15
 
  1/*
  2 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
  3 * All Rights Reserved.
  4 *
  5 * This program is free software; you can redistribute it and/or
  6 * modify it under the terms of the GNU General Public License as
  7 * published by the Free Software Foundation.
  8 *
  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.
 13 *
 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
 17 */
 18#include "xfs.h"
 19#include <linux/proc_fs.h>
 20
 21DEFINE_PER_CPU(struct xfsstats, xfsstats);
 22
 23static 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
 32static int xfs_stat_proc_show(struct seq_file *m, void *v)
 33{
 34	int		i, j;
 35	__uint64_t	xs_xstrat_bytes = 0;
 36	__uint64_t	xs_write_bytes = 0;
 37	__uint64_t	xs_read_bytes = 0;
 
 
 38
 39	static const struct xstats_entry {
 40		char	*desc;
 41		int	endpoint;
 42	} xstats[] = {
 43		{ "extent_alloc",	XFSSTAT_END_EXTENT_ALLOC	},
 44		{ "abt",		XFSSTAT_END_ALLOC_BTREE		},
 45		{ "blk_map",		XFSSTAT_END_BLOCK_MAPPING	},
 46		{ "bmbt",		XFSSTAT_END_BLOCK_MAP_BTREE	},
 47		{ "dir",		XFSSTAT_END_DIRECTORY_OPS	},
 48		{ "trans",		XFSSTAT_END_TRANSACTIONS	},
 49		{ "ig",			XFSSTAT_END_INODE_OPS		},
 50		{ "log",		XFSSTAT_END_LOG_OPS		},
 51		{ "push_ail",		XFSSTAT_END_TAIL_PUSHING	},
 52		{ "xstrat",		XFSSTAT_END_WRITE_CONVERT	},
 53		{ "rw",			XFSSTAT_END_READ_WRITE_OPS	},
 54		{ "attr",		XFSSTAT_END_ATTRIBUTE_OPS	},
 55		{ "icluster",		XFSSTAT_END_INODE_CLUSTER	},
 56		{ "vnodes",		XFSSTAT_END_VNODE_OPS		},
 57		{ "buf",		XFSSTAT_END_BUF			},
 58		{ "abtb2",		XFSSTAT_END_ABTB_V2		},
 59		{ "abtc2",		XFSSTAT_END_ABTC_V2		},
 60		{ "bmbt2",		XFSSTAT_END_BMBT_V2		},
 61		{ "ibt2",		XFSSTAT_END_IBT_V2		},
 
 
 
 
 
 62		/* we print both series of quota information together */
 63		{ "qm",			XFSSTAT_END_QM			},
 64	};
 65
 66	/* Loop over all stats groups */
 
 67	for (i = j = 0; i < ARRAY_SIZE(xstats); i++) {
 68		seq_printf(m, "%s", xstats[i].desc);
 
 69		/* inner loop does each group */
 70		for (; j < xstats[i].endpoint; j++)
 71			seq_printf(m, " %u", counter_val(j));
 72		seq_putc(m, '\n');
 
 73	}
 74	/* extra precision counters */
 75	for_each_possible_cpu(i) {
 76		xs_xstrat_bytes += per_cpu(xfsstats, i).xs_xstrat_bytes;
 77		xs_write_bytes += per_cpu(xfsstats, i).xs_write_bytes;
 78		xs_read_bytes += per_cpu(xfsstats, i).xs_read_bytes;
 
 79	}
 80
 81	seq_printf(m, "xpc %Lu %Lu %Lu\n",
 82			xs_xstrat_bytes, xs_write_bytes, xs_read_bytes);
 83	seq_printf(m, "debug %u\n",
 
 
 84#if defined(DEBUG)
 85		1);
 86#else
 87		0);
 88#endif
 89	return 0;
 
 90}
 91
 92static int xfs_stat_proc_open(struct inode *inode, struct file *file)
 93{
 94	return single_open(file, xfs_stat_proc_show, NULL);
 95}
 96
 97static const struct file_operations xfs_stat_proc_fops = {
 98	.owner		= THIS_MODULE,
 99	.open		= xfs_stat_proc_open,
100	.read		= seq_read,
101	.llseek		= seq_lseek,
102	.release	= single_release,
103};
 
 
 
104
 
105/* legacy quota interfaces */
106#ifdef CONFIG_XFS_QUOTA
 
 
 
 
107static 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",
111			0,
112			counter_val(XFSSTAT_END_XQMSTAT),
113			0,
114			counter_val(XFSSTAT_END_XQMSTAT + 1));
115	return 0;
116}
117
118static int xqm_proc_open(struct inode *inode, struct file *file)
119{
120	return single_open(file, xqm_proc_show, NULL);
121}
122
123static const struct file_operations xqm_proc_fops = {
124	.owner		= THIS_MODULE,
125	.open		= xqm_proc_open,
126	.read		= seq_read,
127	.llseek		= seq_lseek,
128	.release	= single_release,
129};
130
131/* legacy quota stats interface no 2 */
132static int xqmstat_proc_show(struct seq_file *m, void *v)
133{
134	int j;
135
136	seq_printf(m, "qm");
137	for (j = XFSSTAT_END_IBT_V2; j < XFSSTAT_END_XQMSTAT; j++)
138		seq_printf(m, " %u", counter_val(j));
139	seq_putc(m, '\n');
140	return 0;
141}
142
143static int xqmstat_proc_open(struct inode *inode, struct file *file)
144{
145	return single_open(file, xqmstat_proc_show, NULL);
146}
147
148static const struct file_operations xqmstat_proc_fops = {
149	.owner		= THIS_MODULE,
150	.open		= xqmstat_proc_open,
151	.read		= seq_read,
152	.llseek		= seq_lseek,
153	.release	= single_release,
154};
155#endif /* CONFIG_XFS_QUOTA */
156
157int
158xfs_init_procfs(void)
159{
160	if (!proc_mkdir("fs/xfs", NULL))
 
 
 
 
161		goto out;
162
163	if (!proc_create("fs/xfs/stat", 0, NULL,
164			 &xfs_stat_proc_fops))
165		goto out_remove_xfs_dir;
166#ifdef CONFIG_XFS_QUOTA
167	if (!proc_create("fs/xfs/xqmstat", 0, NULL,
168			 &xqmstat_proc_fops))
169		goto out_remove_stat_file;
170	if (!proc_create("fs/xfs/xqm", 0, NULL,
171			 &xqm_proc_fops))
172		goto out_remove_xqmstat_file;
173#endif
174	return 0;
175
176#ifdef CONFIG_XFS_QUOTA
177 out_remove_xqmstat_file:
178	remove_proc_entry("fs/xfs/xqmstat", NULL);
179 out_remove_stat_file:
180	remove_proc_entry("fs/xfs/stat", NULL);
181#endif
182 out_remove_xfs_dir:
183	remove_proc_entry("fs/xfs", NULL);
184 out:
185	return -ENOMEM;
186}
187
188void
189xfs_cleanup_procfs(void)
190{
191#ifdef CONFIG_XFS_QUOTA
192	remove_proc_entry("fs/xfs/xqm", NULL);
193	remove_proc_entry("fs/xfs/xqmstat", NULL);
194#endif
195	remove_proc_entry("fs/xfs/stat", NULL);
196	remove_proc_entry("fs/xfs", NULL);
197}
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
  4 * All Rights Reserved.
 
 
 
 
 
 
 
 
 
 
 
 
 
  5 */
  6#include "xfs.h"
 
  7
  8struct xstats xfsstats;
  9
 10static int counter_val(struct xfsstats __percpu *stats, int idx)
 11{
 12	int val = 0, cpu;
 13
 14	for_each_possible_cpu(cpu)
 15		val += *(((__u32 *)per_cpu_ptr(stats, cpu) + idx));
 16	return val;
 17}
 18
 19int xfs_stats_format(struct xfsstats __percpu *stats, char *buf)
 20{
 21	int		i, j;
 22	int		len = 0;
 23	uint64_t	xs_xstrat_bytes = 0;
 24	uint64_t	xs_write_bytes = 0;
 25	uint64_t	xs_read_bytes = 0;
 26	uint64_t	defer_relog = 0;
 27
 28	static const struct xstats_entry {
 29		char	*desc;
 30		int	endpoint;
 31	} xstats[] = {
 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_rmap_mem_2)	},
 54		{ "rmapbt_mem",		xfsstats_offset(xs_rcbag_2)	},
 55		{ "rcbagbt",		xfsstats_offset(xs_qm_dqreclaims)},
 56		/* we print both series of quota information together */
 57		{ "qm",			xfsstats_offset(xs_xstrat_bytes)},
 58	};
 59
 60	/* Loop over all stats groups */
 61
 62	for (i = j = 0; i < ARRAY_SIZE(xstats); i++) {
 63		len += scnprintf(buf + len, PATH_MAX - len, "%s",
 64				xstats[i].desc);
 65		/* inner loop does each group */
 66		for (; j < xstats[i].endpoint; j++)
 67			len += scnprintf(buf + len, PATH_MAX - len, " %u",
 68					counter_val(stats, j));
 69		len += scnprintf(buf + len, PATH_MAX - len, "\n");
 70	}
 71	/* extra precision counters */
 72	for_each_possible_cpu(i) {
 73		xs_xstrat_bytes += per_cpu_ptr(stats, i)->s.xs_xstrat_bytes;
 74		xs_write_bytes += per_cpu_ptr(stats, i)->s.xs_write_bytes;
 75		xs_read_bytes += per_cpu_ptr(stats, i)->s.xs_read_bytes;
 76		defer_relog += per_cpu_ptr(stats, i)->s.defer_relog;
 77	}
 78
 79	len += scnprintf(buf + len, PATH_MAX-len, "xpc %llu %llu %llu\n",
 80			xs_xstrat_bytes, xs_write_bytes, xs_read_bytes);
 81	len += scnprintf(buf + len, PATH_MAX-len, "defer_relog %llu\n",
 82			defer_relog);
 83	len += scnprintf(buf + len, PATH_MAX-len, "debug %u\n",
 84#if defined(DEBUG)
 85		1);
 86#else
 87		0);
 88#endif
 89
 90	return len;
 91}
 92
 93void xfs_stats_clearall(struct xfsstats __percpu *stats)
 94{
 95	int		c;
 96	uint32_t	vn_active;
 97
 98	xfs_notice(NULL, "Clearing xfsstats");
 99	for_each_possible_cpu(c) {
100		preempt_disable();
101		/* save vn_active, it's a universal truth! */
102		vn_active = per_cpu_ptr(stats, c)->s.vn_active;
103		memset(per_cpu_ptr(stats, c), 0, sizeof(*stats));
104		per_cpu_ptr(stats, c)->s.vn_active = vn_active;
105		preempt_enable();
106	}
107}
108
109#ifdef CONFIG_PROC_FS
110/* legacy quota interfaces */
111#ifdef CONFIG_XFS_QUOTA
112
113#define XFSSTAT_START_XQMSTAT xfsstats_offset(xs_qm_dqreclaims)
114#define XFSSTAT_END_XQMSTAT xfsstats_offset(xs_qm_dquot)
115
116static int xqm_proc_show(struct seq_file *m, void *v)
117{
118	/* maximum; incore; ratio free to inuse; freelist; rtquota */
119	seq_printf(m, "%d\t%d\t%d\t%u\t%s\n",
120		   0, counter_val(xfsstats.xs_stats, XFSSTAT_END_XQMSTAT),
121		   0, counter_val(xfsstats.xs_stats, XFSSTAT_END_XQMSTAT + 1),
122		   IS_ENABLED(CONFIG_XFS_RT) ? "rtquota" : "quota");
 
123	return 0;
124}
125
 
 
 
 
 
 
 
 
 
 
 
 
 
126/* legacy quota stats interface no 2 */
127static int xqmstat_proc_show(struct seq_file *m, void *v)
128{
129	int j;
130
131	seq_puts(m, "qm");
132	for (j = XFSSTAT_START_XQMSTAT; j < XFSSTAT_END_XQMSTAT; j++)
133		seq_printf(m, " %u", counter_val(xfsstats.xs_stats, j));
134	seq_putc(m, '\n');
135	return 0;
136}
 
 
 
 
 
 
 
 
 
 
 
 
 
137#endif /* CONFIG_XFS_QUOTA */
138
139int
140xfs_init_procfs(void)
141{
142	if (!proc_mkdir("fs/xfs", NULL))
143		return -ENOMEM;
144
145	if (!proc_symlink("fs/xfs/stat", NULL,
146			  "/sys/fs/xfs/stats/stats"))
147		goto out;
148
 
 
 
149#ifdef CONFIG_XFS_QUOTA
150	if (!proc_create_single("fs/xfs/xqmstat", 0, NULL, xqmstat_proc_show))
151		goto out;
152	if (!proc_create_single("fs/xfs/xqm", 0, NULL, xqm_proc_show))
153		goto out;
 
 
154#endif
155	return 0;
156
157out:
158	remove_proc_subtree("fs/xfs", NULL);
 
 
 
 
 
 
 
159	return -ENOMEM;
160}
161
162void
163xfs_cleanup_procfs(void)
164{
165	remove_proc_subtree("fs/xfs", NULL);
 
 
 
 
 
166}
167#endif /* CONFIG_PROC_FS */