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 "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 }