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 + 1)
  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_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
  39         if (BTRFS_FS_ERROR(info)) {
  40                 *curr++ = 'E';
  41                 states_printed = true;
  42         }
  43
  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          */
 162         WRITE_ONCE(fs_info->fs_error, errno);
 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
 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
 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 }