]> Git Repo - J-linux.git/blob - fs/btrfs/messages.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / 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_DATA_CSUMS]          = 'C',
24         [BTRFS_FS_STATE_SKIP_META_CSUMS]        = 'S',
25         [BTRFS_FS_STATE_LOG_CLEANUP_ERROR]      = 'L',
26 };
27
28 static void btrfs_state_to_string(const struct btrfs_fs_info *info, char *buf)
29 {
30         unsigned int bit;
31         bool states_printed = false;
32         unsigned long fs_state = READ_ONCE(info->fs_state);
33         char *curr = buf;
34
35         memcpy(curr, STATE_STRING_PREFACE, sizeof(STATE_STRING_PREFACE));
36         curr += sizeof(STATE_STRING_PREFACE) - 1;
37
38         if (BTRFS_FS_ERROR(info)) {
39                 *curr++ = 'E';
40                 states_printed = true;
41         }
42
43         for_each_set_bit(bit, &fs_state, sizeof(fs_state)) {
44                 WARN_ON_ONCE(bit >= BTRFS_FS_STATE_COUNT);
45                 if ((bit < BTRFS_FS_STATE_COUNT) && fs_state_chars[bit]) {
46                         *curr++ = fs_state_chars[bit];
47                         states_printed = true;
48                 }
49         }
50
51         /* If no states were printed, reset the buffer */
52         if (!states_printed)
53                 curr = buf;
54
55         *curr++ = 0;
56 }
57 #endif
58
59 /*
60  * Generally the error codes correspond to their respective errors, but there
61  * are a few special cases.
62  *
63  * EUCLEAN: Any sort of corruption that we encounter.  The tree-checker for
64  *          instance will return EUCLEAN if any of the blocks are corrupted in
65  *          a way that is problematic.  We want to reserve EUCLEAN for these
66  *          sort of corruptions.
67  *
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 will have no idea of the
70  *        original failure, that will have been reported at the time we tripped
71  *        over the error.  Each subsequent error that doesn't have any context
72  *        of the original error should use EROFS when handling BTRFS_FS_STATE_ERROR.
73  */
74 const char * __attribute_const__ btrfs_decode_error(int error)
75 {
76         char *errstr = "unknown";
77
78         switch (error) {
79         case -ENOENT:           /* -2 */
80                 errstr = "No such entry";
81                 break;
82         case -EIO:              /* -5 */
83                 errstr = "IO failure";
84                 break;
85         case -ENOMEM:           /* -12*/
86                 errstr = "Out of memory";
87                 break;
88         case -EEXIST:           /* -17 */
89                 errstr = "Object already exists";
90                 break;
91         case -ENOSPC:           /* -28 */
92                 errstr = "No space left";
93                 break;
94         case -EROFS:            /* -30 */
95                 errstr = "Readonly filesystem";
96                 break;
97         case -EOPNOTSUPP:       /* -95 */
98                 errstr = "Operation not supported";
99                 break;
100         case -EUCLEAN:          /* -117 */
101                 errstr = "Filesystem corrupted";
102                 break;
103         case -EDQUOT:           /* -122 */
104                 errstr = "Quota exceeded";
105                 break;
106         }
107
108         return errstr;
109 }
110
111 /*
112  * Decodes expected errors from the caller and invokes the appropriate error
113  * response.
114  */
115 __cold
116 void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
117                        unsigned int line, int error, const char *fmt, ...)
118 {
119         struct super_block *sb = fs_info->sb;
120 #ifdef CONFIG_PRINTK
121         char statestr[STATE_STRING_BUF_LEN];
122         const char *errstr;
123 #endif
124
125 #ifdef CONFIG_PRINTK_INDEX
126         printk_index_subsys_emit(
127                 "BTRFS: error (device %s%s) in %s:%d: errno=%d %s", KERN_CRIT, fmt);
128 #endif
129
130         /*
131          * Special case: if the error is EROFS, and we're already under
132          * SB_RDONLY, then it is safe here.
133          */
134         if (error == -EROFS && sb_rdonly(sb))
135                 return;
136
137 #ifdef CONFIG_PRINTK
138         errstr = btrfs_decode_error(error);
139         btrfs_state_to_string(fs_info, statestr);
140         if (fmt) {
141                 struct va_format vaf;
142                 va_list args;
143
144                 va_start(args, fmt);
145                 vaf.fmt = fmt;
146                 vaf.va = &args;
147
148                 pr_crit("BTRFS: error (device %s%s) in %s:%d: errno=%d %s (%pV)\n",
149                         sb->s_id, statestr, function, line, error, errstr, &vaf);
150                 va_end(args);
151         } else {
152                 pr_crit("BTRFS: error (device %s%s) in %s:%d: errno=%d %s\n",
153                         sb->s_id, statestr, function, line, error, errstr);
154         }
155 #endif
156
157         /*
158          * Today we only save the error info to memory.  Long term we'll also
159          * send it down to the disk.
160          */
161         WRITE_ONCE(fs_info->fs_error, error);
162
163         /* Don't go through full error handling during mount. */
164         if (!(sb->s_flags & SB_BORN))
165                 return;
166
167         if (sb_rdonly(sb))
168                 return;
169
170         btrfs_discard_stop(fs_info);
171
172         /* Handle error by forcing the filesystem readonly. */
173         btrfs_set_sb_rdonly(sb);
174         btrfs_info(fs_info, "forced readonly");
175         /*
176          * Note that a running device replace operation is not canceled here
177          * although there is no way to update the progress. It would add the
178          * risk of a deadlock, therefore the canceling is omitted. The only
179          * penalty is that some I/O remains active until the procedure
180          * completes. The next time when the filesystem is mounted writable
181          * again, the device replace operation continues.
182          */
183 }
184
185 #ifdef CONFIG_PRINTK
186 static const char * const logtypes[] = {
187         "emergency",
188         "alert",
189         "critical",
190         "error",
191         "warning",
192         "notice",
193         "info",
194         "debug",
195 };
196
197 /*
198  * Use one ratelimit state per log level so that a flood of less important
199  * messages doesn't cause more important ones to be dropped.
200  */
201 static struct ratelimit_state printk_limits[] = {
202         RATELIMIT_STATE_INIT(printk_limits[0], DEFAULT_RATELIMIT_INTERVAL, 100),
203         RATELIMIT_STATE_INIT(printk_limits[1], DEFAULT_RATELIMIT_INTERVAL, 100),
204         RATELIMIT_STATE_INIT(printk_limits[2], DEFAULT_RATELIMIT_INTERVAL, 100),
205         RATELIMIT_STATE_INIT(printk_limits[3], DEFAULT_RATELIMIT_INTERVAL, 100),
206         RATELIMIT_STATE_INIT(printk_limits[4], DEFAULT_RATELIMIT_INTERVAL, 100),
207         RATELIMIT_STATE_INIT(printk_limits[5], DEFAULT_RATELIMIT_INTERVAL, 100),
208         RATELIMIT_STATE_INIT(printk_limits[6], DEFAULT_RATELIMIT_INTERVAL, 100),
209         RATELIMIT_STATE_INIT(printk_limits[7], DEFAULT_RATELIMIT_INTERVAL, 100),
210 };
211
212 void __cold _btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
213 {
214         char lvl[PRINTK_MAX_SINGLE_HEADER_LEN + 1] = "\0";
215         struct va_format vaf;
216         va_list args;
217         int kern_level;
218         const char *type = logtypes[4];
219         struct ratelimit_state *ratelimit = &printk_limits[4];
220
221 #ifdef CONFIG_PRINTK_INDEX
222         printk_index_subsys_emit("%sBTRFS %s (device %s): ", NULL, fmt);
223 #endif
224
225         va_start(args, fmt);
226
227         while ((kern_level = printk_get_level(fmt)) != 0) {
228                 size_t size = printk_skip_level(fmt) - fmt;
229
230                 if (kern_level >= '0' && kern_level <= '7') {
231                         memcpy(lvl, fmt,  size);
232                         lvl[size] = '\0';
233                         type = logtypes[kern_level - '0'];
234                         ratelimit = &printk_limits[kern_level - '0'];
235                 }
236                 fmt += size;
237         }
238
239         vaf.fmt = fmt;
240         vaf.va = &args;
241
242         /* Do not ratelimit if CONFIG_BTRFS_DEBUG is enabled. */
243         if (IS_ENABLED(CONFIG_BTRFS_DEBUG) || __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  * Decode unexpected, fatal errors from the caller, issue an alert, and either
287  * panic or BUGs, depending on mount options.
288  */
289 __cold
290 void __btrfs_panic(const struct btrfs_fs_info *fs_info, const char *function,
291                    unsigned int line, int error, 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(error);
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, error, errstr);
308
309         btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",
310                    function, line, &vaf, error, errstr);
311         va_end(args);
312         /* Caller calls BUG() */
313 }
This page took 0.043886 seconds and 4 git commands to generate.