Loading...
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}
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)
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_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
30static 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 */
71const 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
113void __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
183static 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 */
198static 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
209void __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
256void __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
263void __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
270void __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
282void __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
295/*
296 * We only mark the transaction aborted and then set the file system read-only.
297 * This will prevent new transactions from starting or trying to join this
298 * one.
299 *
300 * This means that error recovery at the call site is limited to freeing
301 * any local memory allocations and passing the error code up without
302 * further cleanup. The transaction should complete as it normally would
303 * in the call path but will return -EIO.
304 *
305 * We'll complete the cleanup in btrfs_end_transaction and
306 * btrfs_commit_transaction.
307 */
308__cold
309void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
310 const char *function,
311 unsigned int line, int errno, bool first_hit)
312{
313 struct btrfs_fs_info *fs_info = trans->fs_info;
314
315 WRITE_ONCE(trans->aborted, errno);
316 WRITE_ONCE(trans->transaction->aborted, errno);
317 if (first_hit && errno == -ENOSPC)
318 btrfs_dump_space_info_for_trans_abort(fs_info);
319 /* Wake up anybody who may be waiting on this transaction */
320 wake_up(&fs_info->transaction_wait);
321 wake_up(&fs_info->transaction_blocked_wait);
322 __btrfs_handle_fs_error(fs_info, function, line, errno, NULL);
323}
324
325/*
326 * __btrfs_panic decodes unexpected, fatal errors from the caller, issues an
327 * alert, and either panics or BUGs, depending on mount options.
328 */
329__cold
330void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
331 unsigned int line, int errno, const char *fmt, ...)
332{
333 char *s_id = "<unknown>";
334 const char *errstr;
335 struct va_format vaf = { .fmt = fmt };
336 va_list args;
337
338 if (fs_info)
339 s_id = fs_info->sb->s_id;
340
341 va_start(args, fmt);
342 vaf.va = &args;
343
344 errstr = btrfs_decode_error(errno);
345 if (fs_info && (btrfs_test_opt(fs_info, PANIC_ON_FATAL_ERROR)))
346 panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
347 s_id, function, line, &vaf, errno, errstr);
348
349 btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",
350 function, line, &vaf, errno, errstr);
351 va_end(args);
352 /* Caller calls BUG() */
353}