[linux-block.git] / fs / btrfs / messages.c

// SPDX-License-Identifier: GPL-2.0

#include "fs.h"
#include "messages.h"
#include "discard.h"
#include "super.h"

#ifdef CONFIG_PRINTK

#define STATE_STRING_PREFACE	" state "
#define STATE_STRING_BUF_LEN	(sizeof(STATE_STRING_PREFACE) + BTRFS_FS_STATE_COUNT + 1)

/*
 * Characters to print to indicate error conditions or uncommon filesystem state.
 * RO is not an error.
 */
static const char fs_state_chars[] = {
	[BTRFS_FS_STATE_REMOUNTING]		= 'M',
	[BTRFS_FS_STATE_RO]			= 0,
	[BTRFS_FS_STATE_TRANS_ABORTED]		= 'A',
	[BTRFS_FS_STATE_DEV_REPLACING]		= 'R',
	[BTRFS_FS_STATE_DUMMY_FS_INFO]		= 0,
	[BTRFS_FS_STATE_NO_DATA_CSUMS]		= 'C',
	[BTRFS_FS_STATE_SKIP_META_CSUMS]	= 'S',
	[BTRFS_FS_STATE_LOG_CLEANUP_ERROR]	= 'L',
};

static void btrfs_state_to_string(const struct btrfs_fs_info *info, char *buf)
{
	unsigned int bit;
	bool states_printed = false;
	unsigned long fs_state = READ_ONCE(info->fs_state);
	char *curr = buf;

	memcpy(curr, STATE_STRING_PREFACE, sizeof(STATE_STRING_PREFACE));
	curr += sizeof(STATE_STRING_PREFACE) - 1;

	if (BTRFS_FS_ERROR(info)) {
		*curr++ = 'E';
		states_printed = true;
	}

	for_each_set_bit(bit, &fs_state, sizeof(fs_state)) {
		WARN_ON_ONCE(bit >= BTRFS_FS_STATE_COUNT);
		if ((bit < BTRFS_FS_STATE_COUNT) && fs_state_chars[bit]) {
			*curr++ = fs_state_chars[bit];
			states_printed = true;
		}
	}

	/* If no states were printed, reset the buffer */
	if (!states_printed)
		curr = buf;

	*curr++ = 0;
}
#endif

/*
 * Generally the error codes correspond to their respective errors, but there
 * are a few special cases.
 *
 * EUCLEAN: Any sort of corruption that we encounter.  The tree-checker for
 *          instance will return EUCLEAN if any of the blocks are corrupted in
 *          a way that is problematic.  We want to reserve EUCLEAN for these
 *          sort of corruptions.
 *
 * EROFS: If we check BTRFS_FS_STATE_ERROR and fail out with a return error, we
 *        need to use EROFS for this case.  We will have no idea of the
 *        original failure, that will have been reported at the time we tripped
 *        over the error.  Each subsequent error that doesn't have any context
 *        of the original error should use EROFS when handling BTRFS_FS_STATE_ERROR.
 */
const char * __attribute_const__ btrfs_decode_error(int error)
{
	char *errstr = "unknown";

	switch (error) {
	case -ENOENT:		/* -2 */
		errstr = "No such entry";
		break;
	case -EIO:		/* -5 */
		errstr = "IO failure";
		break;
	case -ENOMEM:		/* -12*/
		errstr = "Out of memory";
		break;
	case -EEXIST:		/* -17 */
		errstr = "Object already exists";
		break;
	case -ENOSPC:		/* -28 */
		errstr = "No space left";
		break;
	case -EROFS:		/* -30 */
		errstr = "Readonly filesystem";
		break;
	case -EOPNOTSUPP:	/* -95 */
		errstr = "Operation not supported";
		break;
	case -EUCLEAN:		/* -117 */
		errstr = "Filesystem corrupted";
		break;
	case -EDQUOT:		/* -122 */
		errstr = "Quota exceeded";
		break;
	}

	return errstr;
}

/*
 * Decodes expected errors from the caller and invokes the appropriate error
 * response.
 */
__cold
void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
		       unsigned int line, int error, const char *fmt, ...)
{
	struct super_block *sb = fs_info->sb;
#ifdef CONFIG_PRINTK
	char statestr[STATE_STRING_BUF_LEN];
	const char *errstr;
#endif

#ifdef CONFIG_PRINTK_INDEX
	printk_index_subsys_emit(
		"BTRFS: error (device %s%s) in %s:%d: errno=%d %s", KERN_CRIT, fmt);
#endif

	/*
	 * Special case: if the error is EROFS, and we're already under
	 * SB_RDONLY, then it is safe here.
	 */
	if (error == -EROFS && sb_rdonly(sb))
		return;

#ifdef CONFIG_PRINTK
	errstr = btrfs_decode_error(error);
	btrfs_state_to_string(fs_info, statestr);
	if (fmt) {
		struct va_format vaf;
		va_list args;

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

		pr_crit("BTRFS: error (device %s%s) in %s:%d: errno=%d %s (%pV)\n",
			sb->s_id, statestr, function, line, error, errstr, &vaf);
		va_end(args);
	} else {
		pr_crit("BTRFS: error (device %s%s) in %s:%d: errno=%d %s\n",
			sb->s_id, statestr, function, line, error, errstr);
	}
#endif

	/*
	 * Today we only save the error info to memory.  Long term we'll also
	 * send it down to the disk.
	 */
	WRITE_ONCE(fs_info->fs_error, error);

	/* Don't go through full error handling during mount. */
	if (!(sb->s_flags & SB_BORN))
		return;

	if (sb_rdonly(sb))
		return;

	btrfs_discard_stop(fs_info);

	/* Handle error by forcing the filesystem readonly. */
	btrfs_set_sb_rdonly(sb);
	btrfs_info(fs_info, "forced readonly");
	/*
	 * Note that a running device replace operation is not canceled here
	 * although there is no way to update the progress. It would add the
	 * risk of a deadlock, therefore the canceling is omitted. The only
	 * penalty is that some I/O remains active until the procedure
	 * completes. The next time when the filesystem is mounted writable
	 * again, the device replace operation continues.
	 */
}

#ifdef CONFIG_PRINTK
static const char * const logtypes[] = {
	"emergency",
	"alert",
	"critical",
	"error",
	"warning",
	"notice",
	"info",
	"debug",
};

/*
 * Use one ratelimit state per log level so that a flood of less important
 * messages doesn't cause more important ones to be dropped.
 */
static struct ratelimit_state printk_limits[] = {
	RATELIMIT_STATE_INIT(printk_limits[0], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[1], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[2], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[3], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[4], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[5], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[6], DEFAULT_RATELIMIT_INTERVAL, 100),
	RATELIMIT_STATE_INIT(printk_limits[7], DEFAULT_RATELIMIT_INTERVAL, 100),
};

void __cold _btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
{
	char lvl[PRINTK_MAX_SINGLE_HEADER_LEN + 1] = "\0";
	struct va_format vaf;
	va_list args;
	int kern_level;
	const char *type = logtypes[4];
	struct ratelimit_state *ratelimit = &printk_limits[4];

#ifdef CONFIG_PRINTK_INDEX
	printk_index_subsys_emit("%sBTRFS %s (device %s): ", NULL, fmt);
#endif

	va_start(args, fmt);

	while ((kern_level = printk_get_level(fmt)) != 0) {
		size_t size = printk_skip_level(fmt) - fmt;

		if (kern_level >= '0' && kern_level <= '7') {
			memcpy(lvl, fmt,  size);
			lvl[size] = '\0';
			type = logtypes[kern_level - '0'];
			ratelimit = &printk_limits[kern_level - '0'];
		}
		fmt += size;
	}

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

	/* Do not ratelimit if CONFIG_BTRFS_DEBUG is enabled. */
	if (IS_ENABLED(CONFIG_BTRFS_DEBUG) || __ratelimit(ratelimit)) {
		if (fs_info) {
			char statestr[STATE_STRING_BUF_LEN];

			btrfs_state_to_string(fs_info, statestr);
			_printk("%sBTRFS %s (device %s%s): %pV\n", lvl, type,
				fs_info->sb->s_id, statestr, &vaf);
		} else {
			_printk("%sBTRFS %s: %pV\n", lvl, type, &vaf);
		}
	}

	va_end(args);
}
#endif

#if BITS_PER_LONG == 32
void __cold btrfs_warn_32bit_limit(struct btrfs_fs_info *fs_info)
{
	if (!test_and_set_bit(BTRFS_FS_32BIT_WARN, &fs_info->flags)) {
		btrfs_warn(fs_info, "reaching 32bit limit for logical addresses");
		btrfs_warn(fs_info,
"due to page cache limit on 32bit systems, btrfs can't access metadata at or beyond %lluT",
			   BTRFS_32BIT_MAX_FILE_SIZE >> 40);
		btrfs_warn(fs_info,
			   "please consider upgrading to 64bit kernel/hardware");
	}
}

void __cold btrfs_err_32bit_limit(struct btrfs_fs_info *fs_info)
{
	if (!test_and_set_bit(BTRFS_FS_32BIT_ERROR, &fs_info->flags)) {
		btrfs_err(fs_info, "reached 32bit limit for logical addresses");
		btrfs_err(fs_info,
"due to page cache limit on 32bit systems, metadata beyond %lluT can't be accessed",
			  BTRFS_32BIT_MAX_FILE_SIZE >> 40);
		btrfs_err(fs_info,
			   "please consider upgrading to 64bit kernel/hardware");
	}
}
#endif

/*
 * Decode unexpected, fatal errors from the caller, issue an alert, and either
 * panic or BUGs, depending on mount options.
 */
__cold
void __btrfs_panic(const struct btrfs_fs_info *fs_info, const char *function,
		   unsigned int line, int error, const char *fmt, ...)
{
	char *s_id = "<unknown>";
	const char *errstr;
	struct va_format vaf = { .fmt = fmt };
	va_list args;

	if (fs_info)
		s_id = fs_info->sb->s_id;

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

	errstr = btrfs_decode_error(error);
	if (fs_info && (btrfs_test_opt(fs_info, PANIC_ON_FATAL_ERROR)))
		panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
			s_id, function, line, &vaf, error, errstr);

	btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",
		   function, line, &vaf, error, errstr);
	va_end(args);
	/* Caller calls BUG() */
}
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0
	2
	3	#include "fs.h"
	4	#include "messages.h"
	5	#include "discard.h"
	6	#include "super.h"
	7
	8	#ifdef CONFIG_PRINTK
	9
	10	#define STATE_STRING_PREFACE " state "
	11	#define STATE_STRING_BUF_LEN (sizeof(STATE_STRING_PREFACE) + BTRFS_FS_STATE_COUNT + 1)
	12
	13	/*
	14	* Characters to print to indicate error conditions or uncommon filesystem state.
	15	* RO is not an error.
	16	*/
	17	static const char fs_state_chars[] = {
	18	[BTRFS_FS_STATE_REMOUNTING] = 'M',
	19	[BTRFS_FS_STATE_RO] = 0,
	20	[BTRFS_FS_STATE_TRANS_ABORTED] = 'A',
	21	[BTRFS_FS_STATE_DEV_REPLACING] = 'R',
	22	[BTRFS_FS_STATE_DUMMY_FS_INFO] = 0,
	23	[BTRFS_FS_STATE_NO_DATA_CSUMS] = 'C',
	24	[BTRFS_FS_STATE_SKIP_META_CSUMS] = 'S',
	25	[BTRFS_FS_STATE_LOG_CLEANUP_ERROR] = 'L',
	26	};
	27
	28	static void btrfs_state_to_string(const struct btrfs_fs_info info, char buf)
	29	{
	30	unsigned int bit;
	31	bool states_printed = false;
	32	unsigned long fs_state = READ_ONCE(info->fs_state);
	33	char *curr = buf;
	34
	35	memcpy(curr, STATE_STRING_PREFACE, sizeof(STATE_STRING_PREFACE));
	36	curr += sizeof(STATE_STRING_PREFACE) - 1;
	37
	38	if (BTRFS_FS_ERROR(info)) {
	39	*curr++ = 'E';
	40	states_printed = true;
	41	}
	42
	43	for_each_set_bit(bit, &fs_state, sizeof(fs_state)) {
	44	WARN_ON_ONCE(bit >= BTRFS_FS_STATE_COUNT);
	45	if ((bit < BTRFS_FS_STATE_COUNT) && fs_state_chars[bit]) {
	46	*curr++ = fs_state_chars[bit];
	47	states_printed = true;
	48	}
	49	}
	50
	51	/* If no states were printed, reset the buffer */
	52	if (!states_printed)
	53	curr = buf;
	54
	55	*curr++ = 0;
	56	}
	57	#endif
	58
	59	/*
	60	* Generally the error codes correspond to their respective errors, but there
	61	* are a few special cases.
	62	*
	63	* EUCLEAN: Any sort of corruption that we encounter. The tree-checker for
	64	* instance will return EUCLEAN if any of the blocks are corrupted in
	65	* a way that is problematic. We want to reserve EUCLEAN for these
	66	* sort of corruptions.
	67	*
	68	* EROFS: If we check BTRFS_FS_STATE_ERROR and fail out with a return error, we
	69	* need to use EROFS for this case. We will have no idea of the
	70	* original failure, that will have been reported at the time we tripped
	71	* over the error. Each subsequent error that doesn't have any context
	72	* of the original error should use EROFS when handling BTRFS_FS_STATE_ERROR.
	73	*/
	74	const char * __attribute_const__ btrfs_decode_error(int error)
	75	{
	76	char *errstr = "unknown";
	77
	78	switch (error) {
	79	case -ENOENT: /* -2 */
	80	errstr = "No such entry";
	81	break;
	82	case -EIO: /* -5 */
	83	errstr = "IO failure";
	84	break;
	85	case -ENOMEM: /* -12*/
	86	errstr = "Out of memory";
	87	break;
	88	case -EEXIST: /* -17 */
	89	errstr = "Object already exists";
	90	break;
	91	case -ENOSPC: /* -28 */
	92	errstr = "No space left";
	93	break;
	94	case -EROFS: /* -30 */
	95	errstr = "Readonly filesystem";
	96	break;
	97	case -EOPNOTSUPP: /* -95 */
	98	errstr = "Operation not supported";
	99	break;
	100	case -EUCLEAN: /* -117 */
	101	errstr = "Filesystem corrupted";
	102	break;
	103	case -EDQUOT: /* -122 */
	104	errstr = "Quota exceeded";
	105	break;
	106	}
	107
	108	return errstr;
	109	}
	110
	111	/*
	112	* Decodes expected errors from the caller and invokes the appropriate error
	113	* response.
	114	*/
	115	__cold
	116	void __btrfs_handle_fs_error(struct btrfs_fs_info fs_info, const char function,
	117	unsigned int line, int error, const char *fmt, ...)
	118	{
	119	struct super_block *sb = fs_info->sb;
	120	#ifdef CONFIG_PRINTK
	121	char statestr[STATE_STRING_BUF_LEN];
	122	const char *errstr;
	123	#endif
	124
	125	#ifdef CONFIG_PRINTK_INDEX
	126	printk_index_subsys_emit(
	127	"BTRFS: error (device %s%s) in %s:%d: errno=%d %s", KERN_CRIT, fmt);
	128	#endif
	129
	130	/*
	131	* Special case: if the error is EROFS, and we're already under
	132	* SB_RDONLY, then it is safe here.
	133	*/
	134	if (error == -EROFS && sb_rdonly(sb))
	135	return;
	136
	137	#ifdef CONFIG_PRINTK
	138	errstr = btrfs_decode_error(error);
	139	btrfs_state_to_string(fs_info, statestr);
	140	if (fmt) {
	141	struct va_format vaf;
	142	va_list args;
	143
	144	va_start(args, fmt);
	145	vaf.fmt = fmt;
	146	vaf.va = &args;
	147
	148	pr_crit("BTRFS: error (device %s%s) in %s:%d: errno=%d %s (%pV)\n",
	149	sb->s_id, statestr, function, line, error, errstr, &vaf);
	150	va_end(args);
	151	} else {
	152	pr_crit("BTRFS: error (device %s%s) in %s:%d: errno=%d %s\n",
	153	sb->s_id, statestr, function, line, error, errstr);
	154	}
	155	#endif
	156
	157	/*
	158	* Today we only save the error info to memory. Long term we'll also
	159	* send it down to the disk.
	160	*/
	161	WRITE_ONCE(fs_info->fs_error, error);
	162
	163	/* Don't go through full error handling during mount. */
	164	if (!(sb->s_flags & SB_BORN))
	165	return;
	166
	167	if (sb_rdonly(sb))
	168	return;
	169
	170	btrfs_discard_stop(fs_info);
	171
	172	/* Handle error by forcing the filesystem readonly. */
	173	btrfs_set_sb_rdonly(sb);
	174	btrfs_info(fs_info, "forced readonly");
	175	/*
	176	* Note that a running device replace operation is not canceled here
	177	* although there is no way to update the progress. It would add the
	178	* risk of a deadlock, therefore the canceling is omitted. The only
	179	* penalty is that some I/O remains active until the procedure
	180	* completes. The next time when the filesystem is mounted writable
	181	* again, the device replace operation continues.
	182	*/
	183	}
	184
	185	#ifdef CONFIG_PRINTK
	186	static const char * const logtypes[] = {
	187	"emergency",
	188	"alert",
	189	"critical",
	190	"error",
	191	"warning",
	192	"notice",
	193	"info",
	194	"debug",
	195	};
	196
	197	/*
	198	* Use one ratelimit state per log level so that a flood of less important
	199	* messages doesn't cause more important ones to be dropped.
	200	*/
	201	static struct ratelimit_state printk_limits[] = {
	202	RATELIMIT_STATE_INIT(printk_limits[0], DEFAULT_RATELIMIT_INTERVAL, 100),
	203	RATELIMIT_STATE_INIT(printk_limits[1], DEFAULT_RATELIMIT_INTERVAL, 100),
	204	RATELIMIT_STATE_INIT(printk_limits[2], DEFAULT_RATELIMIT_INTERVAL, 100),
	205	RATELIMIT_STATE_INIT(printk_limits[3], DEFAULT_RATELIMIT_INTERVAL, 100),
	206	RATELIMIT_STATE_INIT(printk_limits[4], DEFAULT_RATELIMIT_INTERVAL, 100),
	207	RATELIMIT_STATE_INIT(printk_limits[5], DEFAULT_RATELIMIT_INTERVAL, 100),
	208	RATELIMIT_STATE_INIT(printk_limits[6], DEFAULT_RATELIMIT_INTERVAL, 100),
	209	RATELIMIT_STATE_INIT(printk_limits[7], DEFAULT_RATELIMIT_INTERVAL, 100),
	210	};
	211
	212	void __cold _btrfs_printk(const struct btrfs_fs_info fs_info, const char fmt, ...)
	213	{
	214	char lvl[PRINTK_MAX_SINGLE_HEADER_LEN + 1] = "\0";
	215	struct va_format vaf;
	216	va_list args;
	217	int kern_level;
	218	const char *type = logtypes[4];
	219	struct ratelimit_state *ratelimit = &printk_limits[4];
	220
	221	#ifdef CONFIG_PRINTK_INDEX
	222	printk_index_subsys_emit("%sBTRFS %s (device %s): ", NULL, fmt);
	223	#endif
	224
	225	va_start(args, fmt);
	226
	227	while ((kern_level = printk_get_level(fmt)) != 0) {
	228	size_t size = printk_skip_level(fmt) - fmt;
	229
	230	if (kern_level >= '0' && kern_level <= '7') {
	231	memcpy(lvl, fmt, size);
	232	lvl[size] = '\0';
	233	type = logtypes[kern_level - '0'];
	234	ratelimit = &printk_limits[kern_level - '0'];
	235	}
	236	fmt += size;
	237	}
	238
	239	vaf.fmt = fmt;
	240	vaf.va = &args;
	241
	242	/* Do not ratelimit if CONFIG_BTRFS_DEBUG is enabled. */
	243	if (IS_ENABLED(CONFIG_BTRFS_DEBUG) \|\| __ratelimit(ratelimit)) {
	244	if (fs_info) {
	245	char statestr[STATE_STRING_BUF_LEN];
	246
	247	btrfs_state_to_string(fs_info, statestr);
	248	_printk("%sBTRFS %s (device %s%s): %pV\n", lvl, type,
	249	fs_info->sb->s_id, statestr, &vaf);
	250	} else {
	251	_printk("%sBTRFS %s: %pV\n", lvl, type, &vaf);
	252	}
	253	}
	254
	255	va_end(args);
	256	}
	257	#endif
	258
	259	#if BITS_PER_LONG == 32
	260	void __cold btrfs_warn_32bit_limit(struct btrfs_fs_info *fs_info)
	261	{
	262	if (!test_and_set_bit(BTRFS_FS_32BIT_WARN, &fs_info->flags)) {
	263	btrfs_warn(fs_info, "reaching 32bit limit for logical addresses");
	264	btrfs_warn(fs_info,
	265	"due to page cache limit on 32bit systems, btrfs can't access metadata at or beyond %lluT",
	266	BTRFS_32BIT_MAX_FILE_SIZE >> 40);
	267	btrfs_warn(fs_info,
	268	"please consider upgrading to 64bit kernel/hardware");
	269	}
	270	}
	271
	272	void __cold btrfs_err_32bit_limit(struct btrfs_fs_info *fs_info)
	273	{
	274	if (!test_and_set_bit(BTRFS_FS_32BIT_ERROR, &fs_info->flags)) {
	275	btrfs_err(fs_info, "reached 32bit limit for logical addresses");
	276	btrfs_err(fs_info,
	277	"due to page cache limit on 32bit systems, metadata beyond %lluT can't be accessed",
	278	BTRFS_32BIT_MAX_FILE_SIZE >> 40);
	279	btrfs_err(fs_info,
	280	"please consider upgrading to 64bit kernel/hardware");
	281	}
	282	}
	283	#endif
	284
	285	/*
	286	* Decode unexpected, fatal errors from the caller, issue an alert, and either
	287	* panic or BUGs, depending on mount options.
	288	*/
	289	__cold
	290	void __btrfs_panic(const struct btrfs_fs_info fs_info, const char function,
	291	unsigned int line, int error, const char *fmt, ...)
	292	{
	293	char *s_id = "<unknown>";
	294	const char *errstr;
	295	struct va_format vaf = { .fmt = fmt };
	296	va_list args;
	297
	298	if (fs_info)
	299	s_id = fs_info->sb->s_id;
	300
	301	va_start(args, fmt);
	302	vaf.va = &args;
	303
	304	errstr = btrfs_decode_error(error);
	305	if (fs_info && (btrfs_test_opt(fs_info, PANIC_ON_FATAL_ERROR)))
	306	panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
	307	s_id, function, line, &vaf, error, errstr);
	308
	309	btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",
	310	function, line, &vaf, error, errstr);
	311	va_end(args);
	312	/* Caller calls BUG() */
	313	}