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