[linux.git] / fs / xfs / xfs_sysctl.c

/*
 * Copyright (c) 2001-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/sysctl.h>
#include <linux/proc_fs.h>
#include "xfs_error.h"

static struct ctl_table_header *xfs_table_header;

#ifdef CONFIG_PROC_FS
STATIC int
xfs_stats_clear_proc_handler(
	ctl_table	*ctl,
	int		write,
	void		__user *buffer,
	size_t		*lenp,
	loff_t		*ppos)
{
	int		c, ret, *valp = ctl->data;
	__uint32_t	vn_active;

	ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);

	if (!ret && write && *valp) {
		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();
		}
		xfs_stats_clear = 0;
	}

	return ret;
}

STATIC int
xfs_panic_mask_proc_handler(
	ctl_table	*ctl,
	int		write,
	void		__user *buffer,
	size_t		*lenp,
	loff_t		*ppos)
{
	int		ret, *valp = ctl->data;

	ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
	if (!ret && write) {
		xfs_panic_mask = *valp;
#ifdef DEBUG
		xfs_panic_mask |= (XFS_PTAG_SHUTDOWN_CORRUPT | XFS_PTAG_LOGRES);
#endif
	}
	return ret;
}
#endif /* CONFIG_PROC_FS */

static ctl_table xfs_table[] = {
	{
		.procname	= "irix_sgid_inherit",
		.data		= &xfs_params.sgid_inherit.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.sgid_inherit.min,
		.extra2		= &xfs_params.sgid_inherit.max
	},
	{
		.procname	= "irix_symlink_mode",
		.data		= &xfs_params.symlink_mode.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.symlink_mode.min,
		.extra2		= &xfs_params.symlink_mode.max
	},
	{
		.procname	= "panic_mask",
		.data		= &xfs_params.panic_mask.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= xfs_panic_mask_proc_handler,
		.extra1		= &xfs_params.panic_mask.min,
		.extra2		= &xfs_params.panic_mask.max
	},

	{
		.procname	= "error_level",
		.data		= &xfs_params.error_level.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.error_level.min,
		.extra2		= &xfs_params.error_level.max
	},
	{
		.procname	= "xfssyncd_centisecs",
		.data		= &xfs_params.syncd_timer.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.syncd_timer.min,
		.extra2		= &xfs_params.syncd_timer.max
	},
	{
		.procname	= "inherit_sync",
		.data		= &xfs_params.inherit_sync.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.inherit_sync.min,
		.extra2		= &xfs_params.inherit_sync.max
	},
	{
		.procname	= "inherit_nodump",
		.data		= &xfs_params.inherit_nodump.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.inherit_nodump.min,
		.extra2		= &xfs_params.inherit_nodump.max
	},
	{
		.procname	= "inherit_noatime",
		.data		= &xfs_params.inherit_noatim.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.inherit_noatim.min,
		.extra2		= &xfs_params.inherit_noatim.max
	},
	{
		.procname	= "xfsbufd_centisecs",
		.data		= &xfs_params.xfs_buf_timer.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.xfs_buf_timer.min,
		.extra2		= &xfs_params.xfs_buf_timer.max
	},
	{
		.procname	= "age_buffer_centisecs",
		.data		= &xfs_params.xfs_buf_age.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.xfs_buf_age.min,
		.extra2		= &xfs_params.xfs_buf_age.max
	},
	{
		.procname	= "inherit_nosymlinks",
		.data		= &xfs_params.inherit_nosym.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.inherit_nosym.min,
		.extra2		= &xfs_params.inherit_nosym.max
	},
	{
		.procname	= "rotorstep",
		.data		= &xfs_params.rotorstep.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.rotorstep.min,
		.extra2		= &xfs_params.rotorstep.max
	},
	{
		.procname	= "inherit_nodefrag",
		.data		= &xfs_params.inherit_nodfrg.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.inherit_nodfrg.min,
		.extra2		= &xfs_params.inherit_nodfrg.max
	},
	{
		.procname	= "filestream_centisecs",
		.data		= &xfs_params.fstrm_timer.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.fstrm_timer.min,
		.extra2		= &xfs_params.fstrm_timer.max,
	},
	{
		.procname	= "speculative_prealloc_lifetime",
		.data		= &xfs_params.eofb_timer.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_minmax,
		.extra1		= &xfs_params.eofb_timer.min,
		.extra2		= &xfs_params.eofb_timer.max,
	},
	/* please keep this the last entry */
#ifdef CONFIG_PROC_FS
	{
		.procname	= "stats_clear",
		.data		= &xfs_params.stats_clear.val,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= xfs_stats_clear_proc_handler,
		.extra1		= &xfs_params.stats_clear.min,
		.extra2		= &xfs_params.stats_clear.max
	},
#endif /* CONFIG_PROC_FS */

	{}
};

static ctl_table xfs_dir_table[] = {
	{
		.procname	= "xfs",
		.mode		= 0555,
		.child		= xfs_table
	},
	{}
};

static ctl_table xfs_root_table[] = {
	{
		.procname	= "fs",
		.mode		= 0555,
		.child		= xfs_dir_table
	},
	{}
};

int
xfs_sysctl_register(void)
{
	xfs_table_header = register_sysctl_table(xfs_root_table);
	if (!xfs_table_header)
		return -ENOMEM;
	return 0;
}

void
xfs_sysctl_unregister(void)
{
	unregister_sysctl_table(xfs_table_header);
}
Commit	Line	Data
1da177e4	1	/*
7b718769 NS	2	* Copyright (c) 2001-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	18	#include "xfs.h"
1da177e4 LT	19	#include <linux/sysctl.h>
1da177e4 LT	20	#include <linux/proc_fs.h>
73efe4a4	21	#include "xfs_error.h"
1da177e4	22
1da177e4 LT	23	static struct ctl_table_header *xfs_table_header;
1da177e4 LT	24
1da177e4 LT	25	#ifdef CONFIG_PROC_FS
	26	STATIC int
	27	xfs_stats_clear_proc_handler(
	28	ctl_table *ctl,
	29	int write,
1da177e4 LT	30	void __user *buffer,
	31	size_t *lenp,
	32	loff_t *ppos)
	33	{
	34	int c, ret, *valp = ctl->data;
	35	__uint32_t vn_active;
	36
8d65af78	37	ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
1da177e4 LT	38
1da177e4 LT	39	if (!ret && write && *valp) {
4f10700a	40	xfs_notice(NULL, "Clearing xfsstats");
6f0419e0	41	for_each_possible_cpu(c) {
1da177e4 LT	42	preempt_disable();
	43	/* save vn_active, it's a universal truth! */
	44	vn_active = per_cpu(xfsstats, c).vn_active;
	45	memset(&per_cpu(xfsstats, c), 0,
	46	sizeof(struct xfsstats));
	47	per_cpu(xfsstats, c).vn_active = vn_active;
	48	preempt_enable();
	49	}
	50	xfs_stats_clear = 0;
	51	}
	52
	53	return ret;
	54	}
73efe4a4 DC	55
	56	STATIC int
	57	xfs_panic_mask_proc_handler(
	58	ctl_table *ctl,
	59	int write,
	60	void __user *buffer,
	61	size_t *lenp,
	62	loff_t *ppos)
	63	{
	64	int ret, *valp = ctl->data;
	65
	66	ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
	67	if (!ret && write) {
	68	xfs_panic_mask = *valp;
	69	#ifdef DEBUG
	70	xfs_panic_mask \|= (XFS_PTAG_SHUTDOWN_CORRUPT \| XFS_PTAG_LOGRES);
	71	#endif
	72	}
	73	return ret;
	74	}
1da177e4 LT	75	#endif /* CONFIG_PROC_FS */
1da177e4 LT	76
7989cb8e	77	static ctl_table xfs_table[] = {
3a68cbfe	78	{
3a68cbfe EB	79	.procname = "irix_sgid_inherit",
	80	.data = &xfs_params.sgid_inherit.val,
	81	.maxlen = sizeof(int),
	82	.mode = 0644,
6d456111	83	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	84	.extra1 = &xfs_params.sgid_inherit.min,
	85	.extra2 = &xfs_params.sgid_inherit.max
	86	},
	87	{
3a68cbfe EB	88	.procname = "irix_symlink_mode",
	89	.data = &xfs_params.symlink_mode.val,
	90	.maxlen = sizeof(int),
	91	.mode = 0644,
6d456111	92	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	93	.extra1 = &xfs_params.symlink_mode.min,
	94	.extra2 = &xfs_params.symlink_mode.max
	95	},
	96	{
3a68cbfe EB	97	.procname = "panic_mask",
	98	.data = &xfs_params.panic_mask.val,
	99	.maxlen = sizeof(int),
	100	.mode = 0644,
73efe4a4	101	.proc_handler = xfs_panic_mask_proc_handler,
3a68cbfe EB	102	.extra1 = &xfs_params.panic_mask.min,
	103	.extra2 = &xfs_params.panic_mask.max
	104	},
d3446eac	105
3a68cbfe	106	{
3a68cbfe EB	107	.procname = "error_level",
	108	.data = &xfs_params.error_level.val,
	109	.maxlen = sizeof(int),
	110	.mode = 0644,
6d456111	111	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	112	.extra1 = &xfs_params.error_level.min,
	113	.extra2 = &xfs_params.error_level.max
	114	},
	115	{
3a68cbfe EB	116	.procname = "xfssyncd_centisecs",
	117	.data = &xfs_params.syncd_timer.val,
	118	.maxlen = sizeof(int),
	119	.mode = 0644,
6d456111	120	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	121	.extra1 = &xfs_params.syncd_timer.min,
	122	.extra2 = &xfs_params.syncd_timer.max
	123	},
	124	{
3a68cbfe EB	125	.procname = "inherit_sync",
	126	.data = &xfs_params.inherit_sync.val,
	127	.maxlen = sizeof(int),
	128	.mode = 0644,
6d456111	129	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	130	.extra1 = &xfs_params.inherit_sync.min,
	131	.extra2 = &xfs_params.inherit_sync.max
	132	},
	133	{
3a68cbfe EB	134	.procname = "inherit_nodump",
	135	.data = &xfs_params.inherit_nodump.val,
	136	.maxlen = sizeof(int),
	137	.mode = 0644,
6d456111	138	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	139	.extra1 = &xfs_params.inherit_nodump.min,
	140	.extra2 = &xfs_params.inherit_nodump.max
	141	},
	142	{
3a68cbfe EB	143	.procname = "inherit_noatime",
	144	.data = &xfs_params.inherit_noatim.val,
	145	.maxlen = sizeof(int),
	146	.mode = 0644,
6d456111	147	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	148	.extra1 = &xfs_params.inherit_noatim.min,
	149	.extra2 = &xfs_params.inherit_noatim.max
	150	},
	151	{
3a68cbfe EB	152	.procname = "xfsbufd_centisecs",
	153	.data = &xfs_params.xfs_buf_timer.val,
	154	.maxlen = sizeof(int),
	155	.mode = 0644,
6d456111	156	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	157	.extra1 = &xfs_params.xfs_buf_timer.min,
	158	.extra2 = &xfs_params.xfs_buf_timer.max
	159	},
	160	{
3a68cbfe EB	161	.procname = "age_buffer_centisecs",
	162	.data = &xfs_params.xfs_buf_age.val,
	163	.maxlen = sizeof(int),
	164	.mode = 0644,
6d456111	165	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	166	.extra1 = &xfs_params.xfs_buf_age.min,
	167	.extra2 = &xfs_params.xfs_buf_age.max
	168	},
	169	{
3a68cbfe EB	170	.procname = "inherit_nosymlinks",
	171	.data = &xfs_params.inherit_nosym.val,
	172	.maxlen = sizeof(int),
	173	.mode = 0644,
6d456111	174	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	175	.extra1 = &xfs_params.inherit_nosym.min,
	176	.extra2 = &xfs_params.inherit_nosym.max
	177	},
	178	{
3a68cbfe EB	179	.procname = "rotorstep",
	180	.data = &xfs_params.rotorstep.val,
	181	.maxlen = sizeof(int),
	182	.mode = 0644,
6d456111	183	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	184	.extra1 = &xfs_params.rotorstep.min,
	185	.extra2 = &xfs_params.rotorstep.max
	186	},
	187	{
3a68cbfe EB	188	.procname = "inherit_nodefrag",
	189	.data = &xfs_params.inherit_nodfrg.val,
	190	.maxlen = sizeof(int),
	191	.mode = 0644,
6d456111	192	.proc_handler = proc_dointvec_minmax,
3a68cbfe EB	193	.extra1 = &xfs_params.inherit_nodfrg.min,
	194	.extra2 = &xfs_params.inherit_nodfrg.max
	195	},
2a82b8be	196	{
2a82b8be DC	197	.procname = "filestream_centisecs",
	198	.data = &xfs_params.fstrm_timer.val,
	199	.maxlen = sizeof(int),
	200	.mode = 0644,
6d456111	201	.proc_handler = proc_dointvec_minmax,
2a82b8be DC	202	.extra1 = &xfs_params.fstrm_timer.min,
	203	.extra2 = &xfs_params.fstrm_timer.max,
	204	},
579b62fa BF	205	{
	206	.procname = "speculative_prealloc_lifetime",
	207	.data = &xfs_params.eofb_timer.val,
	208	.maxlen = sizeof(int),
	209	.mode = 0644,
	210	.proc_handler = proc_dointvec_minmax,
	211	.extra1 = &xfs_params.eofb_timer.min,
	212	.extra2 = &xfs_params.eofb_timer.max,
	213	},
1da177e4 LT	214	/* please keep this the last entry */
1da177e4 LT	215	#ifdef CONFIG_PROC_FS
3a68cbfe	216	{
3a68cbfe EB	217	.procname = "stats_clear",
	218	.data = &xfs_params.stats_clear.val,
	219	.maxlen = sizeof(int),
	220	.mode = 0644,
6d456111	221	.proc_handler = xfs_stats_clear_proc_handler,
3a68cbfe EB	222	.extra1 = &xfs_params.stats_clear.min,
	223	.extra2 = &xfs_params.stats_clear.max
	224	},
1da177e4 LT	225	#endif /* CONFIG_PROC_FS */
1da177e4 LT	226
3a68cbfe	227	{}
1da177e4 LT	228	};
1da177e4 LT	229
7989cb8e	230	static ctl_table xfs_dir_table[] = {
3a68cbfe	231	{
3a68cbfe EB	232	.procname = "xfs",
	233	.mode = 0555,
	234	.child = xfs_table
	235	},
	236	{}
1da177e4 LT	237	};
1da177e4 LT	238
7989cb8e	239	static ctl_table xfs_root_table[] = {
3a68cbfe	240	{
3a68cbfe EB	241	.procname = "fs",
	242	.mode = 0555,
	243	.child = xfs_dir_table
	244	},
	245	{}
1da177e4 LT	246	};
1da177e4 LT	247
9f8868ff	248	int
1da177e4 LT	249	xfs_sysctl_register(void)
1da177e4 LT	250	{
0b4d4147	251	xfs_table_header = register_sysctl_table(xfs_root_table);
9f8868ff CH	252	if (!xfs_table_header)
	253	return -ENOMEM;
	254	return 0;
1da177e4 LT	255	}
	256
	257	void
	258	xfs_sysctl_unregister(void)
	259	{
9f8868ff	260	unregister_sysctl_table(xfs_table_header);
1da177e4	261	}