[linux-block.git] / fs / xfs / xfs_message.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2011 Red Hat, Inc.  All Rights Reserved.
 */

#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_error.h"
#include "xfs_shared.h"
#include "xfs_format.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"

/*
 * XFS logging functions
 */
static void
__xfs_printk(
	const char		*level,
	const struct xfs_mount	*mp,
	struct va_format	*vaf)
{
	if (mp && mp->m_super) {
		printk("%sXFS (%s): %pV\n", level, mp->m_super->s_id, vaf);
		return;
	}
	printk("%sXFS: %pV\n", level, vaf);
}

void
xfs_printk_level(
	const char *kern_level,
	const struct xfs_mount *mp,
	const char *fmt, ...)
{
	struct va_format	vaf;
	va_list			args;
	int			level;

	va_start(args, fmt);
	vaf.fmt = fmt;
	vaf.va = &args;

	__xfs_printk(kern_level, mp, &vaf);

	va_end(args);

	if (!kstrtoint(kern_level, 0, &level) &&
	    level <= LOGLEVEL_ERR &&
	    xfs_error_level >= XFS_ERRLEVEL_HIGH)
		xfs_stack_trace();
}

void
_xfs_alert_tag(
	const struct xfs_mount	*mp,
	uint32_t		panic_tag,
	const char		*fmt, ...)
{
	struct va_format	vaf;
	va_list			args;
	int			do_panic = 0;

	if (xfs_panic_mask && (xfs_panic_mask & panic_tag)) {
		xfs_alert(mp, "Transforming an alert into a BUG.");
		do_panic = 1;
	}

	va_start(args, fmt);

	vaf.fmt = fmt;
	vaf.va = &args;

	__xfs_printk(KERN_ALERT, mp, &vaf);
	va_end(args);

	BUG_ON(do_panic);
}

void
asswarn(
	struct xfs_mount	*mp,
	char			*expr,
	char			*file,
	int			line)
{
	xfs_warn(mp, "Assertion failed: %s, file: %s, line: %d",
		expr, file, line);
	WARN_ON(1);
}

void
assfail(
	struct xfs_mount	*mp,
	char			*expr,
	char			*file,
	int			line)
{
	xfs_emerg(mp, "Assertion failed: %s, file: %s, line: %d",
		expr, file, line);
	if (xfs_globals.bug_on_assert)
		BUG();
	else
		WARN_ON(1);
}

void
xfs_hex_dump(const void *p, int length)
{
	print_hex_dump(KERN_ALERT, "", DUMP_PREFIX_OFFSET, 16, 1, p, length, 1);
}

void
xfs_buf_alert_ratelimited(
	struct xfs_buf		*bp,
	const char		*rlmsg,
	const char		*fmt,
	...)
{
	struct xfs_mount	*mp = bp->b_mount;
	struct va_format	vaf;
	va_list			args;

	/* use the more aggressive per-target rate limit for buffers */
	if (!___ratelimit(&bp->b_target->bt_ioerror_rl, rlmsg))
		return;

	va_start(args, fmt);
	vaf.fmt = fmt;
	vaf.va = &args;
	__xfs_printk(KERN_ALERT, mp, &vaf);
	va_end(args);
}
Commit	Line	Data
0b61f8a4	1	// SPDX-License-Identifier: GPL-2.0
10e38391 DC	2	/*
10e38391 DC	3	* Copyright (c) 2011 Red Hat, Inc. All Rights Reserved.
10e38391 DC	4	*/
	5
	6	#include "xfs.h"
	7	#include "xfs_fs.h"
847f9f68	8	#include "xfs_error.h"
5467b34b	9	#include "xfs_shared.h"
4fb6e8ad	10	#include "xfs_format.h"
239880ef	11	#include "xfs_trans_resv.h"
10e38391 DC	12	#include "xfs_mount.h"
	13
	14	/*
	15	* XFS logging functions
	16	*/
957935dc	17	static void
10e38391 DC	18	__xfs_printk(
	19	const char *level,
	20	const struct xfs_mount *mp,
	21	struct va_format *vaf)
	22	{
e1d3d218 IK	23	if (mp && mp->m_super) {
e1d3d218 IK	24	printk("%sXFS (%s): %pV\n", level, mp->m_super->s_id, vaf);
3eff1268 DC	25	return;
3eff1268 DC	26	}
957935dc	27	printk("%sXFS: %pV\n", level, vaf);
10e38391 DC	28	}
10e38391 DC	29
e60aa787 JL	30	void
	31	xfs_printk_level(
	32	const char *kern_level,
	33	const struct xfs_mount *mp,
	34	const char *fmt, ...)
	35	{
	36	struct va_format vaf;
	37	va_list args;
	38	int level;
10e38391	39
e60aa787 JL	40	va_start(args, fmt);
	41	vaf.fmt = fmt;
	42	vaf.va = &args;
	43
	44	__xfs_printk(kern_level, mp, &vaf);
	45
	46	va_end(args);
	47
	48	if (!kstrtoint(kern_level, 0, &level) &&
	49	level <= LOGLEVEL_ERR &&
	50	xfs_error_level >= XFS_ERRLEVEL_HIGH)
	51	xfs_stack_trace();
	52	}
10e38391	53
957935dc	54	void
e2703569	55	_xfs_alert_tag(
10e38391	56	const struct xfs_mount *mp,
90215d74	57	uint32_t panic_tag,
10e38391 DC	58	const char *fmt, ...)
	59	{
	60	struct va_format vaf;
	61	va_list args;
0c9ba973	62	int do_panic = 0;
10e38391 DC	63
10e38391 DC	64	if (xfs_panic_mask && (xfs_panic_mask & panic_tag)) {
e69522a8	65	xfs_alert(mp, "Transforming an alert into a BUG.");
0c9ba973	66	do_panic = 1;
10e38391 DC	67	}
	68
	69	va_start(args, fmt);
	70
	71	vaf.fmt = fmt;
	72	vaf.va = &args;
	73
957935dc	74	__xfs_printk(KERN_ALERT, mp, &vaf);
10e38391 DC	75	va_end(args);
10e38391 DC	76
0c9ba973	77	BUG_ON(do_panic);
10e38391	78	}
9130090b	79
742ae1e3	80	void
9842b56c DW	81	asswarn(
	82	struct xfs_mount *mp,
	83	char *expr,
	84	char *file,
	85	int line)
742ae1e3	86	{
9842b56c	87	xfs_warn(mp, "Assertion failed: %s, file: %s, line: %d",
742ae1e3 DC	88	expr, file, line);
	89	WARN_ON(1);
	90	}
	91
9130090b	92	void
9842b56c DW	93	assfail(
	94	struct xfs_mount *mp,
	95	char *expr,
	96	char *file,
	97	int line)
9130090b	98	{
9842b56c	99	xfs_emerg(mp, "Assertion failed: %s, file: %s, line: %d",
9130090b	100	expr, file, line);
ccdab3d6 BF	101	if (xfs_globals.bug_on_assert)
	102	BUG();
	103	else
	104	WARN_ON(1);
9130090b DC	105	}
	106
	107	void
d243b89a	108	xfs_hex_dump(const void *p, int length)
9130090b	109	{
bdec055b	110	print_hex_dump(KERN_ALERT, "", DUMP_PREFIX_OFFSET, 16, 1, p, length, 1);
9130090b	111	}
f9bccfcc BF	112
	113	void
	114	xfs_buf_alert_ratelimited(
	115	struct xfs_buf *bp,
	116	const char *rlmsg,
	117	const char *fmt,
	118	...)
	119	{
	120	struct xfs_mount *mp = bp->b_mount;
	121	struct va_format vaf;
	122	va_list args;
	123
	124	/* use the more aggressive per-target rate limit for buffers */
	125	if (!___ratelimit(&bp->b_target->bt_ioerror_rl, rlmsg))
	126	return;
	127
	128	va_start(args, fmt);
	129	vaf.fmt = fmt;
	130	vaf.va = &args;
	131	__xfs_printk(KERN_ALERT, mp, &vaf);
	132	va_end(args);
	133	}