[mirror_ubuntu-artful-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_shared.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_sysfs.h"
#include "xfs_log.h"
#include "xfs_log_priv.h"
#include "xfs_stats.h"
#include "xfs_mount.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

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,
};

/*
 * xfs_mount kobject. The mp kobject also serves as the per-mount parent object
 * that is identified by the fsname under sysfs.
 */

static inline struct xfs_mount *
to_mp(struct kobject *kobject)
{
	struct xfs_kobj *kobj = to_kobj(kobject);

	return container_of(kobj, struct xfs_mount, m_kobj);
}

static struct attribute *xfs_mp_attrs[] = {
	NULL,
};

struct kobj_type xfs_mp_ktype = {
	.release = xfs_sysfs_release,
	.sysfs_ops = &xfs_sysfs_ops,
	.default_attrs = xfs_mp_attrs,
};

#ifdef DEBUG
/* debug */

STATIC ssize_t
bug_on_assert_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 == 1)
		xfs_globals.bug_on_assert = true;
	else if (val == 0)
		xfs_globals.bug_on_assert = false;
	else
		return -EINVAL;

	return count;
}

STATIC ssize_t
bug_on_assert_show(
	struct kobject		*kobject,
	char			*buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", xfs_globals.bug_on_assert ? 1 : 0);
}
XFS_SYSFS_ATTR_RW(bug_on_assert);

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(bug_on_assert),
	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);

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),
	NULL,
};

struct kobj_type xfs_log_ktype = {
	.release = xfs_sysfs_release,
	.sysfs_ops = &xfs_sysfs_ops,
	.default_attrs = xfs_log_attrs,
};

/*
 * Metadata IO error configuration
 *
 * The sysfs structure here is:
 *	...xfs/<dev>/error/<class>/<errno>/<error_attrs>
 *
 * where <class> allows us to discriminate between data IO and metadata IO,
 * and any other future type of IO (e.g. special inode or directory error
 * handling) we care to support.
 */
static inline struct xfs_error_cfg *
to_error_cfg(struct kobject *kobject)
{
	struct xfs_kobj *kobj = to_kobj(kobject);
	return container_of(kobj, struct xfs_error_cfg, kobj);
}

static inline struct xfs_mount *
err_to_mp(struct kobject *kobject)
{
	struct xfs_kobj *kobj = to_kobj(kobject);
	return container_of(kobj, struct xfs_mount, m_error_kobj);
}

static ssize_t
max_retries_show(
	struct kobject	*kobject,
	char		*buf)
{
	int		retries;
	struct xfs_error_cfg *cfg = to_error_cfg(kobject);

	if (cfg->max_retries == XFS_ERR_RETRY_FOREVER)
		retries = -1;
	else
		retries = cfg->max_retries;

	return snprintf(buf, PAGE_SIZE, "%d\n", retries);
}

static ssize_t
max_retries_store(
	struct kobject	*kobject,
	const char	*buf,
	size_t		count)
{
	struct xfs_error_cfg *cfg = to_error_cfg(kobject);
	int		ret;
	int		val;

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

	if (val < -1)
		return -EINVAL;

	if (val == -1)
		cfg->max_retries = XFS_ERR_RETRY_FOREVER;
	else
		cfg->max_retries = val;
	return count;
}
XFS_SYSFS_ATTR_RW(max_retries);

static ssize_t
retry_timeout_seconds_show(
	struct kobject	*kobject,
	char		*buf)
{
	int		timeout;
	struct xfs_error_cfg *cfg = to_error_cfg(kobject);

	if (cfg->retry_timeout == XFS_ERR_RETRY_FOREVER)
		timeout = -1;
	else
		timeout = jiffies_to_msecs(cfg->retry_timeout) / MSEC_PER_SEC;

	return snprintf(buf, PAGE_SIZE, "%d\n", timeout);
}

static ssize_t
retry_timeout_seconds_store(
	struct kobject	*kobject,
	const char	*buf,
	size_t		count)
{
	struct xfs_error_cfg *cfg = to_error_cfg(kobject);
	int		ret;
	int		val;

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

	/* 1 day timeout maximum, -1 means infinite */
	if (val < -1 || val > 86400)
		return -EINVAL;

	if (val == -1)
		cfg->retry_timeout = XFS_ERR_RETRY_FOREVER;
	else {
		cfg->retry_timeout = msecs_to_jiffies(val * MSEC_PER_SEC);
		ASSERT(msecs_to_jiffies(val * MSEC_PER_SEC) < LONG_MAX);
	}
	return count;
}
XFS_SYSFS_ATTR_RW(retry_timeout_seconds);

static ssize_t
fail_at_unmount_show(
	struct kobject	*kobject,
	char		*buf)
{
	struct xfs_mount	*mp = err_to_mp(kobject);

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

static ssize_t
fail_at_unmount_store(
	struct kobject	*kobject,
	const char	*buf,
	size_t		count)
{
	struct xfs_mount	*mp = err_to_mp(kobject);
	int		ret;
	int		val;

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

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

	mp->m_fail_unmount = val;
	return count;
}
XFS_SYSFS_ATTR_RW(fail_at_unmount);

static struct attribute *xfs_error_attrs[] = {
	ATTR_LIST(max_retries),
	ATTR_LIST(retry_timeout_seconds),
	NULL,
};


static struct kobj_type xfs_error_cfg_ktype = {
	.release = xfs_sysfs_release,
	.sysfs_ops = &xfs_sysfs_ops,
	.default_attrs = xfs_error_attrs,
};

static struct kobj_type xfs_error_ktype = {
	.release = xfs_sysfs_release,
	.sysfs_ops = &xfs_sysfs_ops,
};

/*
 * Error initialization tables. These need to be ordered in the same
 * order as the enums used to index the array. All class init tables need to
 * define a "default" behaviour as the first entry, all other entries can be
 * empty.
 */
struct xfs_error_init {
	char		*name;
	int		max_retries;
	int		retry_timeout;	/* in seconds */
};

static const struct xfs_error_init xfs_error_meta_init[XFS_ERR_ERRNO_MAX] = {
	{ .name = "default",
	  .max_retries = XFS_ERR_RETRY_FOREVER,
	  .retry_timeout = XFS_ERR_RETRY_FOREVER,
	},
	{ .name = "EIO",
	  .max_retries = XFS_ERR_RETRY_FOREVER,
	  .retry_timeout = XFS_ERR_RETRY_FOREVER,
	},
	{ .name = "ENOSPC",
	  .max_retries = XFS_ERR_RETRY_FOREVER,
	  .retry_timeout = XFS_ERR_RETRY_FOREVER,
	},
	{ .name = "ENODEV",
	  .max_retries = 0,	/* We can't recover from devices disappearing */
	  .retry_timeout = 0,
	},
};

static int
xfs_error_sysfs_init_class(
	struct xfs_mount	*mp,
	int			class,
	const char		*parent_name,
	struct xfs_kobj		*parent_kobj,
	const struct xfs_error_init init[])
{
	struct xfs_error_cfg	*cfg;
	int			error;
	int			i;

	ASSERT(class < XFS_ERR_CLASS_MAX);

	error = xfs_sysfs_init(parent_kobj, &xfs_error_ktype,
				&mp->m_error_kobj, parent_name);
	if (error)
		return error;

	for (i = 0; i < XFS_ERR_ERRNO_MAX; i++) {
		cfg = &mp->m_error_cfg[class][i];
		error = xfs_sysfs_init(&cfg->kobj, &xfs_error_cfg_ktype,
					parent_kobj, init[i].name);
		if (error)
			goto out_error;

		cfg->max_retries = init[i].max_retries;
		if (init[i].retry_timeout == XFS_ERR_RETRY_FOREVER)
			cfg->retry_timeout = XFS_ERR_RETRY_FOREVER;
		else
			cfg->retry_timeout = msecs_to_jiffies(
					init[i].retry_timeout * MSEC_PER_SEC);
	}
	return 0;

out_error:
	/* unwind the entries that succeeded */
	for (i--; i >= 0; i--) {
		cfg = &mp->m_error_cfg[class][i];
		xfs_sysfs_del(&cfg->kobj);
	}
	xfs_sysfs_del(parent_kobj);
	return error;
}

int
xfs_error_sysfs_init(
	struct xfs_mount	*mp)
{
	int			error;

	/* .../xfs/<dev>/error/ */
	error = xfs_sysfs_init(&mp->m_error_kobj, &xfs_error_ktype,
				&mp->m_kobj, "error");
	if (error)
		return error;

	error = sysfs_create_file(&mp->m_error_kobj.kobject,
				  ATTR_LIST(fail_at_unmount));

	if (error)
		goto out_error;

	/* .../xfs/<dev>/error/metadata/ */
	error = xfs_error_sysfs_init_class(mp, XFS_ERR_METADATA,
				"metadata", &mp->m_error_meta_kobj,
				xfs_error_meta_init);
	if (error)
		goto out_error;

	return 0;

out_error:
	xfs_sysfs_del(&mp->m_error_kobj);
	return error;
}

void
xfs_error_sysfs_del(
	struct xfs_mount	*mp)
{
	struct xfs_error_cfg	*cfg;
	int			i, j;

	for (i = 0; i < XFS_ERR_CLASS_MAX; i++) {
		for (j = 0; j < XFS_ERR_ERRNO_MAX; j++) {
			cfg = &mp->m_error_cfg[i][j];

			xfs_sysfs_del(&cfg->kobj);
		}
	}
	xfs_sysfs_del(&mp->m_error_meta_kobj);
	xfs_sysfs_del(&mp->m_error_kobj);
}

struct xfs_error_cfg *
xfs_error_get_cfg(
	struct xfs_mount	*mp,
	int			error_class,
	int			error)
{
	struct xfs_error_cfg	*cfg;

	if (error < 0)
		error = -error;

	switch (error) {
	case EIO:
		cfg = &mp->m_error_cfg[error_class][XFS_ERR_EIO];
		break;
	case ENOSPC:
		cfg = &mp->m_error_cfg[error_class][XFS_ERR_ENOSPC];
		break;
	case ENODEV:
		cfg = &mp->m_error_cfg[error_class][XFS_ERR_ENODEV];
		break;
	default:
		cfg = &mp->m_error_cfg[error_class][XFS_ERR_DEFAULT];
		break;
	}

	return cfg;
}
Commit	Line	Data
a31b1d3d BF	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"
192852be	20	#include "xfs_shared.h"
801cc4e1	21	#include "xfs_format.h"
baff4e44	22	#include "xfs_log_format.h"
801cc4e1	23	#include "xfs_trans_resv.h"
192852be	24	#include "xfs_sysfs.h"
baff4e44 BF	25	#include "xfs_log.h"
baff4e44 BF	26	#include "xfs_log_priv.h"
bb230c12	27	#include "xfs_stats.h"
801cc4e1	28	#include "xfs_mount.h"
a31b1d3d BF	29
	30	struct xfs_sysfs_attr {
	31	struct attribute attr;
a27c2640 BD	32	ssize_t (show)(struct kobject kobject, char *buf);
	33	ssize_t (store)(struct kobject kobject, const char *buf,
	34	size_t count);
a31b1d3d BF	35	};
	36
	37	static inline struct xfs_sysfs_attr *
	38	to_attr(struct attribute *attr)
	39	{
	40	return container_of(attr, struct xfs_sysfs_attr, attr);
	41	}
	42
	43	#define XFS_SYSFS_ATTR_RW(name) \
	44	static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RW(name)
	45	#define XFS_SYSFS_ATTR_RO(name) \
	46	static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_RO(name)
bb230c12 BD	47	#define XFS_SYSFS_ATTR_WO(name) \
bb230c12 BD	48	static struct xfs_sysfs_attr xfs_sysfs_attr_##name = __ATTR_WO(name)
a31b1d3d BF	49
	50	#define ATTR_LIST(name) &xfs_sysfs_attr_##name.attr
	51
a27c2640 BD	52	STATIC ssize_t
	53	xfs_sysfs_object_show(
	54	struct kobject *kobject,
	55	struct attribute *attr,
	56	char *buf)
	57	{
	58	struct xfs_sysfs_attr *xfs_attr = to_attr(attr);
	59
	60	return xfs_attr->show ? xfs_attr->show(kobject, buf) : 0;
	61	}
	62
	63	STATIC ssize_t
	64	xfs_sysfs_object_store(
	65	struct kobject *kobject,
	66	struct attribute *attr,
	67	const char *buf,
	68	size_t count)
	69	{
	70	struct xfs_sysfs_attr *xfs_attr = to_attr(attr);
	71
	72	return xfs_attr->store ? xfs_attr->store(kobject, buf, count) : 0;
	73	}
	74
	75	static const struct sysfs_ops xfs_sysfs_ops = {
	76	.show = xfs_sysfs_object_show,
	77	.store = xfs_sysfs_object_store,
	78	};
	79
801cc4e1 BF	80	/*
	81	* xfs_mount kobject. The mp kobject also serves as the per-mount parent object
	82	* that is identified by the fsname under sysfs.
	83	*/
	84
	85	static inline struct xfs_mount *
	86	to_mp(struct kobject *kobject)
	87	{
	88	struct xfs_kobj *kobj = to_kobj(kobject);
	89
	90	return container_of(kobj, struct xfs_mount, m_kobj);
	91	}
	92
801cc4e1	93	static struct attribute *xfs_mp_attrs[] = {
801cc4e1 BF	94	NULL,
	95	};
	96
	97	struct kobj_type xfs_mp_ktype = {
	98	.release = xfs_sysfs_release,
	99	.sysfs_ops = &xfs_sysfs_ops,
	100	.default_attrs = xfs_mp_attrs,
	101	};
	102
65b65735 BF	103	#ifdef DEBUG
	104	/* debug */
	105
ccdab3d6 BF	106	STATIC ssize_t
	107	bug_on_assert_store(
	108	struct kobject *kobject,
	109	const char *buf,
	110	size_t count)
	111	{
	112	int ret;
	113	int val;
	114
	115	ret = kstrtoint(buf, 0, &val);
	116	if (ret)
	117	return ret;
	118
	119	if (val == 1)
	120	xfs_globals.bug_on_assert = true;
	121	else if (val == 0)
	122	xfs_globals.bug_on_assert = false;
	123	else
	124	return -EINVAL;
	125
	126	return count;
	127	}
	128
	129	STATIC ssize_t
	130	bug_on_assert_show(
	131	struct kobject *kobject,
	132	char *buf)
	133	{
	134	return snprintf(buf, PAGE_SIZE, "%d\n", xfs_globals.bug_on_assert ? 1 : 0);
	135	}
	136	XFS_SYSFS_ATTR_RW(bug_on_assert);
	137
2e227178 BF	138	STATIC ssize_t
2e227178 BF	139	log_recovery_delay_store(
a27c2640	140	struct kobject *kobject,
2e227178	141	const char *buf,
a27c2640	142	size_t count)
2e227178 BF	143	{
	144	int ret;
	145	int val;
	146
	147	ret = kstrtoint(buf, 0, &val);
	148	if (ret)
	149	return ret;
	150
	151	if (val < 0 \|\| val > 60)
	152	return -EINVAL;
	153
	154	xfs_globals.log_recovery_delay = val;
	155
	156	return count;
	157	}
	158
	159	STATIC ssize_t
	160	log_recovery_delay_show(
a27c2640 BD	161	struct kobject *kobject,
a27c2640 BD	162	char *buf)
2e227178 BF	163	{
	164	return snprintf(buf, PAGE_SIZE, "%d\n", xfs_globals.log_recovery_delay);
	165	}
	166	XFS_SYSFS_ATTR_RW(log_recovery_delay);
	167
65b65735	168	static struct attribute *xfs_dbg_attrs[] = {
ccdab3d6	169	ATTR_LIST(bug_on_assert),
2e227178	170	ATTR_LIST(log_recovery_delay),
65b65735 BF	171	NULL,
	172	};
	173
65b65735 BF	174	struct kobj_type xfs_dbg_ktype = {
65b65735 BF	175	.release = xfs_sysfs_release,
a27c2640	176	.sysfs_ops = &xfs_sysfs_ops,
65b65735 BF	177	.default_attrs = xfs_dbg_attrs,
	178	};
	179
	180	#endif /* DEBUG */
	181
bb230c12 BD	182	/* stats */
bb230c12 BD	183
80529c45 BD	184	static inline struct xstats *
	185	to_xstats(struct kobject *kobject)
	186	{
	187	struct xfs_kobj *kobj = to_kobj(kobject);
	188
	189	return container_of(kobj, struct xstats, xs_kobj);
	190	}
	191
bb230c12 BD	192	STATIC ssize_t
bb230c12 BD	193	stats_show(
a27c2640 BD	194	struct kobject *kobject,
a27c2640 BD	195	char *buf)
bb230c12	196	{
80529c45 BD	197	struct xstats *stats = to_xstats(kobject);
	198
	199	return xfs_stats_format(stats->xs_stats, buf);
bb230c12 BD	200	}
	201	XFS_SYSFS_ATTR_RO(stats);
	202
	203	STATIC ssize_t
	204	stats_clear_store(
a27c2640	205	struct kobject *kobject,
bb230c12	206	const char *buf,
a27c2640	207	size_t count)
bb230c12 BD	208	{
	209	int ret;
	210	int val;
80529c45	211	struct xstats *stats = to_xstats(kobject);
bb230c12 BD	212
	213	ret = kstrtoint(buf, 0, &val);
	214	if (ret)
	215	return ret;
	216
	217	if (val != 1)
	218	return -EINVAL;
80529c45 BD	219
80529c45 BD	220	xfs_stats_clearall(stats->xs_stats);
bb230c12 BD	221	return count;
	222	}
	223	XFS_SYSFS_ATTR_WO(stats_clear);
	224
	225	static struct attribute *xfs_stats_attrs[] = {
	226	ATTR_LIST(stats),
	227	ATTR_LIST(stats_clear),
	228	NULL,
	229	};
	230
bb230c12 BD	231	struct kobj_type xfs_stats_ktype = {
bb230c12 BD	232	.release = xfs_sysfs_release,
a27c2640	233	.sysfs_ops = &xfs_sysfs_ops,
bb230c12 BD	234	.default_attrs = xfs_stats_attrs,
	235	};
	236
baff4e44 BF	237	/* xlog */
baff4e44 BF	238
a27c2640 BD	239	static inline struct xlog *
	240	to_xlog(struct kobject *kobject)
	241	{
	242	struct xfs_kobj *kobj = to_kobj(kobject);
	243
	244	return container_of(kobj, struct xlog, l_kobj);
	245	}
	246
80d6d698 BF	247	STATIC ssize_t
80d6d698 BF	248	log_head_lsn_show(
a27c2640 BD	249	struct kobject *kobject,
a27c2640 BD	250	char *buf)
80d6d698	251	{
80d6d698 BF	252	int cycle;
80d6d698 BF	253	int block;
a27c2640	254	struct xlog *log = to_xlog(kobject);
80d6d698 BF	255
	256	spin_lock(&log->l_icloglock);
	257	cycle = log->l_curr_cycle;
	258	block = log->l_curr_block;
	259	spin_unlock(&log->l_icloglock);
	260
	261	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, block);
	262	}
	263	XFS_SYSFS_ATTR_RO(log_head_lsn);
	264
	265	STATIC ssize_t
	266	log_tail_lsn_show(
a27c2640 BD	267	struct kobject *kobject,
a27c2640 BD	268	char *buf)
80d6d698	269	{
80d6d698 BF	270	int cycle;
80d6d698 BF	271	int block;
a27c2640	272	struct xlog *log = to_xlog(kobject);
80d6d698 BF	273
	274	xlog_crack_atomic_lsn(&log->l_tail_lsn, &cycle, &block);
	275	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, block);
	276	}
	277	XFS_SYSFS_ATTR_RO(log_tail_lsn);
	278
	279	STATIC ssize_t
	280	reserve_grant_head_show(
a27c2640 BD	281	struct kobject *kobject,
	282	char *buf)
	283
80d6d698	284	{
80d6d698 BF	285	int cycle;
80d6d698 BF	286	int bytes;
a27c2640	287	struct xlog *log = to_xlog(kobject);
80d6d698 BF	288
	289	xlog_crack_grant_head(&log->l_reserve_head.grant, &cycle, &bytes);
	290	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, bytes);
	291	}
	292	XFS_SYSFS_ATTR_RO(reserve_grant_head);
	293
	294	STATIC ssize_t
	295	write_grant_head_show(
a27c2640 BD	296	struct kobject *kobject,
a27c2640 BD	297	char *buf)
80d6d698	298	{
80d6d698 BF	299	int cycle;
80d6d698 BF	300	int bytes;
a27c2640	301	struct xlog *log = to_xlog(kobject);
80d6d698 BF	302
	303	xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &bytes);
	304	return snprintf(buf, PAGE_SIZE, "%d:%d\n", cycle, bytes);
	305	}
	306	XFS_SYSFS_ATTR_RO(write_grant_head);
	307
baff4e44	308	static struct attribute *xfs_log_attrs[] = {
80d6d698 BF	309	ATTR_LIST(log_head_lsn),
	310	ATTR_LIST(log_tail_lsn),
	311	ATTR_LIST(reserve_grant_head),
	312	ATTR_LIST(write_grant_head),
baff4e44 BF	313	NULL,
	314	};
	315
baff4e44 BF	316	struct kobj_type xfs_log_ktype = {
baff4e44 BF	317	.release = xfs_sysfs_release,
a27c2640	318	.sysfs_ops = &xfs_sysfs_ops,
baff4e44 BF	319	.default_attrs = xfs_log_attrs,
baff4e44 BF	320	};
192852be CM	321
	322	/*
	323	* Metadata IO error configuration
	324	*
	325	* The sysfs structure here is:
	326	* ...xfs/<dev>/error/<class>/<errno>/<error_attrs>
	327	*
	328	* where <class> allows us to discriminate between data IO and metadata IO,
	329	* and any other future type of IO (e.g. special inode or directory error
	330	* handling) we care to support.
	331	*/
192852be CM	332	static inline struct xfs_error_cfg *
	333	to_error_cfg(struct kobject *kobject)
	334	{
	335	struct xfs_kobj *kobj = to_kobj(kobject);
	336	return container_of(kobj, struct xfs_error_cfg, kobj);
	337	}
	338
e6b3bb78 CM	339	static inline struct xfs_mount *
	340	err_to_mp(struct kobject *kobject)
	341	{
	342	struct xfs_kobj *kobj = to_kobj(kobject);
	343	return container_of(kobj, struct xfs_mount, m_error_kobj);
	344	}
	345
a5ea70d2 CM	346	static ssize_t
	347	max_retries_show(
	348	struct kobject *kobject,
	349	char *buf)
	350	{
77169812	351	int retries;
a5ea70d2 CM	352	struct xfs_error_cfg *cfg = to_error_cfg(kobject);
a5ea70d2 CM	353
ff97f239	354	if (cfg->max_retries == XFS_ERR_RETRY_FOREVER)
77169812 ES	355	retries = -1;
	356	else
	357	retries = cfg->max_retries;
	358
	359	return snprintf(buf, PAGE_SIZE, "%d\n", retries);
a5ea70d2 CM	360	}
	361
	362	static ssize_t
	363	max_retries_store(
	364	struct kobject *kobject,
	365	const char *buf,
	366	size_t count)
	367	{
	368	struct xfs_error_cfg *cfg = to_error_cfg(kobject);
	369	int ret;
	370	int val;
	371
	372	ret = kstrtoint(buf, 0, &val);
	373	if (ret)
	374	return ret;
	375
	376	if (val < -1)
	377	return -EINVAL;
	378
77169812	379	if (val == -1)
ff97f239	380	cfg->max_retries = XFS_ERR_RETRY_FOREVER;
77169812 ES	381	else
77169812 ES	382	cfg->max_retries = val;
a5ea70d2 CM	383	return count;
	384	}
	385	XFS_SYSFS_ATTR_RW(max_retries);
	386
	387	static ssize_t
	388	retry_timeout_seconds_show(
	389	struct kobject *kobject,
	390	char *buf)
	391	{
77169812	392	int timeout;
a5ea70d2 CM	393	struct xfs_error_cfg *cfg = to_error_cfg(kobject);
a5ea70d2 CM	394
77169812 ES	395	if (cfg->retry_timeout == XFS_ERR_RETRY_FOREVER)
	396	timeout = -1;
	397	else
	398	timeout = jiffies_to_msecs(cfg->retry_timeout) / MSEC_PER_SEC;
	399
	400	return snprintf(buf, PAGE_SIZE, "%d\n", timeout);
a5ea70d2 CM	401	}
	402
	403	static ssize_t
	404	retry_timeout_seconds_store(
	405	struct kobject *kobject,
	406	const char *buf,
	407	size_t count)
	408	{
	409	struct xfs_error_cfg *cfg = to_error_cfg(kobject);
	410	int ret;
	411	int val;
	412
	413	ret = kstrtoint(buf, 0, &val);
	414	if (ret)
	415	return ret;
	416
77169812 ES	417	/* 1 day timeout maximum, -1 means infinite */
77169812 ES	418	if (val < -1 \|\| val > 86400)
a5ea70d2 CM	419	return -EINVAL;
a5ea70d2 CM	420
77169812 ES	421	if (val == -1)
	422	cfg->retry_timeout = XFS_ERR_RETRY_FOREVER;
	423	else {
	424	cfg->retry_timeout = msecs_to_jiffies(val * MSEC_PER_SEC);
	425	ASSERT(msecs_to_jiffies(val * MSEC_PER_SEC) < LONG_MAX);
	426	}
a5ea70d2 CM	427	return count;
	428	}
	429	XFS_SYSFS_ATTR_RW(retry_timeout_seconds);
	430
e6b3bb78 CM	431	static ssize_t
	432	fail_at_unmount_show(
	433	struct kobject *kobject,
	434	char *buf)
	435	{
	436	struct xfs_mount *mp = err_to_mp(kobject);
	437
	438	return snprintf(buf, PAGE_SIZE, "%d\n", mp->m_fail_unmount);
	439	}
	440
	441	static ssize_t
	442	fail_at_unmount_store(
	443	struct kobject *kobject,
	444	const char *buf,
	445	size_t count)
	446	{
	447	struct xfs_mount *mp = err_to_mp(kobject);
	448	int ret;
	449	int val;
	450
	451	ret = kstrtoint(buf, 0, &val);
	452	if (ret)
	453	return ret;
	454
	455	if (val < 0 \|\| val > 1)
	456	return -EINVAL;
	457
	458	mp->m_fail_unmount = val;
	459	return count;
	460	}
	461	XFS_SYSFS_ATTR_RW(fail_at_unmount);
	462
a5ea70d2 CM	463	static struct attribute *xfs_error_attrs[] = {
	464	ATTR_LIST(max_retries),
	465	ATTR_LIST(retry_timeout_seconds),
	466	NULL,
	467	};
	468
	469
f1b8243c	470	static struct kobj_type xfs_error_cfg_ktype = {
192852be CM	471	.release = xfs_sysfs_release,
	472	.sysfs_ops = &xfs_sysfs_ops,
	473	.default_attrs = xfs_error_attrs,
	474	};
	475
f1b8243c	476	static struct kobj_type xfs_error_ktype = {
192852be	477	.release = xfs_sysfs_release,
e6b3bb78	478	.sysfs_ops = &xfs_sysfs_ops,
192852be CM	479	};
192852be CM	480
ef6a50fb CM	481	/*
	482	* Error initialization tables. These need to be ordered in the same
	483	* order as the enums used to index the array. All class init tables need to
	484	* define a "default" behaviour as the first entry, all other entries can be
	485	* empty.
	486	*/
	487	struct xfs_error_init {
	488	char *name;
	489	int max_retries;
a5ea70d2	490	int retry_timeout; /* in seconds */
ef6a50fb CM	491	};
	492
	493	static const struct xfs_error_init xfs_error_meta_init[XFS_ERR_ERRNO_MAX] = {
	494	{ .name = "default",
e0a431b3	495	.max_retries = XFS_ERR_RETRY_FOREVER,
77169812	496	.retry_timeout = XFS_ERR_RETRY_FOREVER,
ef6a50fb	497	},
e0a431b3 CM	498	{ .name = "EIO",
e0a431b3 CM	499	.max_retries = XFS_ERR_RETRY_FOREVER,
77169812	500	.retry_timeout = XFS_ERR_RETRY_FOREVER,
e0a431b3 CM	501	},
	502	{ .name = "ENOSPC",
	503	.max_retries = XFS_ERR_RETRY_FOREVER,
77169812	504	.retry_timeout = XFS_ERR_RETRY_FOREVER,
e0a431b3 CM	505	},
e0a431b3 CM	506	{ .name = "ENODEV",
77169812 ES	507	.max_retries = 0, /* We can't recover from devices disappearing */
77169812 ES	508	.retry_timeout = 0,
e0a431b3	509	},
ef6a50fb CM	510	};
	511
	512	static int
	513	xfs_error_sysfs_init_class(
	514	struct xfs_mount *mp,
	515	int class,
	516	const char *parent_name,
	517	struct xfs_kobj *parent_kobj,
	518	const struct xfs_error_init init[])
	519	{
	520	struct xfs_error_cfg *cfg;
	521	int error;
	522	int i;
	523
	524	ASSERT(class < XFS_ERR_CLASS_MAX);
	525
	526	error = xfs_sysfs_init(parent_kobj, &xfs_error_ktype,
	527	&mp->m_error_kobj, parent_name);
	528	if (error)
	529	return error;
	530
	531	for (i = 0; i < XFS_ERR_ERRNO_MAX; i++) {
	532	cfg = &mp->m_error_cfg[class][i];
	533	error = xfs_sysfs_init(&cfg->kobj, &xfs_error_cfg_ktype,
	534	parent_kobj, init[i].name);
	535	if (error)
	536	goto out_error;
	537
	538	cfg->max_retries = init[i].max_retries;
77169812 ES	539	if (init[i].retry_timeout == XFS_ERR_RETRY_FOREVER)
	540	cfg->retry_timeout = XFS_ERR_RETRY_FOREVER;
	541	else
	542	cfg->retry_timeout = msecs_to_jiffies(
a5ea70d2	543	init[i].retry_timeout * MSEC_PER_SEC);
ef6a50fb CM	544	}
	545	return 0;
	546
	547	out_error:
	548	/* unwind the entries that succeeded */
	549	for (i--; i >= 0; i--) {
	550	cfg = &mp->m_error_cfg[class][i];
	551	xfs_sysfs_del(&cfg->kobj);
	552	}
	553	xfs_sysfs_del(parent_kobj);
	554	return error;
	555	}
	556
192852be CM	557	int
	558	xfs_error_sysfs_init(
	559	struct xfs_mount *mp)
	560	{
	561	int error;
	562
	563	/* .../xfs/<dev>/error/ */
	564	error = xfs_sysfs_init(&mp->m_error_kobj, &xfs_error_ktype,
	565	&mp->m_kobj, "error");
ffd40ef6 CM	566	if (error)
	567	return error;
	568
e6b3bb78 CM	569	error = sysfs_create_file(&mp->m_error_kobj.kobject,
	570	ATTR_LIST(fail_at_unmount));
	571
	572	if (error)
	573	goto out_error;
	574
ffd40ef6	575	/* .../xfs/<dev>/error/metadata/ */
ef6a50fb CM	576	error = xfs_error_sysfs_init_class(mp, XFS_ERR_METADATA,
	577	"metadata", &mp->m_error_meta_kobj,
	578	xfs_error_meta_init);
ffd40ef6 CM	579	if (error)
	580	goto out_error;
	581
ffd40ef6 CM	582	return 0;
ffd40ef6 CM	583
ffd40ef6 CM	584	out_error:
ffd40ef6 CM	585	xfs_sysfs_del(&mp->m_error_kobj);
192852be CM	586	return error;
	587	}
	588
	589	void
	590	xfs_error_sysfs_del(
	591	struct xfs_mount *mp)
	592	{
ffd40ef6 CM	593	struct xfs_error_cfg *cfg;
	594	int i, j;
	595
	596	for (i = 0; i < XFS_ERR_CLASS_MAX; i++) {
	597	for (j = 0; j < XFS_ERR_ERRNO_MAX; j++) {
	598	cfg = &mp->m_error_cfg[i][j];
	599
	600	xfs_sysfs_del(&cfg->kobj);
	601	}
	602	}
	603	xfs_sysfs_del(&mp->m_error_meta_kobj);
192852be CM	604	xfs_sysfs_del(&mp->m_error_kobj);
192852be CM	605	}
df309390 CM	606
	607	struct xfs_error_cfg *
	608	xfs_error_get_cfg(
	609	struct xfs_mount *mp,
	610	int error_class,
	611	int error)
	612	{
	613	struct xfs_error_cfg *cfg;
	614
e97f6c54 ES	615	if (error < 0)
	616	error = -error;
	617
df309390	618	switch (error) {
e0a431b3 CM	619	case EIO:
	620	cfg = &mp->m_error_cfg[error_class][XFS_ERR_EIO];
	621	break;
	622	case ENOSPC:
	623	cfg = &mp->m_error_cfg[error_class][XFS_ERR_ENOSPC];
	624	break;
	625	case ENODEV:
	626	cfg = &mp->m_error_cfg[error_class][XFS_ERR_ENODEV];
	627	break;
df309390 CM	628	default:
	629	cfg = &mp->m_error_cfg[error_class][XFS_ERR_DEFAULT];
	630	break;
	631	}
	632
	633	return cfg;
	634	}