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 | */ |
17 | static 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 | |
27 | static 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 | */ |
73 | const 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 |
115 | void __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(info: fs_info, buf: 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 |
185 | static 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 | */ |
200 | static 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 | |
211 | void __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(buffer: fmt)) != 0) { |
227 | size_t size = printk_skip_level(buffer: 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(info: fs_info, buf: statestr); |
246 | _printk(fmt: "%sBTRFS %s (device %s%s): %pV\n" , lvl, type, |
247 | fs_info->sb->s_id, statestr, &vaf); |
248 | } else { |
249 | _printk(fmt: "%sBTRFS %s: %pV\n" , lvl, type, &vaf); |
250 | } |
251 | } |
252 | |
253 | va_end(args); |
254 | } |
255 | #endif |
256 | |
257 | #if BITS_PER_LONG == 32 |
258 | void __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 | |
270 | void __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 |
288 | void __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 | |