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

// SPDX-License-Identifier: GPL-2.0

#include "fs.h"
#include "messages.h"
#include "discard.h"
#include "transaction.h"
#include "space-info.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)

/*
 * 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_ERROR]			= 'E',
	[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_CSUMS]		= 'C',
	[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;

	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 errno)
{
	char *errstr = "unknown";

	switch (errno) {
	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;
}

/*
 * __btrfs_handle_fs_error 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 errno, 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 (errno == -EROFS && sb_rdonly(sb))
		return;

#ifdef CONFIG_PRINTK
	errstr = btrfs_decode_error(errno);
	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, errno, 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, errno, errstr);
	}
#endif

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

	/* 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;

	if (__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

#ifdef CONFIG_BTRFS_ASSERT
void __cold btrfs_assertfail(const char *expr, const char *file, int line)
{
	pr_err("assertion failed: %s, in %s:%d\n", expr, file, line);
	BUG();
}
#endif

void __cold btrfs_print_v0_err(struct btrfs_fs_info *fs_info)
{
	btrfs_err(fs_info,
"Unsupported V0 extent filesystem detected. Aborting. Please re-create your filesystem with a newer kernel");
}

#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

/*
 * __btrfs_panic decodes unexpected, fatal errors from the caller, issues an
 * alert, and either panics or BUGs, depending on mount options.
 */
__cold
void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
		   unsigned int line, int errno, 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(errno);
	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, errno, errstr);

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