mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/kdave/btrfs-progs.git
synced 2024-11-27 06:04:30 +08:00
btrfs-progs: sync messages.[ch] from the kernel
These are the printk helpers from the kernel. There were a few modifications, the hi-lights are - We do not have fs_info::fs_state, so that needed to be removed. - We do not have discard.h sync'ed yet, so that dependency was dropped. - Anything related to struct super_block was commented out. - The transaction abort had to be modified to fit with the current btrfs-progs code. - Added a btrfs_no_printk() helper to common/messages.* so that the print statements still worked. - The 32bit limit checkers are not needed so are behind __KERNEL__ Additionally there were kerncompat.h changes that needed to be made to handle the dependencies properly. Those are easier to spot. Any function that needed to be modified has a MODIFIED tag in the comment section with a list of things that were changed. Signed-off-by: Josef Bacik <josef@toxicpanda.com> Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
Josef Bacik
David Sterba
parent
89697b69f7
commit
228aa34f10
1
Makefile
1
Makefile
@ -179,6 +179,7 @@ objects = \
|
||||
kernel-shared/free-space-tree.o \
|
||||
kernel-shared/inode-item.o \
|
||||
kernel-shared/inode.o \
|
||||
kernel-shared/messages.o \
|
||||
kernel-shared/print-tree.o \
|
||||
kernel-shared/root-tree.o \
|
||||
kernel-shared/transaction.o \
|
||||
|
||||
@ -35,6 +35,17 @@ void __btrfs_printf(const char *fmt, ...)
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
__attribute__ ((format (printf, 2, 3)))
|
||||
void btrfs_no_printk(const void *fs_info, const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
vfprintf(stderr, fmt, args);
|
||||
va_end(args);
|
||||
fputc('\n', stderr);
|
||||
}
|
||||
|
||||
static bool should_print(int level)
|
||||
{
|
||||
if (bconf.verbose == BTRFS_BCONF_QUIET || level == BTRFS_BCONF_QUIET)
|
||||
|
||||
@ -41,6 +41,21 @@
|
||||
#endif
|
||||
|
||||
#ifndef BTRFS_DISABLE_BACKTRACE
|
||||
static inline void assert_trace(const char *assertion, const char *filename,
|
||||
const char *func, unsigned line, long val)
|
||||
{
|
||||
if (val)
|
||||
return;
|
||||
fprintf(stderr,
|
||||
"%s:%d: %s: Assertion `%s` failed, value %ld\n",
|
||||
filename, line, func, assertion, val);
|
||||
#ifndef BTRFS_DISABLE_BACKTRACE
|
||||
print_trace();
|
||||
#endif
|
||||
abort();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
#define UASSERT(c) assert_trace(#c, __FILE__, __func__, __LINE__, (long)(c))
|
||||
#else
|
||||
#define UASSERT(c) assert(c)
|
||||
@ -118,6 +133,9 @@
|
||||
__attribute__ ((format (printf, 1, 2)))
|
||||
void __btrfs_printf(const char *fmt, ...);
|
||||
|
||||
__attribute__ ((format (printf, 2, 3)))
|
||||
void btrfs_no_printk(const void *fs_info, const char *fmt, ...);
|
||||
|
||||
/*
|
||||
* Level of messages that must be printed by default (in case the verbosity
|
||||
* options haven't been set by the user) due to backward compatibility reasons
|
||||
|
||||
@ -36,6 +36,7 @@
|
||||
#include <linux/const.h>
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdarg.h>
|
||||
#include <features.h>
|
||||
|
||||
/*
|
||||
@ -320,6 +321,12 @@ static inline int IS_ERR_OR_NULL(const void *ptr)
|
||||
#define printk(fmt, args...) fprintf(stderr, fmt, ##args)
|
||||
#define KERN_CRIT ""
|
||||
#define KERN_ERR ""
|
||||
#define KERN_EMERG ""
|
||||
#define KERN_ALERT ""
|
||||
#define KERN_CRIT ""
|
||||
#define KERN_NOTICE ""
|
||||
#define KERN_INFO ""
|
||||
#define KERN_WARNING ""
|
||||
|
||||
/*
|
||||
* kmalloc/kfree
|
||||
@ -335,26 +342,6 @@ static inline int IS_ERR_OR_NULL(const void *ptr)
|
||||
#define memalloc_nofs_save() (0)
|
||||
#define memalloc_nofs_restore(x) ((void)(x))
|
||||
|
||||
#ifndef BTRFS_DISABLE_BACKTRACE
|
||||
static inline void assert_trace(const char *assertion, const char *filename,
|
||||
const char *func, unsigned line, long val)
|
||||
{
|
||||
if (val)
|
||||
return;
|
||||
fprintf(stderr,
|
||||
"%s:%d: %s: Assertion `%s` failed, value %ld\n",
|
||||
filename, line, func, assertion, val);
|
||||
#ifndef BTRFS_DISABLE_BACKTRACE
|
||||
print_trace();
|
||||
#endif
|
||||
abort();
|
||||
exit(1);
|
||||
}
|
||||
#define ASSERT(c) assert_trace(#c, __FILE__, __func__, __LINE__, (long)(c))
|
||||
#else
|
||||
#define ASSERT(c) assert(c)
|
||||
#endif
|
||||
|
||||
#define BUG_ON(c) bugon_trace(#c, __FILE__, __func__, __LINE__, (long)(c))
|
||||
#define BUG() \
|
||||
do { \
|
||||
@ -574,8 +561,24 @@ struct work_struct {
|
||||
typedef struct wait_queue_head_s {
|
||||
} wait_queue_head_t;
|
||||
|
||||
struct super_block {
|
||||
char *s_id;
|
||||
};
|
||||
|
||||
struct va_format {
|
||||
const char *fmt;
|
||||
va_list *va;
|
||||
};
|
||||
|
||||
#define __init
|
||||
#define __cold
|
||||
#define __user
|
||||
|
||||
#define __printf(a, b) __attribute__((__format__(printf, a, b)))
|
||||
|
||||
static inline bool sb_rdonly(struct super_block *sb)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -22,6 +22,7 @@
|
||||
#include "kernel-shared/backref.h"
|
||||
#include "kernel-shared/ulist.h"
|
||||
#include "kernel-shared/transaction.h"
|
||||
#include "kernel-shared/messages.h"
|
||||
#include "common/internal.h"
|
||||
|
||||
#define pr_debug(...) do { } while (0)
|
||||
|
||||
@ -377,6 +377,8 @@ struct btrfs_fs_info {
|
||||
u64 zone_size;
|
||||
u64 zoned;
|
||||
};
|
||||
|
||||
struct super_block *sb;
|
||||
};
|
||||
|
||||
static inline bool btrfs_is_zoned(const struct btrfs_fs_info *fs_info)
|
||||
|
||||
@ -20,6 +20,7 @@
|
||||
#include "kernel-shared/ctree.h"
|
||||
#include "kernel-shared/delayed-ref.h"
|
||||
#include "kernel-shared/transaction.h"
|
||||
#include "kernel-shared/messages.h"
|
||||
|
||||
/*
|
||||
* delayed back reference update tracking. For subvolume trees
|
||||
|
||||
@ -31,6 +31,7 @@
|
||||
#include "kernel-shared/ctree.h"
|
||||
#include "kernel-shared/volumes.h"
|
||||
#include "kernel-shared/disk-io.h"
|
||||
#include "kernel-shared/messages.h"
|
||||
#include "common/utils.h"
|
||||
#include "common/device-utils.h"
|
||||
#include "common/internal.h"
|
||||
|
||||
@ -22,6 +22,7 @@
|
||||
#include "kernel-shared/free-space-tree.h"
|
||||
#include "kernel-shared/volumes.h"
|
||||
#include "kernel-shared/transaction.h"
|
||||
#include "kernel-shared/messages.h"
|
||||
#include "kernel-lib/bitops.h"
|
||||
#include "common/internal.h"
|
||||
|
||||
|
||||
336
kernel-shared/messages.c
Normal file
336
kernel-shared/messages.c
Normal file
@ -0,0 +1,336 @@
|
||||
// SPDX-License-Identifier: GPL-2.0
|
||||
|
||||
#include "kerncompat.h"
|
||||
#include "kernel-lib/bitops.h"
|
||||
#include "kernel-shared/ctree.h"
|
||||
#include "kernel-shared/messages.h"
|
||||
#include "kernel-shared/transaction.h"
|
||||
|
||||
#ifdef CONFIG_PRINTK
|
||||
|
||||
#define STATE_STRING_PREFACE ": state "
|
||||
#define STATE_STRING_BUF_LEN (sizeof(STATE_STRING_PREFACE) + BTRFS_FS_STATE_COUNT)
|
||||
|
||||
/*
|
||||
* Characters to print to indicate error conditions or uncommon filesystem state.
|
||||
* RO is not an error.
|
||||
*/
|
||||
static const char fs_state_chars[] = {
|
||||
[BTRFS_FS_STATE_ERROR] = 'E',
|
||||
[BTRFS_FS_STATE_REMOUNTING] = 'M',
|
||||
[BTRFS_FS_STATE_RO] = 0,
|
||||
[BTRFS_FS_STATE_TRANS_ABORTED] = 'A',
|
||||
[BTRFS_FS_STATE_DEV_REPLACING] = 'R',
|
||||
[BTRFS_FS_STATE_DUMMY_FS_INFO] = 0,
|
||||
[BTRFS_FS_STATE_NO_CSUMS] = 'C',
|
||||
[BTRFS_FS_STATE_LOG_CLEANUP_ERROR] = 'L',
|
||||
};
|
||||
|
||||
static void btrfs_state_to_string(const struct btrfs_fs_info *info, char *buf)
|
||||
{
|
||||
unsigned int bit;
|
||||
bool states_printed = false;
|
||||
unsigned long fs_state = READ_ONCE(info->fs_state);
|
||||
char *curr = buf;
|
||||
|
||||
memcpy(curr, STATE_STRING_PREFACE, sizeof(STATE_STRING_PREFACE));
|
||||
curr += sizeof(STATE_STRING_PREFACE) - 1;
|
||||
|
||||
for_each_set_bit(bit, &fs_state, sizeof(fs_state)) {
|
||||
WARN_ON_ONCE(bit >= BTRFS_FS_STATE_COUNT);
|
||||
if ((bit < BTRFS_FS_STATE_COUNT) && fs_state_chars[bit]) {
|
||||
*curr++ = fs_state_chars[bit];
|
||||
states_printed = true;
|
||||
}
|
||||
}
|
||||
|
||||
/* If no states were printed, reset the buffer */
|
||||
if (!states_printed)
|
||||
curr = buf;
|
||||
|
||||
*curr++ = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Generally the error codes correspond to their respective errors, but there
|
||||
* are a few special cases.
|
||||
*
|
||||
* EUCLEAN: Any sort of corruption that we encounter. The tree-checker for
|
||||
* instance will return EUCLEAN if any of the blocks are corrupted in
|
||||
* a way that is problematic. We want to reserve EUCLEAN for these
|
||||
* sort of corruptions.
|
||||
*
|
||||
* EROFS: If we check BTRFS_FS_STATE_ERROR and fail out with a return error, we
|
||||
* need to use EROFS for this case. We will have no idea of the
|
||||
* original failure, that will have been reported at the time we tripped
|
||||
* over the error. Each subsequent error that doesn't have any context
|
||||
* of the original error should use EROFS when handling BTRFS_FS_STATE_ERROR.
|
||||
*/
|
||||
const char * __attribute_const__ btrfs_decode_error(int error)
|
||||
{
|
||||
char *errstr = "unknown";
|
||||
|
||||
switch (error) {
|
||||
case -ENOENT: /* -2 */
|
||||
errstr = "No such entry";
|
||||
break;
|
||||
case -EIO: /* -5 */
|
||||
errstr = "IO failure";
|
||||
break;
|
||||
case -ENOMEM: /* -12*/
|
||||
errstr = "Out of memory";
|
||||
break;
|
||||
case -EEXIST: /* -17 */
|
||||
errstr = "Object already exists";
|
||||
break;
|
||||
case -ENOSPC: /* -28 */
|
||||
errstr = "No space left";
|
||||
break;
|
||||
case -EROFS: /* -30 */
|
||||
errstr = "Readonly filesystem";
|
||||
break;
|
||||
case -EOPNOTSUPP: /* -95 */
|
||||
errstr = "Operation not supported";
|
||||
break;
|
||||
case -EUCLEAN: /* -117 */
|
||||
errstr = "Filesystem corrupted";
|
||||
break;
|
||||
case -EDQUOT: /* -122 */
|
||||
errstr = "Quota exceeded";
|
||||
break;
|
||||
}
|
||||
|
||||
return errstr;
|
||||
}
|
||||
|
||||
/*
|
||||
* __btrfs_handle_fs_error decodes expected errors from the caller and
|
||||
* invokes the appropriate error response.
|
||||
*/
|
||||
__cold
|
||||
void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
|
||||
unsigned int line, int error, const char *fmt, ...)
|
||||
{
|
||||
struct super_block *sb = fs_info->sb;
|
||||
#ifdef CONFIG_PRINTK
|
||||
char statestr[STATE_STRING_BUF_LEN];
|
||||
const char *errstr;
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_PRINTK_INDEX
|
||||
printk_index_subsys_emit(
|
||||
"BTRFS: error (device %s%s) in %s:%d: error=%d %s", KERN_CRIT, fmt);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Special case: if the error is EROFS, and we're already under
|
||||
* SB_RDONLY, then it is safe here.
|
||||
*/
|
||||
if (error == -EROFS && sb_rdonly(sb))
|
||||
return;
|
||||
|
||||
#ifdef CONFIG_PRINTK
|
||||
errstr = btrfs_decode_error(error);
|
||||
btrfs_state_to_string(fs_info, statestr);
|
||||
if (fmt) {
|
||||
struct va_format vaf;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
vaf.fmt = fmt;
|
||||
vaf.va = &args;
|
||||
|
||||
pr_crit("BTRFS: error (device %s%s) in %s:%d: error=%d %s (%pV)\n",
|
||||
sb->s_id, statestr, function, line, error, errstr, &vaf);
|
||||
va_end(args);
|
||||
} else {
|
||||
pr_crit("BTRFS: error (device %s%s) in %s:%d: error=%d %s\n",
|
||||
sb->s_id, statestr, function, line, error, errstr);
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* We don't have fs_info::fs_state yet, and the rest of this is more
|
||||
* kernel related cleanup, so for now comment it out.
|
||||
*/
|
||||
#if 0
|
||||
/*
|
||||
* Today we only save the error info to memory. Long term we'll also
|
||||
* send it down to the disk.
|
||||
*/
|
||||
set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
|
||||
|
||||
/* Don't go through full error handling during mount. */
|
||||
if (!(sb->s_flags & SB_BORN))
|
||||
return;
|
||||
|
||||
if (sb_rdonly(sb))
|
||||
return;
|
||||
|
||||
btrfs_discard_stop(fs_info);
|
||||
|
||||
/* Handle error by forcing the filesystem readonly. */
|
||||
btrfs_set_sb_rdonly(sb);
|
||||
#endif
|
||||
|
||||
btrfs_info(fs_info, "forced readonly");
|
||||
/*
|
||||
* Note that a running device replace operation is not canceled here
|
||||
* although there is no way to update the progress. It would add the
|
||||
* risk of a deadlock, therefore the canceling is omitted. The only
|
||||
* penalty is that some I/O remains active until the procedure
|
||||
* completes. The next time when the filesystem is mounted writable
|
||||
* again, the device replace operation continues.
|
||||
*/
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PRINTK
|
||||
static const char * const logtypes[] = {
|
||||
"emergency",
|
||||
"alert",
|
||||
"critical",
|
||||
"error",
|
||||
"warning",
|
||||
"notice",
|
||||
"info",
|
||||
"debug",
|
||||
};
|
||||
|
||||
/*
|
||||
* Use one ratelimit state per log level so that a flood of less important
|
||||
* messages doesn't cause more important ones to be dropped.
|
||||
*/
|
||||
static struct ratelimit_state printk_limits[] = {
|
||||
RATELIMIT_STATE_INIT(printk_limits[0], DEFAULT_RATELIMIT_INTERVAL, 100),
|
||||
RATELIMIT_STATE_INIT(printk_limits[1], DEFAULT_RATELIMIT_INTERVAL, 100),
|
||||
RATELIMIT_STATE_INIT(printk_limits[2], DEFAULT_RATELIMIT_INTERVAL, 100),
|
||||
RATELIMIT_STATE_INIT(printk_limits[3], DEFAULT_RATELIMIT_INTERVAL, 100),
|
||||
RATELIMIT_STATE_INIT(printk_limits[4], DEFAULT_RATELIMIT_INTERVAL, 100),
|
||||
RATELIMIT_STATE_INIT(printk_limits[5], DEFAULT_RATELIMIT_INTERVAL, 100),
|
||||
RATELIMIT_STATE_INIT(printk_limits[6], DEFAULT_RATELIMIT_INTERVAL, 100),
|
||||
RATELIMIT_STATE_INIT(printk_limits[7], DEFAULT_RATELIMIT_INTERVAL, 100),
|
||||
};
|
||||
|
||||
void __cold _btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
|
||||
{
|
||||
char lvl[PRINTK_MAX_SINGLE_HEADER_LEN + 1] = "\0";
|
||||
struct va_format vaf;
|
||||
va_list args;
|
||||
int kern_level;
|
||||
const char *type = logtypes[4];
|
||||
struct ratelimit_state *ratelimit = &printk_limits[4];
|
||||
|
||||
#ifdef CONFIG_PRINTK_INDEX
|
||||
printk_index_subsys_emit("%sBTRFS %s (device %s): ", NULL, fmt);
|
||||
#endif
|
||||
|
||||
va_start(args, fmt);
|
||||
|
||||
while ((kern_level = printk_get_level(fmt)) != 0) {
|
||||
size_t size = printk_skip_level(fmt) - fmt;
|
||||
|
||||
if (kern_level >= '0' && kern_level <= '7') {
|
||||
memcpy(lvl, fmt, size);
|
||||
lvl[size] = '\0';
|
||||
type = logtypes[kern_level - '0'];
|
||||
ratelimit = &printk_limits[kern_level - '0'];
|
||||
}
|
||||
fmt += size;
|
||||
}
|
||||
|
||||
vaf.fmt = fmt;
|
||||
vaf.va = &args;
|
||||
|
||||
if (__ratelimit(ratelimit)) {
|
||||
if (fs_info) {
|
||||
char statestr[STATE_STRING_BUF_LEN];
|
||||
|
||||
btrfs_state_to_string(fs_info, statestr);
|
||||
_printk("%sBTRFS %s (device %s%s): %pV\n", lvl, type,
|
||||
fs_info->sb->s_id, statestr, &vaf);
|
||||
} else {
|
||||
_printk("%sBTRFS %s: %pV\n", lvl, type, &vaf);
|
||||
}
|
||||
}
|
||||
|
||||
va_end(args);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_BTRFS_ASSERT
|
||||
void __cold btrfs_assertfail(const char *expr, const char *file, int line)
|
||||
{
|
||||
pr_err("assertion failed: %s, in %s:%d\n", expr, file, line);
|
||||
BUG();
|
||||
}
|
||||
#endif
|
||||
|
||||
void __cold btrfs_print_v0_err(struct btrfs_fs_info *fs_info)
|
||||
{
|
||||
btrfs_err(fs_info,
|
||||
"Unsupported V0 extent filesystem detected. Aborting. Please re-create your filesystem with a newer kernel");
|
||||
}
|
||||
|
||||
#if BITS_PER_LONG == 32 && defined(__KERNEL__)
|
||||
void __cold btrfs_warn_32bit_limit(struct btrfs_fs_info *fs_info)
|
||||
{
|
||||
if (!test_and_set_bit(BTRFS_FS_32BIT_WARN, &fs_info->flags)) {
|
||||
btrfs_warn(fs_info, "reaching 32bit limit for logical addresses");
|
||||
btrfs_warn(fs_info,
|
||||
"due to page cache limit on 32bit systems, btrfs can't access metadata at or beyond %lluT",
|
||||
BTRFS_32BIT_MAX_FILE_SIZE >> 40);
|
||||
btrfs_warn(fs_info,
|
||||
"please consider upgrading to 64bit kernel/hardware");
|
||||
}
|
||||
}
|
||||
|
||||
void __cold btrfs_err_32bit_limit(struct btrfs_fs_info *fs_info)
|
||||
{
|
||||
if (!test_and_set_bit(BTRFS_FS_32BIT_ERROR, &fs_info->flags)) {
|
||||
btrfs_err(fs_info, "reached 32bit limit for logical addresses");
|
||||
btrfs_err(fs_info,
|
||||
"due to page cache limit on 32bit systems, metadata beyond %lluT can't be accessed",
|
||||
BTRFS_32BIT_MAX_FILE_SIZE >> 40);
|
||||
btrfs_err(fs_info,
|
||||
"please consider upgrading to 64bit kernel/hardware");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* __btrfs_panic decodes unexpected, fatal errors from the caller, issues an
|
||||
* alert, and either panics or BUGs, depending on mount options.
|
||||
*
|
||||
* MODIFIED:
|
||||
* - We don't have btrfs_test_opt() yet, kill that and s_id.
|
||||
*/
|
||||
__cold
|
||||
void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
|
||||
unsigned int line, int error, const char *fmt, ...)
|
||||
{
|
||||
const char *errstr;
|
||||
struct va_format vaf = { .fmt = fmt };
|
||||
va_list args;
|
||||
#if 0
|
||||
char *s_id = "<unknown>";
|
||||
|
||||
if (fs_info)
|
||||
s_id = fs_info->sb->s_id;
|
||||
#endif
|
||||
|
||||
va_start(args, fmt);
|
||||
vaf.va = &args;
|
||||
|
||||
errstr = btrfs_decode_error(error);
|
||||
#if 0
|
||||
if (fs_info && (btrfs_test_opt(fs_info, PANIC_ON_FATAL_ERROR)))
|
||||
panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (error=%d %s)\n",
|
||||
s_id, function, line, &vaf, error, errstr);
|
||||
#endif
|
||||
|
||||
btrfs_crit(fs_info, "panic in %s:%d: %pV (error=%d %s)",
|
||||
function, line, &vaf, error, errstr);
|
||||
va_end(args);
|
||||
/* Caller calls BUG() */
|
||||
}
|
||||
216
kernel-shared/messages.h
Normal file
216
kernel-shared/messages.h
Normal file
@ -0,0 +1,216 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
|
||||
#ifndef BTRFS_MESSAGES_H
|
||||
#define BTRFS_MESSAGES_H
|
||||
|
||||
#include "kerncompat.h"
|
||||
#include <linux/types.h>
|
||||
#include "common/messages.h"
|
||||
|
||||
struct btrfs_fs_info;
|
||||
struct btrfs_trans_handle;
|
||||
|
||||
#ifdef __KERNEL__
|
||||
static inline __printf(2, 3) __cold
|
||||
void btrfs_no_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_PRINTK
|
||||
|
||||
#define btrfs_printk(fs_info, fmt, args...) \
|
||||
_btrfs_printk(fs_info, fmt, ##args)
|
||||
|
||||
__printf(2, 3)
|
||||
__cold
|
||||
void _btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...);
|
||||
|
||||
#else
|
||||
|
||||
#define btrfs_printk(fs_info, fmt, args...) \
|
||||
btrfs_no_printk(fs_info, fmt, ##args)
|
||||
#endif
|
||||
|
||||
#define btrfs_emerg(fs_info, fmt, args...) \
|
||||
btrfs_printk(fs_info, KERN_EMERG fmt, ##args)
|
||||
#define btrfs_alert(fs_info, fmt, args...) \
|
||||
btrfs_printk(fs_info, KERN_ALERT fmt, ##args)
|
||||
#define btrfs_crit(fs_info, fmt, args...) \
|
||||
btrfs_printk(fs_info, KERN_CRIT fmt, ##args)
|
||||
#define btrfs_err(fs_info, fmt, args...) \
|
||||
btrfs_printk(fs_info, KERN_ERR fmt, ##args)
|
||||
#define btrfs_warn(fs_info, fmt, args...) \
|
||||
btrfs_printk(fs_info, KERN_WARNING fmt, ##args)
|
||||
#define btrfs_notice(fs_info, fmt, args...) \
|
||||
btrfs_printk(fs_info, KERN_NOTICE fmt, ##args)
|
||||
#define btrfs_info(fs_info, fmt, args...) \
|
||||
btrfs_printk(fs_info, KERN_INFO fmt, ##args)
|
||||
|
||||
/*
|
||||
* Wrappers that use printk_in_rcu
|
||||
*/
|
||||
#define btrfs_emerg_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_in_rcu(fs_info, KERN_EMERG fmt, ##args)
|
||||
#define btrfs_alert_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_in_rcu(fs_info, KERN_ALERT fmt, ##args)
|
||||
#define btrfs_crit_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_in_rcu(fs_info, KERN_CRIT fmt, ##args)
|
||||
#define btrfs_err_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_in_rcu(fs_info, KERN_ERR fmt, ##args)
|
||||
#define btrfs_warn_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_in_rcu(fs_info, KERN_WARNING fmt, ##args)
|
||||
#define btrfs_notice_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
|
||||
#define btrfs_info_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_in_rcu(fs_info, KERN_INFO fmt, ##args)
|
||||
|
||||
/*
|
||||
* Wrappers that use a ratelimited printk_in_rcu
|
||||
*/
|
||||
#define btrfs_emerg_rl_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_rl_in_rcu(fs_info, KERN_EMERG fmt, ##args)
|
||||
#define btrfs_alert_rl_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_rl_in_rcu(fs_info, KERN_ALERT fmt, ##args)
|
||||
#define btrfs_crit_rl_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_rl_in_rcu(fs_info, KERN_CRIT fmt, ##args)
|
||||
#define btrfs_err_rl_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_rl_in_rcu(fs_info, KERN_ERR fmt, ##args)
|
||||
#define btrfs_warn_rl_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_rl_in_rcu(fs_info, KERN_WARNING fmt, ##args)
|
||||
#define btrfs_notice_rl_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_rl_in_rcu(fs_info, KERN_NOTICE fmt, ##args)
|
||||
#define btrfs_info_rl_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_rl_in_rcu(fs_info, KERN_INFO fmt, ##args)
|
||||
|
||||
/*
|
||||
* Wrappers that use a ratelimited printk
|
||||
*/
|
||||
#define btrfs_emerg_rl(fs_info, fmt, args...) \
|
||||
btrfs_printk_ratelimited(fs_info, KERN_EMERG fmt, ##args)
|
||||
#define btrfs_alert_rl(fs_info, fmt, args...) \
|
||||
btrfs_printk_ratelimited(fs_info, KERN_ALERT fmt, ##args)
|
||||
#define btrfs_crit_rl(fs_info, fmt, args...) \
|
||||
btrfs_printk_ratelimited(fs_info, KERN_CRIT fmt, ##args)
|
||||
#define btrfs_err_rl(fs_info, fmt, args...) \
|
||||
btrfs_printk_ratelimited(fs_info, KERN_ERR fmt, ##args)
|
||||
#define btrfs_warn_rl(fs_info, fmt, args...) \
|
||||
btrfs_printk_ratelimited(fs_info, KERN_WARNING fmt, ##args)
|
||||
#define btrfs_notice_rl(fs_info, fmt, args...) \
|
||||
btrfs_printk_ratelimited(fs_info, KERN_NOTICE fmt, ##args)
|
||||
#define btrfs_info_rl(fs_info, fmt, args...) \
|
||||
btrfs_printk_ratelimited(fs_info, KERN_INFO fmt, ##args)
|
||||
|
||||
#if defined(CONFIG_DYNAMIC_DEBUG)
|
||||
#define btrfs_debug(fs_info, fmt, args...) \
|
||||
_dynamic_func_call_no_desc(fmt, btrfs_printk, \
|
||||
fs_info, KERN_DEBUG fmt, ##args)
|
||||
#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
|
||||
_dynamic_func_call_no_desc(fmt, btrfs_printk_in_rcu, \
|
||||
fs_info, KERN_DEBUG fmt, ##args)
|
||||
#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
|
||||
_dynamic_func_call_no_desc(fmt, btrfs_printk_rl_in_rcu, \
|
||||
fs_info, KERN_DEBUG fmt, ##args)
|
||||
#define btrfs_debug_rl(fs_info, fmt, args...) \
|
||||
_dynamic_func_call_no_desc(fmt, btrfs_printk_ratelimited, \
|
||||
fs_info, KERN_DEBUG fmt, ##args)
|
||||
#elif defined(DEBUG)
|
||||
#define btrfs_debug(fs_info, fmt, args...) \
|
||||
btrfs_printk(fs_info, KERN_DEBUG fmt, ##args)
|
||||
#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
|
||||
#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_printk_rl_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
|
||||
#define btrfs_debug_rl(fs_info, fmt, args...) \
|
||||
btrfs_printk_ratelimited(fs_info, KERN_DEBUG fmt, ##args)
|
||||
#else
|
||||
#define btrfs_debug(fs_info, fmt, args...) \
|
||||
btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
|
||||
#define btrfs_debug_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_no_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
|
||||
#define btrfs_debug_rl_in_rcu(fs_info, fmt, args...) \
|
||||
btrfs_no_printk_in_rcu(fs_info, KERN_DEBUG fmt, ##args)
|
||||
#define btrfs_debug_rl(fs_info, fmt, args...) \
|
||||
btrfs_no_printk(fs_info, KERN_DEBUG fmt, ##args)
|
||||
#endif
|
||||
|
||||
#define btrfs_printk_in_rcu(fs_info, fmt, args...) \
|
||||
do { \
|
||||
rcu_read_lock(); \
|
||||
btrfs_printk(fs_info, fmt, ##args); \
|
||||
rcu_read_unlock(); \
|
||||
} while (0)
|
||||
|
||||
#define btrfs_no_printk_in_rcu(fs_info, fmt, args...) \
|
||||
do { \
|
||||
rcu_read_lock(); \
|
||||
btrfs_no_printk(fs_info, fmt, ##args); \
|
||||
rcu_read_unlock(); \
|
||||
} while (0)
|
||||
|
||||
#define btrfs_printk_ratelimited(fs_info, fmt, args...) \
|
||||
do { \
|
||||
static DEFINE_RATELIMIT_STATE(_rs, \
|
||||
DEFAULT_RATELIMIT_INTERVAL, \
|
||||
DEFAULT_RATELIMIT_BURST); \
|
||||
if (__ratelimit(&_rs)) \
|
||||
btrfs_printk(fs_info, fmt, ##args); \
|
||||
} while (0)
|
||||
|
||||
#define btrfs_printk_rl_in_rcu(fs_info, fmt, args...) \
|
||||
do { \
|
||||
rcu_read_lock(); \
|
||||
btrfs_printk_ratelimited(fs_info, fmt, ##args); \
|
||||
rcu_read_unlock(); \
|
||||
} while (0)
|
||||
|
||||
#ifdef CONFIG_BTRFS_ASSERT
|
||||
void __cold btrfs_assertfail(const char *expr, const char *file, int line);
|
||||
|
||||
#define ASSERT(expr) \
|
||||
(likely(expr) ? (void)0 : btrfs_assertfail(#expr, __FILE__, __LINE__))
|
||||
#else
|
||||
#define ASSERT(expr) (void)(expr)
|
||||
#endif
|
||||
|
||||
void __cold btrfs_print_v0_err(struct btrfs_fs_info *fs_info);
|
||||
|
||||
__printf(5, 6)
|
||||
__cold
|
||||
void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
|
||||
unsigned int line, int error, const char *fmt, ...);
|
||||
|
||||
const char * __attribute_const__ btrfs_decode_error(int error);
|
||||
|
||||
#define btrfs_handle_fs_error(fs_info, error, fmt, args...) \
|
||||
__btrfs_handle_fs_error((fs_info), __func__, __LINE__, \
|
||||
(error), fmt, ##args)
|
||||
|
||||
__printf(5, 6)
|
||||
__cold
|
||||
void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
|
||||
unsigned int line, int error, const char *fmt, ...);
|
||||
/*
|
||||
* If BTRFS_MOUNT_PANIC_ON_FATAL_ERROR is in mount_opt, __btrfs_panic
|
||||
* will panic(). Otherwise we BUG() here.
|
||||
*/
|
||||
#define btrfs_panic(fs_info, error, fmt, args...) \
|
||||
do { \
|
||||
__btrfs_panic(fs_info, __func__, __LINE__, error, fmt, ##args); \
|
||||
BUG(); \
|
||||
} while (0)
|
||||
|
||||
#if BITS_PER_LONG == 32
|
||||
#define BTRFS_32BIT_MAX_FILE_SIZE (((u64)ULONG_MAX + 1) << PAGE_SHIFT)
|
||||
/*
|
||||
* The warning threshold is 5/8th of the MAX_LFS_FILESIZE that limits the logical
|
||||
* addresses of extents.
|
||||
*
|
||||
* For 4K page size it's about 10T, for 64K it's 160T.
|
||||
*/
|
||||
#define BTRFS_32BIT_EARLY_WARN_THRESHOLD (BTRFS_32BIT_MAX_FILE_SIZE * 5 / 8)
|
||||
void btrfs_warn_32bit_limit(struct btrfs_fs_info *fs_info);
|
||||
void btrfs_err_32bit_limit(struct btrfs_fs_info *fs_info);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -21,6 +21,7 @@
|
||||
#include "kerncompat.h"
|
||||
#include "ulist.h"
|
||||
#include "kernel-shared/ctree.h"
|
||||
#include "kernel-shared/messages.h"
|
||||
|
||||
/*
|
||||
* ulist is a generic data structure to hold a collection of unique u64
|
||||
|
||||
@ -22,6 +22,7 @@
|
||||
#include <stdbool.h>
|
||||
#include "kernel-shared/disk-io.h"
|
||||
#include "kernel-shared/volumes.h"
|
||||
#include "kernel-shared/messages.h"
|
||||
|
||||
#ifdef BTRFS_ZONED
|
||||
#include <linux/blkzoned.h>
|
||||
|
||||
@ -325,26 +325,6 @@ static inline int IS_ERR_OR_NULL(const void *ptr)
|
||||
#define memalloc_nofs_save() (0)
|
||||
#define memalloc_nofs_restore(x) ((void)(x))
|
||||
|
||||
#ifndef BTRFS_DISABLE_BACKTRACE
|
||||
static inline void assert_trace(const char *assertion, const char *filename,
|
||||
const char *func, unsigned line, long val)
|
||||
{
|
||||
if (val)
|
||||
return;
|
||||
fprintf(stderr,
|
||||
"%s:%d: %s: Assertion `%s` failed, value %ld\n",
|
||||
filename, line, func, assertion, val);
|
||||
#ifndef BTRFS_DISABLE_BACKTRACE
|
||||
print_trace();
|
||||
#endif
|
||||
abort();
|
||||
exit(1);
|
||||
}
|
||||
#define ASSERT(c) assert_trace(#c, __FILE__, __func__, __LINE__, (long)(c))
|
||||
#else
|
||||
#define ASSERT(c) assert(c)
|
||||
#endif
|
||||
|
||||
#define BUG_ON(c) bugon_trace(#c, __FILE__, __func__, __LINE__, (long)(c))
|
||||
#define BUG() \
|
||||
do { \
|
||||
|
||||
Loading…
Reference in New Issue
Block a user