[mirror_ubuntu-bionic-kernel.git] / fs / xfs / xfs_sysfs.c

/*
 * Copyright (c) 2014 Red Hat, 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 "xfs_sysfs.h"
#include "xfs_log_format.h"
#include "xfs_log.h"
#include "xfs_log_priv.h"
#include "xfs_stats.h"

struct xfs_sysfs_attr {
	struct attribute attr;
	ssize_t (*show)(struct kobject *kobject, char *buf);
	ssize_t (*store)(struct kobject *kobject, const char *buf,
			 size_t count);
};

static inline struct xfs_sysfs_attr *
to_attr(struct attribute *attr)
{
	return container_of(attr, struct xfs_sysfs_attr, attr);
}

#define XFS_SYSFS_ATTR_RW(name) \
	static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RW(name)
#define XFS_SYSFS_ATTR_RO(name) \
	static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RO(name)
#define XFS_SYSFS_ATTR_WO(name) \
	static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_WO(name)

#define ATTR_LIST(name) &xfs_sysfs_attr_##name.attr

/*
 * xfs_mount kobject. This currently has no attributes and thus no need for show
 * and store helpers. The mp kobject serves as the per-mount parent object that
 * is identified by the fsname under sysfs.
 */

struct kobj_type xfs_mp_ktype = {
	.release = xfs_sysfs_release,
};

STATIC ssize_t
xfs_sysfs_object_show(
	struct kobject		*kobject,
	struct attribute	*attr,
	char			*buf)
{
	struct xfs_sysfs_attr *xfs_attr = to_attr(attr);

	return xfs_attr->show ? xfs_attr->show(kobject, buf) : 0;
}

STATIC ssize_t
xfs_sysfs_object_store(
	struct kobject		*kobject,
	struct attribute	*attr,
	const char		*buf,
	size_t			count)
{
	struct xfs_sysfs_attr *xfs_attr = to_attr(attr);

	return xfs_attr->store ? xfs_attr->store(kobject, buf, count) : 0;
}

static const struct sysfs_ops xfs_sysfs_ops = {
	.show = xfs_sysfs_object_show,
	.store = xfs_sysfs_object_store,
};

#ifdef DEBUG
/* debug */

STATIC ssize_t
log_recovery_delay_store(
	struct kobject	*kobject,
	const char	*buf,
	size_t		count)
{
	int		ret;
	int		val;

	ret = kstrtoint(buf, 0, &val);
	if (ret)
		return ret;

	if (val < 0 || val > 60)
		return -EINVAL;

	xfs_globals.log_recovery_delay = val;

	return count;
}

STATIC ssize_t
log_recovery_delay_show(
	struct kobject	*kobject,
	char		*buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", xfs_globals.log_recovery_delay);
}
XFS_SYSFS_ATTR_RW(log_recovery_delay);

static struct attribute *xfs_dbg_attrs[] = {
	ATTR_LIST(log_recovery_delay),
	NULL,
};

struct kobj_type xfs_dbg_ktype = {
	.release = xfs_sysfs_release,
	.sysfs_ops = &xfs_sysfs_ops,
	.default_attrs = xfs_dbg_attrs,
};

#endif /* DEBUG */

/* stats */

static inline struct xstats *
to_xstats(struct kobject *kobject)
{
	struct xfs_kobj *kobj = to_kobj(kobject);

	return container_of(kobj, struct xstats, xs_kobj);
}

STATIC ssize_t
stats_show(
	struct kobject	*kobject,
	char		*buf)
{
	struct xstats	*stats = to_xstats(kobject);

	return xfs_stats_format(stats->xs_stats, buf);
}
XFS_SYSFS_ATTR_RO(stats);

STATIC ssize_t
stats_clear_store(
	struct kobject	*kobject,
	const char	*buf,
	size_t		count)
{
	int		ret;
	int		val;
	struct xstats	*stats = to_xstats(kobject);

	ret = kstrtoint(buf, 0, &val);
	if (ret)
		return ret;

	if (val != 1)
		return -EINVAL;

	xfs_stats_clearall(stats->xs_stats);
	return count;
}
XFS_SYSFS_ATTR_WO(stats_clear);

static struct attribute *xfs_stats_attrs[] = {
	ATTR_LIST(stats),
	ATTR_LIST(stats_clear),
	NULL,
};

struct kobj_type xfs_stats_ktype = {
	.release = xfs_sysfs_release,
	.sysfs_ops = &xfs_sysfs_ops,
	.default_attrs = xfs_stats_attrs,
};

/* xlog */

static inline struct xlog *
to_xlog(struct kobject *kobject)
{
	struct xfs_kobj *kobj = to_kobj(kobject);

	return container_of(kobj, struct xlog, l_kobj);
}

STATIC ssize_t
log_head_lsn_show(
	struct kobject	*kobject,
	char		*buf)
{
	int cycle;
	int block;
	struct xlog *log = to_xlog(kobject);

	spin_lock(&log->l_icloglock);
	cycle = log->l_curr_cycle;
	block = log->l_curr_block;
	spin_unlock(&log->l_icloglock);

	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, block);
}
XFS_SYSFS_ATTR_RO(log_head_lsn);

STATIC ssize_t
log_tail_lsn_show(
	struct kobject	*kobject,
	char		*buf)
{
	int cycle;
	int block;
	struct xlog *log = to_xlog(kobject);

	xlog_crack_atomic_lsn(&log->l_tail_lsn, &cycle, &block);
	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, block);
}
XFS_SYSFS_ATTR_RO(log_tail_lsn);

STATIC ssize_t
reserve_grant_head_show(
	struct kobject	*kobject,
	char		*buf)

{
	int cycle;
	int bytes;
	struct xlog *log = to_xlog(kobject);

	xlog_crack_grant_head(&log->l_reserve_head.grant, &cycle, &bytes);
	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, bytes);
}
XFS_SYSFS_ATTR_RO(reserve_grant_head);

STATIC ssize_t
write_grant_head_show(
	struct kobject	*kobject,
	char		*buf)
{
	int cycle;
	int bytes;
	struct xlog *log = to_xlog(kobject);

	xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &bytes);
	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, bytes);
}
XFS_SYSFS_ATTR_RO(write_grant_head);

#ifdef DEBUG
STATIC ssize_t
log_badcrc_factor_store(
	struct kobject	*kobject,
	const char	*buf,
	size_t		count)
{
	struct xlog	*log = to_xlog(kobject);
	int		ret;
	uint32_t	val;

	ret = kstrtouint(buf, 0, &val);
	if (ret)
		return ret;

	log->l_badcrc_factor = val;

	return count;
}

STATIC ssize_t
log_badcrc_factor_show(
	struct kobject	*kobject,
	char		*buf)
{
	struct xlog	*log = to_xlog(kobject);

	return snprintf(buf, PAGE_SIZE, "%d\n", log->l_badcrc_factor);
}

XFS_SYSFS_ATTR_RW(log_badcrc_factor);
#endif	/* DEBUG */

static struct attribute *xfs_log_attrs[] = {
	ATTR_LIST(log_head_lsn),
	ATTR_LIST(log_tail_lsn),
	ATTR_LIST(reserve_grant_head),
	ATTR_LIST(write_grant_head),
#ifdef DEBUG
	ATTR_LIST(log_badcrc_factor),
#endif
	NULL,
};

struct kobj_type xfs_log_ktype = {
	.release = xfs_sysfs_release,
	.sysfs_ops = &xfs_sysfs_ops,
	.default_attrs = xfs_log_attrs,
};
Commit	Line	Data
	1	/*
	2	* Copyright (c) 2014 Red Hat, 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
	19	#include "xfs.h"
	20	#include "xfs_sysfs.h"
	21	#include "xfs_log_format.h"
	22	#include "xfs_log.h"
	23	#include "xfs_log_priv.h"
	24	#include "xfs_stats.h"
	25
	26	struct xfs_sysfs_attr {
	27	struct attribute attr;
	28	ssize_t (show)(struct kobject kobject, char *buf);
	29	ssize_t (store)(struct kobject kobject, const char *buf,
	30	size_t count);
	31	};
	32
	33	static inline struct xfs_sysfs_attr *
	34	to_attr(struct attribute *attr)
	35	{
	36	return container_of(attr, struct xfs_sysfs_attr, attr);
	37	}
	38
	39	#define XFS_SYSFS_ATTR_RW(name) \
	40	static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RW(name)
	41	#define XFS_SYSFS_ATTR_RO(name) \
	42	static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RO(name)
	43	#define XFS_SYSFS_ATTR_WO(name) \
	44	static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_WO(name)
	45
	46	#define ATTR_LIST(name) &xfs_sysfs_attr_##name.attr
	47
	48	/*
	49	* xfs_mount kobject. This currently has no attributes and thus no need for show
	50	* and store helpers. The mp kobject serves as the per-mount parent object that
	51	* is identified by the fsname under sysfs.
	52	*/
	53
	54	struct kobj_type xfs_mp_ktype = {
	55	.release = xfs_sysfs_release,
	56	};
	57
	58	STATIC ssize_t
	59	xfs_sysfs_object_show(
	60	struct kobject *kobject,
	61	struct attribute *attr,
	62	char *buf)
	63	{
	64	struct xfs_sysfs_attr *xfs_attr = to_attr(attr);
	65
	66	return xfs_attr->show ? xfs_attr->show(kobject, buf) : 0;
	67	}
	68
	69	STATIC ssize_t
	70	xfs_sysfs_object_store(
	71	struct kobject *kobject,
	72	struct attribute *attr,
	73	const char *buf,
	74	size_t count)
	75	{
	76	struct xfs_sysfs_attr *xfs_attr = to_attr(attr);
	77
	78	return xfs_attr->store ? xfs_attr->store(kobject, buf, count) : 0;
	79	}
	80
	81	static const struct sysfs_ops xfs_sysfs_ops = {
	82	.show = xfs_sysfs_object_show,
	83	.store = xfs_sysfs_object_store,
	84	};
	85
	86	#ifdef DEBUG
	87	/* debug */
	88
	89	STATIC ssize_t
	90	log_recovery_delay_store(
	91	struct kobject *kobject,
	92	const char *buf,
	93	size_t count)
	94	{
	95	int ret;
	96	int val;
	97
	98	ret = kstrtoint(buf, 0, &val);
	99	if (ret)
	100	return ret;
	101
	102	if (val < 0 \|\| val > 60)
	103	return -EINVAL;
	104
	105	xfs_globals.log_recovery_delay = val;
	106
	107	return count;
	108	}
	109
	110	STATIC ssize_t
	111	log_recovery_delay_show(
	112	struct kobject *kobject,
	113	char *buf)
	114	{
	115	return snprintf(buf, PAGE_SIZE, "%d\n", xfs_globals.log_recovery_delay);
	116	}
	117	XFS_SYSFS_ATTR_RW(log_recovery_delay);
	118
	119	static struct attribute *xfs_dbg_attrs[] = {
	120	ATTR_LIST(log_recovery_delay),
	121	NULL,
	122	};
	123
	124	struct kobj_type xfs_dbg_ktype = {
	125	.release = xfs_sysfs_release,
	126	.sysfs_ops = &xfs_sysfs_ops,
	127	.default_attrs = xfs_dbg_attrs,
	128	};
	129
	130	#endif /* DEBUG */
	131
	132	/* stats */
	133
	134	static inline struct xstats *
	135	to_xstats(struct kobject *kobject)
	136	{
	137	struct xfs_kobj *kobj = to_kobj(kobject);
	138
	139	return container_of(kobj, struct xstats, xs_kobj);
	140	}
	141
	142	STATIC ssize_t
	143	stats_show(
	144	struct kobject *kobject,
	145	char *buf)
	146	{
	147	struct xstats *stats = to_xstats(kobject);
	148
	149	return xfs_stats_format(stats->xs_stats, buf);
	150	}
	151	XFS_SYSFS_ATTR_RO(stats);
	152
	153	STATIC ssize_t
	154	stats_clear_store(
	155	struct kobject *kobject,
	156	const char *buf,
	157	size_t count)
	158	{
	159	int ret;
	160	int val;
	161	struct xstats *stats = to_xstats(kobject);
	162
	163	ret = kstrtoint(buf, 0, &val);
	164	if (ret)
	165	return ret;
	166
	167	if (val != 1)
	168	return -EINVAL;
	169
	170	xfs_stats_clearall(stats->xs_stats);
	171	return count;
	172	}
	173	XFS_SYSFS_ATTR_WO(stats_clear);
	174
	175	static struct attribute *xfs_stats_attrs[] = {
	176	ATTR_LIST(stats),
	177	ATTR_LIST(stats_clear),
	178	NULL,
	179	};
	180
	181	struct kobj_type xfs_stats_ktype = {
	182	.release = xfs_sysfs_release,
	183	.sysfs_ops = &xfs_sysfs_ops,
	184	.default_attrs = xfs_stats_attrs,
	185	};
	186
	187	/* xlog */
	188
	189	static inline struct xlog *
	190	to_xlog(struct kobject *kobject)
	191	{
	192	struct xfs_kobj *kobj = to_kobj(kobject);
	193
	194	return container_of(kobj, struct xlog, l_kobj);
	195	}
	196
	197	STATIC ssize_t
	198	log_head_lsn_show(
	199	struct kobject *kobject,
	200	char *buf)
	201	{
	202	int cycle;
	203	int block;
	204	struct xlog *log = to_xlog(kobject);
	205
	206	spin_lock(&log->l_icloglock);
	207	cycle = log->l_curr_cycle;
	208	block = log->l_curr_block;
	209	spin_unlock(&log->l_icloglock);
	210
	211	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, block);
	212	}
	213	XFS_SYSFS_ATTR_RO(log_head_lsn);
	214
	215	STATIC ssize_t
	216	log_tail_lsn_show(
	217	struct kobject *kobject,
	218	char *buf)
	219	{
	220	int cycle;
	221	int block;
	222	struct xlog *log = to_xlog(kobject);
	223
	224	xlog_crack_atomic_lsn(&log->l_tail_lsn, &cycle, &block);
	225	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, block);
	226	}
	227	XFS_SYSFS_ATTR_RO(log_tail_lsn);
	228
	229	STATIC ssize_t
	230	reserve_grant_head_show(
	231	struct kobject *kobject,
	232	char *buf)
	233
	234	{
	235	int cycle;
	236	int bytes;
	237	struct xlog *log = to_xlog(kobject);
	238
	239	xlog_crack_grant_head(&log->l_reserve_head.grant, &cycle, &bytes);
	240	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, bytes);
	241	}
	242	XFS_SYSFS_ATTR_RO(reserve_grant_head);
	243
	244	STATIC ssize_t
	245	write_grant_head_show(
	246	struct kobject *kobject,
	247	char *buf)
	248	{
	249	int cycle;
	250	int bytes;
	251	struct xlog *log = to_xlog(kobject);
	252
	253	xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &bytes);
	254	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, bytes);
	255	}
	256	XFS_SYSFS_ATTR_RO(write_grant_head);
	257
	258	#ifdef DEBUG
	259	STATIC ssize_t
	260	log_badcrc_factor_store(
	261	struct kobject *kobject,
	262	const char *buf,
	263	size_t count)
	264	{
	265	struct xlog *log = to_xlog(kobject);
	266	int ret;
	267	uint32_t val;
	268
	269	ret = kstrtouint(buf, 0, &val);
	270	if (ret)
	271	return ret;
	272
	273	log->l_badcrc_factor = val;
	274
	275	return count;
	276	}
	277
	278	STATIC ssize_t
	279	log_badcrc_factor_show(
	280	struct kobject *kobject,
	281	char *buf)
	282	{
	283	struct xlog *log = to_xlog(kobject);
	284
	285	return snprintf(buf, PAGE_SIZE, "%d\n", log->l_badcrc_factor);
	286	}
	287
	288	XFS_SYSFS_ATTR_RW(log_badcrc_factor);
	289	#endif /* DEBUG */
	290
	291	static struct attribute *xfs_log_attrs[] = {
	292	ATTR_LIST(log_head_lsn),
	293	ATTR_LIST(log_tail_lsn),
	294	ATTR_LIST(reserve_grant_head),
	295	ATTR_LIST(write_grant_head),
	296	#ifdef DEBUG
	297	ATTR_LIST(log_badcrc_factor),
	298	#endif
	299	NULL,
	300	};
	301
	302	struct kobj_type xfs_log_ktype = {
	303	.release = xfs_sysfs_release,
	304	.sysfs_ops = &xfs_sysfs_ops,
	305	.default_attrs = xfs_log_attrs,
	306	};