fs/btrfs/messages.c

   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  */
  19 static 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
  30 static 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  */
  71 const 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
 113 void __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
 183 static 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  */
 198 static 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
 209 void __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
 256 void __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
 263 void __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
 270 void __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
 282 void __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
 309 void __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
 330 void __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 }