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 " | |
ae3364e5 | 13 | #define STATE_STRING_BUF_LEN (sizeof(STATE_STRING_PREFACE) + BTRFS_FS_STATE_COUNT + 1) |
083bd7e5 JB |
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[] = { | |
083bd7e5 JB |
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 | ||
29 | static 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 | ||
ae3364e5 FM |
39 | if (BTRFS_FS_ERROR(info)) { |
40 | *curr++ = 'E'; | |
41 | states_printed = true; | |
42 | } | |
43 | ||
083bd7e5 JB |
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 | */ | |
75 | const char * __attribute_const__ btrfs_decode_error(int errno) | |
76 | { | |
77 | char *errstr = "unknown"; | |
78 | ||
79 | switch (errno) { | |
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 | * __btrfs_handle_fs_error decodes expected errors from the caller and | |
114 | * invokes the appropriate error response. | |
115 | */ | |
116 | __cold | |
117 | void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function, | |
118 | unsigned int line, int errno, 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 (errno == -EROFS && sb_rdonly(sb)) | |
136 | return; | |
137 | ||
138 | #ifdef CONFIG_PRINTK | |
139 | errstr = btrfs_decode_error(errno); | |
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, errno, 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, errno, 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 | */ | |
ae3364e5 | 162 | WRITE_ONCE(fs_info->fs_error, errno); |
083bd7e5 JB |
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 | |
187 | static 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 | */ | |
202 | static 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 | ||
213 | void __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 | ||
083bd7e5 JB |
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 | ||
083bd7e5 JB |
285 | /* |
286 | * __btrfs_panic decodes unexpected, fatal errors from the caller, issues an | |
287 | * alert, and either panics or BUGs, depending on mount options. | |
288 | */ | |
289 | __cold | |
290 | void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function, | |
291 | unsigned int line, int errno, 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(errno); | |
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, errno, errstr); | |
308 | ||
309 | btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)", | |
310 | function, line, &vaf, errno, errstr); | |
311 | va_end(args); | |
312 | /* Caller calls BUG() */ | |
313 | } |