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