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