fs/xfs/xfs_error.c - kernel/common.git - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  */
 #include "xfs.h"
 #include "xfs_shared.h"
 #include "xfs_format.h"
 #include "xfs_fs.h"
 #include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
 #include "xfs_mount.h"
 #include "xfs_error.h"
 #include "xfs_sysfs.h"
 #include "xfs_inode.h"

 #ifdef DEBUG

 #define XFS_ERRTAG(_tag, _name, _default) \
 	[XFS_ERRTAG_##_tag]	= (_default),
 #include "xfs_errortag.h"
 static const unsigned int xfs_errortag_random_default[] = { XFS_ERRTAGS };
 #undef XFS_ERRTAG

 struct xfs_errortag_attr {
 	struct attribute	attr;
 	unsigned int		tag;
 };

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

 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_errortag_kobj);
 }

 STATIC ssize_t
 xfs_errortag_attr_store(
 	struct kobject		*kobject,
 	struct attribute	*attr,
 	const char		*buf,
 	size_t			count)
 {
 	struct xfs_mount	*mp = to_mp(kobject);
 	unsigned int		error_tag = to_attr(attr)->tag;
 	int			ret;

 	if (strcmp(buf, "default") == 0) {
 		mp->m_errortag[error_tag] =
 			xfs_errortag_random_default[error_tag];
 	} else {
 		ret = kstrtouint(buf, 0, &mp->m_errortag[error_tag]);
 		if (ret)
 			return ret;
 	}

 	return count;
 }

 STATIC ssize_t
 xfs_errortag_attr_show(
 	struct kobject		*kobject,
 	struct attribute	*attr,
 	char			*buf)
 {
 	struct xfs_mount	*mp = to_mp(kobject);
 	unsigned int		error_tag = to_attr(attr)->tag;

 	return snprintf(buf, PAGE_SIZE, "%u\n", mp->m_errortag[error_tag]);
 }

 static const struct sysfs_ops xfs_errortag_sysfs_ops = {
 	.show = xfs_errortag_attr_show,
 	.store = xfs_errortag_attr_store,
 };

 #define XFS_ERRTAG(_tag, _name, _default)				\
 static struct xfs_errortag_attr xfs_errortag_attr_##_name = {		\
 	.attr = {.name = __stringify(_name),				\
 		 .mode = VERIFY_OCTAL_PERMISSIONS(S_IWUSR | S_IRUGO) },	\
 	.tag	= XFS_ERRTAG_##_tag,					\
 };
 #include "xfs_errortag.h"
 XFS_ERRTAGS
 #undef XFS_ERRTAG

 #define XFS_ERRTAG(_tag, _name, _default) \
 	&xfs_errortag_attr_##_name.attr,
 #include "xfs_errortag.h"
 static struct attribute *xfs_errortag_attrs[] = {
 	XFS_ERRTAGS
 	NULL
 };
 ATTRIBUTE_GROUPS(xfs_errortag);
 #undef XFS_ERRTAG

 /* -1 because XFS_ERRTAG_DROP_WRITES got removed, + 1 for NULL termination */
 static_assert(ARRAY_SIZE(xfs_errortag_attrs) == XFS_ERRTAG_MAX);

 static const struct kobj_type xfs_errortag_ktype = {
 	.release = xfs_sysfs_release,
 	.sysfs_ops = &xfs_errortag_sysfs_ops,
 	.default_groups = xfs_errortag_groups,
 };

 int
 xfs_errortag_init(
 	struct xfs_mount	*mp)
 {
 	int ret;

 	mp->m_errortag = kzalloc(sizeof(unsigned int) * XFS_ERRTAG_MAX,
 				GFP_KERNEL | __GFP_RETRY_MAYFAIL);
 	if (!mp->m_errortag)
 		return -ENOMEM;

 	ret = xfs_sysfs_init(&mp->m_errortag_kobj, &xfs_errortag_ktype,
 				&mp->m_kobj, "errortag");
 	if (ret)
 		kfree(mp->m_errortag);
 	return ret;
 }

 void
 xfs_errortag_del(
 	struct xfs_mount	*mp)
 {
 	xfs_sysfs_del(&mp->m_errortag_kobj);
 	kfree(mp->m_errortag);
 }

 static bool
 xfs_errortag_valid(
 	unsigned int		error_tag)
 {
 	if (error_tag >= XFS_ERRTAG_MAX)
 		return false;

 	/* Error out removed injection types */
 	if (error_tag == XFS_ERRTAG_DROP_WRITES)
 		return false;
 	return true;
 }

 bool
 xfs_errortag_enabled(
 	struct xfs_mount	*mp,
 	unsigned int		tag)
 {
 	if (!mp->m_errortag)
 		return false;
 	if (!xfs_errortag_valid(tag))
 		return false;

 	return mp->m_errortag[tag] != 0;
 }

 bool
 xfs_errortag_test(
 	struct xfs_mount	*mp,
 	const char		*file,
 	int			line,
 	unsigned int		error_tag)
 {
 	unsigned int		randfactor;

 	/*
 	 * To be able to use error injection anywhere, we need to ensure error
 	 * injection mechanism is already initialized.
 	 *
 	 * Code paths like I/O completion can be called before the
 	 * initialization is complete, but be able to inject errors in such
 	 * places is still useful.
 	 */
 	if (!mp->m_errortag)
 		return false;

 	if (!xfs_errortag_valid(error_tag))
 		return false;

 	randfactor = mp->m_errortag[error_tag];
 	if (!randfactor || get_random_u32_below(randfactor))
 		return false;

 	xfs_warn_ratelimited(mp,
 "Injecting error at file %s, line %d, on filesystem \"%s\"",
 			file, line, mp->m_super->s_id);
 	return true;
 }

 int
 xfs_errortag_add(
 	struct xfs_mount	*mp,
 	unsigned int		error_tag)
 {
 	BUILD_BUG_ON(ARRAY_SIZE(xfs_errortag_random_default) != XFS_ERRTAG_MAX);

 	if (!xfs_errortag_valid(error_tag))
 		return -EINVAL;
 	mp->m_errortag[error_tag] = xfs_errortag_random_default[error_tag];
 	return 0;
 }

 int
 xfs_errortag_clearall(
 	struct xfs_mount	*mp)
 {
 	memset(mp->m_errortag, 0, sizeof(unsigned int) * XFS_ERRTAG_MAX);
 	return 0;
 }
 #endif /* DEBUG */

 void
 xfs_error_report(
 	const char		*tag,
 	int			level,
 	struct xfs_mount	*mp,
 	const char		*filename,
 	int			linenum,
 	xfs_failaddr_t		failaddr)
 {
 	if (level <= xfs_error_level) {
 		xfs_alert_tag(mp, XFS_PTAG_ERROR_REPORT,
 		"Internal error %s at line %d of file %s.  Caller %pS",
 			    tag, linenum, filename, failaddr);

 		xfs_stack_trace();
 	}
 }

 void
 xfs_corruption_error(
 	const char		*tag,
 	int			level,
 	struct xfs_mount	*mp,
 	const void		*buf,
 	size_t			bufsize,
 	const char		*filename,
 	int			linenum,
 	xfs_failaddr_t		failaddr)
 {
 	if (buf && level <= xfs_error_level)
 		xfs_hex_dump(buf, bufsize);
 	xfs_error_report(tag, level, mp, filename, linenum, failaddr);
 	xfs_alert(mp, "Corruption detected. Unmount and run xfs_repair");
 }

 /*
  * Complain about the kinds of metadata corruption that we can't detect from a
  * verifier, such as incorrect inter-block relationship data.  Does not set
  * bp->b_error.
  *
  * Call xfs_buf_mark_corrupt, not this function.
  */
 void
 xfs_buf_corruption_error(
 	struct xfs_buf		*bp,
 	xfs_failaddr_t		fa)
 {
 	struct xfs_mount	*mp = bp->b_mount;

 	xfs_alert_tag(mp, XFS_PTAG_VERIFIER_ERROR,
 		  "Metadata corruption detected at %pS, %s block 0x%llx",
 		  fa, bp->b_ops->name, xfs_buf_daddr(bp));

 	xfs_alert(mp, "Unmount and run xfs_repair");

 	if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
 		xfs_stack_trace();
 }

 /*
  * Warnings specifically for verifier errors.  Differentiate CRC vs. invalid
  * values, and omit the stack trace unless the error level is tuned high.
  */
 void
 xfs_buf_verifier_error(
 	struct xfs_buf		*bp,
 	int			error,
 	const char		*name,
 	const void		*buf,
 	size_t			bufsz,
 	xfs_failaddr_t		failaddr)
 {
 	struct xfs_mount	*mp = bp->b_mount;
 	xfs_failaddr_t		fa;
 	int			sz;

 	fa = failaddr ? failaddr : __return_address;
 	__xfs_buf_ioerror(bp, error, fa);

 	xfs_alert_tag(mp, XFS_PTAG_VERIFIER_ERROR,
 		  "Metadata %s detected at %pS, %s block 0x%llx %s",
 		  bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",
 		  fa, bp->b_ops->name, xfs_buf_daddr(bp), name);

 	xfs_alert(mp, "Unmount and run xfs_repair");

 	if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
 		sz = min_t(size_t, XFS_CORRUPTION_DUMP_LEN, bufsz);
 		xfs_alert(mp, "First %d bytes of corrupted metadata buffer:",
 				sz);
 		xfs_hex_dump(buf, sz);
 	}

 	if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
 		xfs_stack_trace();
 }

 /*
  * Warnings specifically for verifier errors.  Differentiate CRC vs. invalid
  * values, and omit the stack trace unless the error level is tuned high.
  */
 void
 xfs_verifier_error(
 	struct xfs_buf		*bp,
 	int			error,
 	xfs_failaddr_t		failaddr)
 {
 	return xfs_buf_verifier_error(bp, error, "", xfs_buf_offset(bp, 0),
 			XFS_CORRUPTION_DUMP_LEN, failaddr);
 }

 /*
  * Warnings for inode corruption problems.  Don't bother with the stack
  * trace unless the error level is turned up high.
  */
 void
 xfs_inode_verifier_error(
 	struct xfs_inode	*ip,
 	int			error,
 	const char		*name,
 	const void		*buf,
 	size_t			bufsz,
 	xfs_failaddr_t		failaddr)
 {
 	struct xfs_mount	*mp = ip->i_mount;
 	xfs_failaddr_t		fa;
 	int			sz;

 	fa = failaddr ? failaddr : __return_address;

 	xfs_alert(mp, "Metadata %s detected at %pS, inode 0x%llx %s",
 		  error == -EFSBADCRC ? "CRC error" : "corruption",
 		  fa, ip->i_ino, name);

 	xfs_alert(mp, "Unmount and run xfs_repair");

 	if (buf && xfs_error_level >= XFS_ERRLEVEL_LOW) {
 		sz = min_t(size_t, XFS_CORRUPTION_DUMP_LEN, bufsz);
 		xfs_alert(mp, "First %d bytes of corrupted metadata buffer:",
 				sz);
 		xfs_hex_dump(buf, sz);
 	}

 	if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
 		xfs_stack_trace();
 }
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
	* All Rights Reserved.
	*/
	#include "xfs.h"
	#include "xfs_shared.h"
	#include "xfs_format.h"
	#include "xfs_fs.h"
	#include "xfs_log_format.h"
	#include "xfs_trans_resv.h"
	#include "xfs_mount.h"
	#include "xfs_error.h"
	#include "xfs_sysfs.h"
	#include "xfs_inode.h"

	#ifdef DEBUG

	#define XFS_ERRTAG(_tag, _name, _default) \
	[XFS_ERRTAG_##_tag] = (_default),
	#include "xfs_errortag.h"
	static const unsigned int xfs_errortag_random_default[] = { XFS_ERRTAGS };
	#undef XFS_ERRTAG

	struct xfs_errortag_attr {
	struct attribute attr;
	unsigned int tag;
	};

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

	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_errortag_kobj);
	}

	STATIC ssize_t
	xfs_errortag_attr_store(
	struct kobject *kobject,
	struct attribute *attr,
	const char *buf,
	size_t count)
	{
	struct xfs_mount *mp = to_mp(kobject);
	unsigned int error_tag = to_attr(attr)->tag;
	int ret;

	if (strcmp(buf, "default") == 0) {
	mp->m_errortag[error_tag] =
	xfs_errortag_random_default[error_tag];
	} else {
	ret = kstrtouint(buf, 0, &mp->m_errortag[error_tag]);
	if (ret)
	return ret;
	}

	return count;
	}

	STATIC ssize_t
	xfs_errortag_attr_show(
	struct kobject *kobject,
	struct attribute *attr,
	char *buf)
	{
	struct xfs_mount *mp = to_mp(kobject);
	unsigned int error_tag = to_attr(attr)->tag;

	return snprintf(buf, PAGE_SIZE, "%u\n", mp->m_errortag[error_tag]);
	}

	static const struct sysfs_ops xfs_errortag_sysfs_ops = {
	.show = xfs_errortag_attr_show,
	.store = xfs_errortag_attr_store,
	};

	#define XFS_ERRTAG(_tag, _name, _default) \
	static struct xfs_errortag_attr xfs_errortag_attr_##_name = { \
	.attr = {.name = __stringify(_name), \
	.mode = VERIFY_OCTAL_PERMISSIONS(S_IWUSR \| S_IRUGO) }, \
	.tag = XFS_ERRTAG_##_tag, \
	};
	#include "xfs_errortag.h"
	XFS_ERRTAGS
	#undef XFS_ERRTAG

	#define XFS_ERRTAG(_tag, _name, _default) \
	&xfs_errortag_attr_##_name.attr,
	#include "xfs_errortag.h"
	static struct attribute *xfs_errortag_attrs[] = {
	XFS_ERRTAGS
	NULL
	};
	ATTRIBUTE_GROUPS(xfs_errortag);
	#undef XFS_ERRTAG

	/* -1 because XFS_ERRTAG_DROP_WRITES got removed, + 1 for NULL termination */
	static_assert(ARRAY_SIZE(xfs_errortag_attrs) == XFS_ERRTAG_MAX);

	static const struct kobj_type xfs_errortag_ktype = {
	.release = xfs_sysfs_release,
	.sysfs_ops = &xfs_errortag_sysfs_ops,
	.default_groups = xfs_errortag_groups,
	};

	int
	xfs_errortag_init(
	struct xfs_mount *mp)
	{
	int ret;

	mp->m_errortag = kzalloc(sizeof(unsigned int) * XFS_ERRTAG_MAX,
	GFP_KERNEL \| __GFP_RETRY_MAYFAIL);
	if (!mp->m_errortag)
	return -ENOMEM;

	ret = xfs_sysfs_init(&mp->m_errortag_kobj, &xfs_errortag_ktype,
	&mp->m_kobj, "errortag");
	if (ret)
	kfree(mp->m_errortag);
	return ret;
	}

	void
	xfs_errortag_del(
	struct xfs_mount *mp)
	{
	xfs_sysfs_del(&mp->m_errortag_kobj);
	kfree(mp->m_errortag);
	}

	static bool
	xfs_errortag_valid(
	unsigned int error_tag)
	{
	if (error_tag >= XFS_ERRTAG_MAX)
	return false;

	/* Error out removed injection types */
	if (error_tag == XFS_ERRTAG_DROP_WRITES)
	return false;
	return true;
	}

	bool
	xfs_errortag_enabled(
	struct xfs_mount *mp,
	unsigned int tag)
	{
	if (!mp->m_errortag)
	return false;
	if (!xfs_errortag_valid(tag))
	return false;

	return mp->m_errortag[tag] != 0;
	}

	bool
	xfs_errortag_test(
	struct xfs_mount *mp,
	const char *file,
	int line,
	unsigned int error_tag)
	{
	unsigned int randfactor;

	/*
	* To be able to use error injection anywhere, we need to ensure error
	* injection mechanism is already initialized.
	*
	* Code paths like I/O completion can be called before the
	* initialization is complete, but be able to inject errors in such
	* places is still useful.
	*/
	if (!mp->m_errortag)
	return false;

	if (!xfs_errortag_valid(error_tag))
	return false;

	randfactor = mp->m_errortag[error_tag];
	if (!randfactor \|\| get_random_u32_below(randfactor))
	return false;

	xfs_warn_ratelimited(mp,
	"Injecting error at file %s, line %d, on filesystem \"%s\"",
	file, line, mp->m_super->s_id);
	return true;
	}

	int
	xfs_errortag_add(
	struct xfs_mount *mp,
	unsigned int error_tag)
	{
	BUILD_BUG_ON(ARRAY_SIZE(xfs_errortag_random_default) != XFS_ERRTAG_MAX);

	if (!xfs_errortag_valid(error_tag))
	return -EINVAL;
	mp->m_errortag[error_tag] = xfs_errortag_random_default[error_tag];
	return 0;
	}

	int
	xfs_errortag_clearall(
	struct xfs_mount *mp)
	{
	memset(mp->m_errortag, 0, sizeof(unsigned int) * XFS_ERRTAG_MAX);
	return 0;
	}
	#endif /* DEBUG */

	void
	xfs_error_report(
	const char *tag,
	int level,
	struct xfs_mount *mp,
	const char *filename,
	int linenum,
	xfs_failaddr_t failaddr)
	{
	if (level <= xfs_error_level) {
	xfs_alert_tag(mp, XFS_PTAG_ERROR_REPORT,
	"Internal error %s at line %d of file %s. Caller %pS",
	tag, linenum, filename, failaddr);

	xfs_stack_trace();
	}
	}

	void
	xfs_corruption_error(
	const char *tag,
	int level,
	struct xfs_mount *mp,
	const void *buf,
	size_t bufsize,
	const char *filename,
	int linenum,
	xfs_failaddr_t failaddr)
	{
	if (buf && level <= xfs_error_level)
	xfs_hex_dump(buf, bufsize);
	xfs_error_report(tag, level, mp, filename, linenum, failaddr);
	xfs_alert(mp, "Corruption detected. Unmount and run xfs_repair");
	}

	/*
	* Complain about the kinds of metadata corruption that we can't detect from a
	* verifier, such as incorrect inter-block relationship data. Does not set
	* bp->b_error.
	*
	* Call xfs_buf_mark_corrupt, not this function.
	*/
	void
	xfs_buf_corruption_error(
	struct xfs_buf *bp,
	xfs_failaddr_t fa)
	{
	struct xfs_mount *mp = bp->b_mount;

	xfs_alert_tag(mp, XFS_PTAG_VERIFIER_ERROR,
	"Metadata corruption detected at %pS, %s block 0x%llx",
	fa, bp->b_ops->name, xfs_buf_daddr(bp));

	xfs_alert(mp, "Unmount and run xfs_repair");

	if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
	xfs_stack_trace();
	}

	/*
	* Warnings specifically for verifier errors. Differentiate CRC vs. invalid
	* values, and omit the stack trace unless the error level is tuned high.
	*/
	void
	xfs_buf_verifier_error(
	struct xfs_buf *bp,
	int error,
	const char *name,
	const void *buf,
	size_t bufsz,
	xfs_failaddr_t failaddr)
	{
	struct xfs_mount *mp = bp->b_mount;
	xfs_failaddr_t fa;
	int sz;

	fa = failaddr ? failaddr : __return_address;
	__xfs_buf_ioerror(bp, error, fa);

	xfs_alert_tag(mp, XFS_PTAG_VERIFIER_ERROR,
	"Metadata %s detected at %pS, %s block 0x%llx %s",
	bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",
	fa, bp->b_ops->name, xfs_buf_daddr(bp), name);

	xfs_alert(mp, "Unmount and run xfs_repair");

	if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
	sz = min_t(size_t, XFS_CORRUPTION_DUMP_LEN, bufsz);
	xfs_alert(mp, "First %d bytes of corrupted metadata buffer:",
	sz);
	xfs_hex_dump(buf, sz);
	}

	if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
	xfs_stack_trace();
	}

	/*
	* Warnings specifically for verifier errors. Differentiate CRC vs. invalid
	* values, and omit the stack trace unless the error level is tuned high.
	*/
	void
	xfs_verifier_error(
	struct xfs_buf *bp,
	int error,
	xfs_failaddr_t failaddr)
	{
	return xfs_buf_verifier_error(bp, error, "", xfs_buf_offset(bp, 0),
	XFS_CORRUPTION_DUMP_LEN, failaddr);
	}

	/*
	* Warnings for inode corruption problems. Don't bother with the stack
	* trace unless the error level is turned up high.
	*/
	void
	xfs_inode_verifier_error(
	struct xfs_inode *ip,
	int error,
	const char *name,
	const void *buf,
	size_t bufsz,
	xfs_failaddr_t failaddr)
	{
	struct xfs_mount *mp = ip->i_mount;
	xfs_failaddr_t fa;
	int sz;

	fa = failaddr ? failaddr : __return_address;

	xfs_alert(mp, "Metadata %s detected at %pS, inode 0x%llx %s",
	error == -EFSBADCRC ? "CRC error" : "corruption",
	fa, ip->i_ino, name);

	xfs_alert(mp, "Unmount and run xfs_repair");

	if (buf && xfs_error_level >= XFS_ERRLEVEL_LOW) {
	sz = min_t(size_t, XFS_CORRUPTION_DUMP_LEN, bufsz);
	xfs_alert(mp, "First %d bytes of corrupted metadata buffer:",
	sz);
	xfs_hex_dump(buf, sz);
	}

	if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
	xfs_stack_trace();
	}