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(fs_info, 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(fmt)) != 0) { 227 size_t size = printk_skip_level(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(fs_info, statestr); 246 _printk("%sBTRFS %s (device %s%s): %pV\n", lvl, type, 247 fs_info->sb->s_id, statestr, &vaf); 248 } else { 249 _printk("%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