Skip to content

L
linux

xiphi1978 / linux

通知 2
Star 0
Fork 0
L
linux

体验新版 GitCode，发现更多精彩内容 >>

提交 b31e1552 编写于 作者: E Eric Sandeen 提交者： Theodore Ts'o
浏览文件
操作

ext4: Change all super.c messages to print the device 

This patch changes ext4 super.c to include the device name with all 
warning/error messages, by using a new utility function ext4_msg. 
It's a rather large patch, but very mechanic. I left debug printks
alone.

This is a straightforward port of a patch which Andi Kleen did for
ext3.

Cc: Andi Kleen <ak@linux.intel.com>
Signed-off-by: NEric Sandeen <sandeen@redhat.com>
Signed-off-by: N"Theodore Ts'o" <tytso@mit.edu>
上级 03f5d8bc
显示空白变更内容
内联 并排
Showing with 235 addition and 229 deletion
fs/ext4/ext4.h
浏览文件 @ b31e1552
...@@ -1401,6 +1401,8 @@ extern void ext4_abort(struct super_block *, const char *, const char *, ...) ...@@ -1401,6 +1401,8 @@ extern void ext4_abort(struct super_block *, const char *, const char *, ...)
__attribute__ ((format (printf, 3, 4))); __attribute__ ((format (printf, 3, 4)));
extern void ext4_warning(struct super_block *, const char *, const char *, ...) extern void ext4_warning(struct super_block *, const char *, const char *, ...)
__attribute__ ((format (printf, 3, 4))); __attribute__ ((format (printf, 3, 4)));
extern void ext4_msg(struct super_block *, const char *, const char *, ...)
__attribute__ ((format (printf, 3, 4)));
extern void ext4_grp_locked_error(struct super_block *, ext4_group_t, extern void ext4_grp_locked_error(struct super_block *, ext4_group_t,
const char *, const char *, ...) const char *, const char *, ...)
__attribute__ ((format (printf, 4, 5))); __attribute__ ((format (printf, 4, 5)));
......
fs/ext4/super.c
浏览文件 @ b31e1552
...@@ -306,7 +306,7 @@ static void ext4_handle_error(struct super_block *sb) ...@@ -306,7 +306,7 @@ static void ext4_handle_error(struct super_block *sb)
jbd2_journal_abort(journal, -EIO); jbd2_journal_abort(journal, -EIO);
} }
if (test_opt(sb, ERRORS_RO)) { if (test_opt(sb, ERRORS_RO)) {
printk(KERN_CRIT "Remounting filesystem read-only\n"); ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
} }
ext4_commit_super(sb, 1); ext4_commit_super(sb, 1);
...@@ -399,8 +399,6 @@ void ext4_abort(struct super_block *sb, const char *function, ...@@ -399,8 +399,6 @@ void ext4_abort(struct super_block *sb, const char *function,
{ {
va_list args; va_list args;
printk(KERN_CRIT "ext4_abort called.\n");
va_start(args, fmt); va_start(args, fmt);
printk(KERN_CRIT "EXT4-fs error (device %s): %s: ", sb->s_id, function); printk(KERN_CRIT "EXT4-fs error (device %s): %s: ", sb->s_id, function);
vprintk(fmt, args); vprintk(fmt, args);
...@@ -413,7 +411,7 @@ void ext4_abort(struct super_block *sb, const char *function, ...@@ -413,7 +411,7 @@ void ext4_abort(struct super_block *sb, const char *function,
if (sb->s_flags & MS_RDONLY) if (sb->s_flags & MS_RDONLY)
return; return;
printk(KERN_CRIT "Remounting filesystem read-only\n"); ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS; EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT; EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
...@@ -421,6 +419,18 @@ void ext4_abort(struct super_block *sb, const char *function, ...@@ -421,6 +419,18 @@ void ext4_abort(struct super_block *sb, const char *function,
jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO); jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
} }
void ext4_msg (struct super_block * sb, const char *prefix,
const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
printk("%sEXT4-fs (%s): ", prefix, sb->s_id);
vprintk(fmt, args);
printk("\n");
va_end(args);
}
void ext4_warning(struct super_block *sb, const char *function, void ext4_warning(struct super_block *sb, const char *function,
const char *fmt, ...) const char *fmt, ...)
{ {
...@@ -499,7 +509,7 @@ void ext4_update_dynamic_rev(struct super_block *sb) ...@@ -499,7 +509,7 @@ void ext4_update_dynamic_rev(struct super_block *sb)
/* /*
* Open the external journal device * Open the external journal device
*/ */
static struct block_device *ext4_blkdev_get(dev_t dev) static struct block_device *ext4_blkdev_get(dev_t dev, struct super_block *sb)
{ {
struct block_device *bdev; struct block_device *bdev;
char b[BDEVNAME_SIZE]; char b[BDEVNAME_SIZE];
...@@ -510,7 +520,7 @@ static struct block_device *ext4_blkdev_get(dev_t dev) ...@@ -510,7 +520,7 @@ static struct block_device *ext4_blkdev_get(dev_t dev)
return bdev; return bdev;
fail: fail:
printk(KERN_ERR "EXT4-fs: failed to open journal device %s: %ld\n", ext4_msg(sb, KERN_ERR, "failed to open journal device %s: %ld",
__bdevname(dev, b), PTR_ERR(bdev)); __bdevname(dev, b), PTR_ERR(bdev));
return NULL; return NULL;
} }
...@@ -546,7 +556,7 @@ static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi) ...@@ -546,7 +556,7 @@ static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi)
{ {
struct list_head *l; struct list_head *l;
printk(KERN_ERR "sb orphan head is %d\n", ext4_msg(sb, KERN_ERR, "sb orphan head is %d",
le32_to_cpu(sbi->s_es->s_last_orphan)); le32_to_cpu(sbi->s_es->s_last_orphan));
printk(KERN_ERR "sb_info orphan list:\n"); printk(KERN_ERR "sb_info orphan list:\n");
...@@ -678,8 +688,9 @@ static struct inode *ext4_alloc_inode(struct super_block *sb) ...@@ -678,8 +688,9 @@ static struct inode *ext4_alloc_inode(struct super_block *sb)
static void ext4_destroy_inode(struct inode *inode) static void ext4_destroy_inode(struct inode *inode)
{ {
if (!list_empty(&(EXT4_I(inode)->i_orphan))) { if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
printk("EXT4 Inode %p: orphan list check failed!\n", ext4_msg(inode->i_sb, KERN_ERR,
EXT4_I(inode)); "Inode %lu (%p): orphan list check failed!",
inode->i_ino, EXT4_I(inode));
print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4, print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
EXT4_I(inode), sizeof(struct ext4_inode_info), EXT4_I(inode), sizeof(struct ext4_inode_info),
true); true);
...@@ -1239,8 +1250,7 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1239,8 +1250,7 @@ static int parse_options(char *options, struct super_block *sb,
#else #else
case Opt_user_xattr: case Opt_user_xattr:
case Opt_nouser_xattr: case Opt_nouser_xattr:
printk(KERN_ERR "EXT4 (no)user_xattr options " ext4_msg(sb, KERN_ERR, "(no)user_xattr options not supported");
"not supported\n");
break; break;
#endif #endif
#ifdef CONFIG_EXT4_FS_POSIX_ACL #ifdef CONFIG_EXT4_FS_POSIX_ACL
...@@ -1253,8 +1263,7 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1253,8 +1263,7 @@ static int parse_options(char *options, struct super_block *sb,
#else #else
case Opt_acl: case Opt_acl:
case Opt_noacl: case Opt_noacl:
printk(KERN_ERR "EXT4 (no)acl options " ext4_msg(sb, KERN_ERR, "(no)acl options not supported");
"not supported\n");
break; break;
#endif #endif
case Opt_journal_update: case Opt_journal_update:
...@@ -1264,16 +1273,16 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1264,16 +1273,16 @@ static int parse_options(char *options, struct super_block *sb,
user to specify an existing inode to be the user to specify an existing inode to be the
journal file. */ journal file. */
if (is_remount) { if (is_remount) {
printk(KERN_ERR "EXT4-fs: cannot specify " ext4_msg(sb, KERN_ERR,
"journal on remount\n"); "Cannot specify journal on remount");
return 0; return 0;
} }
set_opt(sbi->s_mount_opt, UPDATE_JOURNAL); set_opt(sbi->s_mount_opt, UPDATE_JOURNAL);
break; break;
case Opt_journal_dev: case Opt_journal_dev:
if (is_remount) { if (is_remount) {
printk(KERN_ERR "EXT4-fs: cannot specify " ext4_msg(sb, KERN_ERR,
"journal on remount\n"); "Cannot specify journal on remount");
return 0; return 0;
} }
if (match_int(&args[0], &option)) if (match_int(&args[0], &option))
...@@ -1327,9 +1336,8 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1327,9 +1336,8 @@ static int parse_options(char *options, struct super_block *sb,
if (is_remount) { if (is_remount) {
if ((sbi->s_mount_opt & EXT4_MOUNT_DATA_FLAGS) if ((sbi->s_mount_opt & EXT4_MOUNT_DATA_FLAGS)
!= data_opt) { != data_opt) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: cannot change data " "Cannot change data mode on remount");
"mode on remount\n");
return 0; return 0;
} }
} else { } else {
...@@ -1359,31 +1367,31 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1359,31 +1367,31 @@ static int parse_options(char *options, struct super_block *sb,
set_qf_name: set_qf_name:
if (sb_any_quota_loaded(sb) && if (sb_any_quota_loaded(sb) &&
!sbi->s_qf_names[qtype]) { !sbi->s_qf_names[qtype]) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: Cannot change journaled " "Cannot change journaled "
"quota options when quota turned on.\n"); "quota options when quota turned on");
return 0; return 0;
} }
qname = match_strdup(&args[0]); qname = match_strdup(&args[0]);
if (!qname) { if (!qname) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: not enough memory for " "Not enough memory for "
"storing quotafile name.\n"); "storing quotafile name");
return 0; return 0;
} }
if (sbi->s_qf_names[qtype] && if (sbi->s_qf_names[qtype] &&
strcmp(sbi->s_qf_names[qtype], qname)) { strcmp(sbi->s_qf_names[qtype], qname)) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: %s quota file already " "%s quota file already "
"specified.\n", QTYPE2NAME(qtype)); "specified", QTYPE2NAME(qtype));
kfree(qname); kfree(qname);
return 0; return 0;
} }
sbi->s_qf_names[qtype] = qname; sbi->s_qf_names[qtype] = qname;
if (strchr(sbi->s_qf_names[qtype], '/')) { if (strchr(sbi->s_qf_names[qtype], '/')) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: quotafile must be on " "quotafile must be on "
"filesystem root.\n"); "filesystem root");
kfree(sbi->s_qf_names[qtype]); kfree(sbi->s_qf_names[qtype]);
sbi->s_qf_names[qtype] = NULL; sbi->s_qf_names[qtype] = NULL;
return 0; return 0;
...@@ -1398,9 +1406,9 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1398,9 +1406,9 @@ static int parse_options(char *options, struct super_block *sb,
clear_qf_name: clear_qf_name:
if (sb_any_quota_loaded(sb) && if (sb_any_quota_loaded(sb) &&
sbi->s_qf_names[qtype]) { sbi->s_qf_names[qtype]) {
printk(KERN_ERR "EXT4-fs: Cannot change " ext4_msg(sb, KERN_ERR, "Cannot change "
"journaled quota options when " "journaled quota options when "
"quota turned on.\n"); "quota turned on");
return 0; return 0;
} }
/* /*
...@@ -1417,9 +1425,9 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1417,9 +1425,9 @@ static int parse_options(char *options, struct super_block *sb,
set_qf_format: set_qf_format:
if (sb_any_quota_loaded(sb) && if (sb_any_quota_loaded(sb) &&
sbi->s_jquota_fmt != qfmt) { sbi->s_jquota_fmt != qfmt) {
printk(KERN_ERR "EXT4-fs: Cannot change " ext4_msg(sb, KERN_ERR, "Cannot change "
"journaled quota options when " "journaled quota options when "
"quota turned on.\n"); "quota turned on");
return 0; return 0;
} }
sbi->s_jquota_fmt = qfmt; sbi->s_jquota_fmt = qfmt;
...@@ -1435,8 +1443,8 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1435,8 +1443,8 @@ static int parse_options(char *options, struct super_block *sb,
break; break;
case Opt_noquota: case Opt_noquota:
if (sb_any_quota_loaded(sb)) { if (sb_any_quota_loaded(sb)) {
printk(KERN_ERR "EXT4-fs: Cannot change quota " ext4_msg(sb, KERN_ERR, "Cannot change quota "
"options when quota turned on.\n"); "options when quota turned on");
return 0; return 0;
} }
clear_opt(sbi->s_mount_opt, QUOTA); clear_opt(sbi->s_mount_opt, QUOTA);
...@@ -1447,8 +1455,8 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1447,8 +1455,8 @@ static int parse_options(char *options, struct super_block *sb,
case Opt_quota: case Opt_quota:
case Opt_usrquota: case Opt_usrquota:
case Opt_grpquota: case Opt_grpquota:
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: quota options not supported.\n"); "quota options not supported");
break; break;
case Opt_usrjquota: case Opt_usrjquota:
case Opt_grpjquota: case Opt_grpjquota:
...@@ -1456,9 +1464,8 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1456,9 +1464,8 @@ static int parse_options(char *options, struct super_block *sb,
case Opt_offgrpjquota: case Opt_offgrpjquota:
case Opt_jqfmt_vfsold: case Opt_jqfmt_vfsold:
case Opt_jqfmt_vfsv0: case Opt_jqfmt_vfsv0:
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: journaled quota options not " "journaled quota options not supported");
"supported.\n");
break; break;
case Opt_noquota: case Opt_noquota:
break; break;
...@@ -1483,8 +1490,9 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1483,8 +1490,9 @@ static int parse_options(char *options, struct super_block *sb,
break; break;
case Opt_resize: case Opt_resize:
if (!is_remount) { if (!is_remount) {
printk("EXT4-fs: resize option only available " ext4_msg(sb, KERN_ERR,
"for remount\n"); "resize option only available "
"for remount");
return 0; return 0;
} }
if (match_int(&args[0], &option) != 0) if (match_int(&args[0], &option) != 0)
...@@ -1526,8 +1534,9 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1526,8 +1534,9 @@ static int parse_options(char *options, struct super_block *sb,
if (option < 0 || option > (1 << 30)) if (option < 0 || option > (1 << 30))
return 0; return 0;
if (!is_power_of_2(option)) { if (!is_power_of_2(option)) {
printk(KERN_ERR "EXT4-fs: inode_readahead_blks" ext4_msg(sb, KERN_ERR,
" must be a power of 2\n"); "EXT4-fs: inode_readahead_blks"
" must be a power of 2");
return 0; return 0;
} }
sbi->s_inode_readahead_blks = option; sbi->s_inode_readahead_blks = option;
...@@ -1554,9 +1563,9 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1554,9 +1563,9 @@ static int parse_options(char *options, struct super_block *sb,
set_opt(sbi->s_mount_opt,NO_AUTO_DA_ALLOC); set_opt(sbi->s_mount_opt,NO_AUTO_DA_ALLOC);
break; break;
default: default:
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: Unrecognized mount option \"%s\" " "Unrecognized mount option \"%s\" "
"or missing value\n", p); "or missing value", p);
return 0; return 0;
} }
} }
...@@ -1574,21 +1583,21 @@ static int parse_options(char *options, struct super_block *sb, ...@@ -1574,21 +1583,21 @@ static int parse_options(char *options, struct super_block *sb,
(sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA)) || (sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA)) ||
(sbi->s_qf_names[GRPQUOTA] && (sbi->s_qf_names[GRPQUOTA] &&
(sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA))) { (sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA))) {
printk(KERN_ERR "EXT4-fs: old and new quota " ext4_msg(sb, KERN_ERR, "old and new quota "
"format mixing.\n"); "format mixing");
return 0; return 0;
} }
if (!sbi->s_jquota_fmt) { if (!sbi->s_jquota_fmt) {
printk(KERN_ERR "EXT4-fs: journaled quota format " ext4_msg(sb, KERN_ERR, "journaled quota format "
"not specified.\n"); "not specified");
return 0; return 0;
} }
} else { } else {
if (sbi->s_jquota_fmt) { if (sbi->s_jquota_fmt) {
printk(KERN_ERR "EXT4-fs: journaled quota format " ext4_msg(sb, KERN_ERR, "journaled quota format "
"specified with no journaling " "specified with no journaling "
"enabled.\n"); "enabled");
return 0; return 0;
} }
} }
...@@ -1603,31 +1612,31 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es, ...@@ -1603,31 +1612,31 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
int res = 0; int res = 0;
if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) { if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
printk(KERN_ERR "EXT4-fs warning: revision level too high, " ext4_msg(sb, KERN_ERR, "revision level too high, "
"forcing read-only mode\n"); "forcing read-only mode");
res = MS_RDONLY; res = MS_RDONLY;
} }
if (read_only) if (read_only)
return res; return res;
if (!(sbi->s_mount_state & EXT4_VALID_FS)) if (!(sbi->s_mount_state & EXT4_VALID_FS))
printk(KERN_WARNING "EXT4-fs warning: mounting unchecked fs, " ext4_msg(sb, KERN_WARNING, "warning: mounting unchecked fs, "
"running e2fsck is recommended\n"); "running e2fsck is recommended");
else if ((sbi->s_mount_state & EXT4_ERROR_FS)) else if ((sbi->s_mount_state & EXT4_ERROR_FS))
printk(KERN_WARNING ext4_msg(sb, KERN_WARNING,
"EXT4-fs warning: mounting fs with errors, " "warning: mounting fs with errors, "
"running e2fsck is recommended\n"); "running e2fsck is recommended");
else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 && else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
le16_to_cpu(es->s_mnt_count) >= le16_to_cpu(es->s_mnt_count) >=
(unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count)) (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
printk(KERN_WARNING ext4_msg(sb, KERN_WARNING,
"EXT4-fs warning: maximal mount count reached, " "warning: maximal mount count reached, "
"running e2fsck is recommended\n"); "running e2fsck is recommended");
else if (le32_to_cpu(es->s_checkinterval) && else if (le32_to_cpu(es->s_checkinterval) &&
(le32_to_cpu(es->s_lastcheck) + (le32_to_cpu(es->s_lastcheck) +
le32_to_cpu(es->s_checkinterval) <= get_seconds())) le32_to_cpu(es->s_checkinterval) <= get_seconds()))
printk(KERN_WARNING ext4_msg(sb, KERN_WARNING,
"EXT4-fs warning: checktime reached, " "warning: checktime reached, "
"running e2fsck is recommended\n"); "running e2fsck is recommended");
if (!sbi->s_journal) if (!sbi->s_journal)
es->s_state &= cpu_to_le16(~EXT4_VALID_FS); es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
if (!(__s16) le16_to_cpu(es->s_max_mnt_count)) if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
...@@ -1649,11 +1658,11 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es, ...@@ -1649,11 +1658,11 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
sbi->s_mount_opt); sbi->s_mount_opt);
if (EXT4_SB(sb)->s_journal) { if (EXT4_SB(sb)->s_journal) {
printk(KERN_INFO "EXT4 FS on %s, %s journal on %s\n", ext4_msg(sb, KERN_INFO, "%s journal on %s",
sb->s_id, EXT4_SB(sb)->s_journal->j_inode ? "internal" : EXT4_SB(sb)->s_journal->j_inode ? "internal" :
"external", EXT4_SB(sb)->s_journal->j_devname); "external", EXT4_SB(sb)->s_journal->j_devname);
} else { } else {
printk(KERN_INFO "EXT4 FS on %s, no journal\n", sb->s_id); ext4_msg(sb, KERN_INFO, "no journal");
} }
return res; return res;
} }
...@@ -1688,8 +1697,8 @@ static int ext4_fill_flex_info(struct super_block *sb) ...@@ -1688,8 +1697,8 @@ static int ext4_fill_flex_info(struct super_block *sb)
memset(sbi->s_flex_groups, 0, size); memset(sbi->s_flex_groups, 0, size);
} }
if (sbi->s_flex_groups == NULL) { if (sbi->s_flex_groups == NULL) {
printk(KERN_ERR "EXT4-fs: not enough memory for " ext4_msg(sb, KERN_ERR, "not enough memory for "
"%u flex groups\n", flex_group_count); "%u flex groups", flex_group_count);
goto failed; goto failed;
} }
...@@ -1775,30 +1784,30 @@ static int ext4_check_descriptors(struct super_block *sb) ...@@ -1775,30 +1784,30 @@ static int ext4_check_descriptors(struct super_block *sb)
block_bitmap = ext4_block_bitmap(sb, gdp); block_bitmap = ext4_block_bitmap(sb, gdp);
if (block_bitmap < first_block || block_bitmap > last_block) { if (block_bitmap < first_block || block_bitmap > last_block) {
printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: " ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
"Block bitmap for group %u not in group " "Block bitmap for group %u not in group "
"(block %llu)!\n", i, block_bitmap); "(block %llu)!", i, block_bitmap);
return 0; return 0;
} }
inode_bitmap = ext4_inode_bitmap(sb, gdp); inode_bitmap = ext4_inode_bitmap(sb, gdp);
if (inode_bitmap < first_block || inode_bitmap > last_block) { if (inode_bitmap < first_block || inode_bitmap > last_block) {
printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: " ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
"Inode bitmap for group %u not in group " "Inode bitmap for group %u not in group "
"(block %llu)!\n", i, inode_bitmap); "(block %llu)!", i, inode_bitmap);
return 0; return 0;
} }
inode_table = ext4_inode_table(sb, gdp); inode_table = ext4_inode_table(sb, gdp);
if (inode_table < first_block || if (inode_table < first_block ||
inode_table + sbi->s_itb_per_group - 1 > last_block) { inode_table + sbi->s_itb_per_group - 1 > last_block) {
printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: " ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
"Inode table for group %u not in group " "Inode table for group %u not in group "
"(block %llu)!\n", i, inode_table); "(block %llu)!", i, inode_table);
return 0; return 0;
} }
ext4_lock_group(sb, i); ext4_lock_group(sb, i);
if (!ext4_group_desc_csum_verify(sbi, i, gdp)) { if (!ext4_group_desc_csum_verify(sbi, i, gdp)) {
printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: " ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
"Checksum for group %u failed (%u!=%u)\n", "Checksum for group %u failed (%u!=%u)",
i, le16_to_cpu(ext4_group_desc_csum(sbi, i, i, le16_to_cpu(ext4_group_desc_csum(sbi, i,
gdp)), le16_to_cpu(gdp->bg_checksum)); gdp)), le16_to_cpu(gdp->bg_checksum));
if (!(sb->s_flags & MS_RDONLY)) { if (!(sb->s_flags & MS_RDONLY)) {
...@@ -1847,8 +1856,8 @@ static void ext4_orphan_cleanup(struct super_block *sb, ...@@ -1847,8 +1856,8 @@ static void ext4_orphan_cleanup(struct super_block *sb,
} }
if (bdev_read_only(sb->s_bdev)) { if (bdev_read_only(sb->s_bdev)) {
printk(KERN_ERR "EXT4-fs: write access " ext4_msg(sb, KERN_ERR, "write access "
"unavailable, skipping orphan cleanup.\n"); "unavailable, skipping orphan cleanup");
return; return;
} }
...@@ -1862,8 +1871,7 @@ static void ext4_orphan_cleanup(struct super_block *sb, ...@@ -1862,8 +1871,7 @@ static void ext4_orphan_cleanup(struct super_block *sb,
} }
if (s_flags & MS_RDONLY) { if (s_flags & MS_RDONLY) {
printk(KERN_INFO "EXT4-fs: %s: orphan cleanup on readonly fs\n", ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
sb->s_id);
sb->s_flags &= ~MS_RDONLY; sb->s_flags &= ~MS_RDONLY;
} }
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
...@@ -1874,9 +1882,9 @@ static void ext4_orphan_cleanup(struct super_block *sb, ...@@ -1874,9 +1882,9 @@ static void ext4_orphan_cleanup(struct super_block *sb,
if (EXT4_SB(sb)->s_qf_names[i]) { if (EXT4_SB(sb)->s_qf_names[i]) {
int ret = ext4_quota_on_mount(sb, i); int ret = ext4_quota_on_mount(sb, i);
if (ret < 0) if (ret < 0)
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: Cannot turn on journaled " "Cannot turn on journaled "
"quota: error %d\n", ret); "quota: error %d", ret);
} }
} }
#endif #endif
...@@ -1893,16 +1901,16 @@ static void ext4_orphan_cleanup(struct super_block *sb, ...@@ -1893,16 +1901,16 @@ static void ext4_orphan_cleanup(struct super_block *sb,
list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan); list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan);
vfs_dq_init(inode); vfs_dq_init(inode);
if (inode->i_nlink) { if (inode->i_nlink) {
printk(KERN_DEBUG ext4_msg(sb, KERN_DEBUG,
"%s: truncating inode %lu to %lld bytes\n", "%s: truncating inode %lu to %lld bytes",
__func__, inode->i_ino, inode->i_size); __func__, inode->i_ino, inode->i_size);
jbd_debug(2, "truncating inode %lu to %lld bytes\n", jbd_debug(2, "truncating inode %lu to %lld bytes\n",
inode->i_ino, inode->i_size); inode->i_ino, inode->i_size);
ext4_truncate(inode); ext4_truncate(inode);
nr_truncates++; nr_truncates++;
} else { } else {
printk(KERN_DEBUG ext4_msg(sb, KERN_DEBUG,
"%s: deleting unreferenced inode %lu\n", "%s: deleting unreferenced inode %lu",
__func__, inode->i_ino); __func__, inode->i_ino);
jbd_debug(2, "deleting unreferenced inode %lu\n", jbd_debug(2, "deleting unreferenced inode %lu\n",
inode->i_ino); inode->i_ino);
...@@ -1914,11 +1922,11 @@ static void ext4_orphan_cleanup(struct super_block *sb, ...@@ -1914,11 +1922,11 @@ static void ext4_orphan_cleanup(struct super_block *sb,
#define PLURAL(x) (x), ((x) == 1) ? "" : "s" #define PLURAL(x) (x), ((x) == 1) ? "" : "s"
if (nr_orphans) if (nr_orphans)
printk(KERN_INFO "EXT4-fs: %s: %d orphan inode%s deleted\n", ext4_msg(sb, KERN_INFO, "%d orphan inode%s deleted",
sb->s_id, PLURAL(nr_orphans)); PLURAL(nr_orphans));
if (nr_truncates) if (nr_truncates)
printk(KERN_INFO "EXT4-fs: %s: %d truncate%s cleaned up\n", ext4_msg(sb, KERN_INFO, "%d truncate%s cleaned up",
sb->s_id, PLURAL(nr_truncates)); PLURAL(nr_truncates));
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
/* Turn quotas off */ /* Turn quotas off */
for (i = 0; i < MAXQUOTAS; i++) { for (i = 0; i < MAXQUOTAS; i++) {
...@@ -2307,7 +2315,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2307,7 +2315,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE); blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE);
if (!blocksize) { if (!blocksize) {
printk(KERN_ERR "EXT4-fs: unable to set blocksize\n"); ext4_msg(sb, KERN_ERR, "unable to set blocksize");
goto out_fail; goto out_fail;
} }
...@@ -2323,7 +2331,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2323,7 +2331,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
} }
if (!(bh = sb_bread(sb, logical_sb_block))) { if (!(bh = sb_bread(sb, logical_sb_block))) {
printk(KERN_ERR "EXT4-fs: unable to read superblock\n"); ext4_msg(sb, KERN_ERR, "unable to read superblock");
goto out_fail; goto out_fail;
} }
/* /*
...@@ -2393,9 +2401,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2393,9 +2401,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
(EXT4_HAS_COMPAT_FEATURE(sb, ~0U) || (EXT4_HAS_COMPAT_FEATURE(sb, ~0U) ||
EXT4_HAS_RO_COMPAT_FEATURE(sb, ~0U) || EXT4_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
EXT4_HAS_INCOMPAT_FEATURE(sb, ~0U))) EXT4_HAS_INCOMPAT_FEATURE(sb, ~0U)))
printk(KERN_WARNING ext4_msg(sb, KERN_WARNING,
"EXT4-fs warning: feature flags set on rev 0 fs, " "feature flags set on rev 0 fs, "
"running e2fsck is recommended\n"); "running e2fsck is recommended");
/* /*
* Check feature flags regardless of the revision level, since we * Check feature flags regardless of the revision level, since we
...@@ -2404,16 +2412,18 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2404,16 +2412,18 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
*/ */
features = EXT4_HAS_INCOMPAT_FEATURE(sb, ~EXT4_FEATURE_INCOMPAT_SUPP); features = EXT4_HAS_INCOMPAT_FEATURE(sb, ~EXT4_FEATURE_INCOMPAT_SUPP);
if (features) { if (features) {
printk(KERN_ERR "EXT4-fs: %s: couldn't mount because of " ext4_msg(sb, KERN_ERR,
"unsupported optional features (%x).\n", sb->s_id, "Couldn't mount because of "
"unsupported optional features (%x)",
(le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_incompat) & (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_incompat) &
~EXT4_FEATURE_INCOMPAT_SUPP)); ~EXT4_FEATURE_INCOMPAT_SUPP));
goto failed_mount; goto failed_mount;
} }
features = EXT4_HAS_RO_COMPAT_FEATURE(sb, ~EXT4_FEATURE_RO_COMPAT_SUPP); features = EXT4_HAS_RO_COMPAT_FEATURE(sb, ~EXT4_FEATURE_RO_COMPAT_SUPP);
if (!(sb->s_flags & MS_RDONLY) && features) { if (!(sb->s_flags & MS_RDONLY) && features) {
printk(KERN_ERR "EXT4-fs: %s: couldn't mount RDWR because of " ext4_msg(sb, KERN_ERR,
"unsupported optional features (%x).\n", sb->s_id, "Couldn't mount RDWR because of "
"unsupported optional features (%x)",
(le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) & (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) &
~EXT4_FEATURE_RO_COMPAT_SUPP)); ~EXT4_FEATURE_RO_COMPAT_SUPP));
goto failed_mount; goto failed_mount;
...@@ -2427,9 +2437,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2427,9 +2437,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
*/ */
if (sizeof(root->i_blocks) < sizeof(u64) && if (sizeof(root->i_blocks) < sizeof(u64) &&
!(sb->s_flags & MS_RDONLY)) { !(sb->s_flags & MS_RDONLY)) {
printk(KERN_ERR "EXT4-fs: %s: Filesystem with huge " ext4_msg(sb, KERN_ERR, "Filesystem with huge "
"files cannot be mounted read-write " "files cannot be mounted read-write "
"without CONFIG_LBD.\n", sb->s_id); "without CONFIG_LBD");
goto failed_mount; goto failed_mount;
} }
} }
...@@ -2437,16 +2447,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2437,16 +2447,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
if (blocksize < EXT4_MIN_BLOCK_SIZE || if (blocksize < EXT4_MIN_BLOCK_SIZE ||
blocksize > EXT4_MAX_BLOCK_SIZE) { blocksize > EXT4_MAX_BLOCK_SIZE) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: Unsupported filesystem blocksize %d on %s.\n", "Unsupported filesystem blocksize %d", blocksize);
blocksize, sb->s_id);
goto failed_mount; goto failed_mount;
} }
if (sb->s_blocksize != blocksize) { if (sb->s_blocksize != blocksize) {
/* Validate the filesystem blocksize */ /* Validate the filesystem blocksize */
if (!sb_set_blocksize(sb, blocksize)) { if (!sb_set_blocksize(sb, blocksize)) {
printk(KERN_ERR "EXT4-fs: bad block size %d.\n", ext4_msg(sb, KERN_ERR, "bad block size %d",
blocksize); blocksize);
goto failed_mount; goto failed_mount;
} }
...@@ -2456,15 +2465,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2456,15 +2465,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
offset = do_div(logical_sb_block, blocksize); offset = do_div(logical_sb_block, blocksize);
bh = sb_bread(sb, logical_sb_block); bh = sb_bread(sb, logical_sb_block);
if (!bh) { if (!bh) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: Can't read superblock on 2nd try.\n"); "Can't read superblock on 2nd try");
goto failed_mount; goto failed_mount;
} }
es = (struct ext4_super_block *)(((char *)bh->b_data) + offset); es = (struct ext4_super_block *)(((char *)bh->b_data) + offset);
sbi->s_es = es; sbi->s_es = es;
if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) { if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: Magic mismatch, very weird !\n"); "Magic mismatch, very weird!");
goto failed_mount; goto failed_mount;
} }
} }
...@@ -2482,8 +2491,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2482,8 +2491,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) || if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
(!is_power_of_2(sbi->s_inode_size)) || (!is_power_of_2(sbi->s_inode_size)) ||
(sbi->s_inode_size > blocksize)) { (sbi->s_inode_size > blocksize)) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: unsupported inode size: %d\n", "unsupported inode size: %d",
sbi->s_inode_size); sbi->s_inode_size);
goto failed_mount; goto failed_mount;
} }
...@@ -2496,8 +2505,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2496,8 +2505,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT || if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
sbi->s_desc_size > EXT4_MAX_DESC_SIZE || sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
!is_power_of_2(sbi->s_desc_size)) { !is_power_of_2(sbi->s_desc_size)) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: unsupported descriptor size %lu\n", "unsupported descriptor size %lu",
sbi->s_desc_size); sbi->s_desc_size);
goto failed_mount; goto failed_mount;
} }
...@@ -2537,25 +2546,24 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2537,25 +2546,24 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
} }
if (sbi->s_blocks_per_group > blocksize * 8) { if (sbi->s_blocks_per_group > blocksize * 8) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: #blocks per group too big: %lu\n", "#blocks per group too big: %lu",
sbi->s_blocks_per_group); sbi->s_blocks_per_group);
goto failed_mount; goto failed_mount;
} }
if (sbi->s_inodes_per_group > blocksize * 8) { if (sbi->s_inodes_per_group > blocksize * 8) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: #inodes per group too big: %lu\n", "#inodes per group too big: %lu",
sbi->s_inodes_per_group); sbi->s_inodes_per_group);
goto failed_mount; goto failed_mount;
} }
if (ext4_blocks_count(es) > if (ext4_blocks_count(es) >
(sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) { (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
printk(KERN_ERR "EXT4-fs: filesystem on %s:" ext4_msg(sb, KERN_ERR, "filesystem"
" too large to mount safely\n", sb->s_id); " too large to mount safely");
if (sizeof(sector_t) < 8) if (sizeof(sector_t) < 8)
printk(KERN_WARNING "EXT4-fs: CONFIG_LBD not " ext4_msg(sb, KERN_WARNING, "CONFIG_LBD not enabled");
"enabled\n");
goto failed_mount; goto failed_mount;
} }
...@@ -2565,8 +2573,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2565,8 +2573,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
/* check blocks count against device size */ /* check blocks count against device size */
blocks_count = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits; blocks_count = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits;
if (blocks_count && ext4_blocks_count(es) > blocks_count) { if (blocks_count && ext4_blocks_count(es) > blocks_count) {
printk(KERN_WARNING "EXT4-fs: bad geometry: block count %llu " ext4_msg(sb, KERN_WARNING, "bad geometry: block count %llu "
"exceeds size of device (%llu blocks)\n", "exceeds size of device (%llu blocks)",
ext4_blocks_count(es), blocks_count); ext4_blocks_count(es), blocks_count);
goto failed_mount; goto failed_mount;
} }
...@@ -2576,8 +2584,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2576,8 +2584,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
* of the filesystem. * of the filesystem.
*/ */
if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) { if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
printk(KERN_WARNING "EXT4-fs: bad geometry: first data" ext4_msg(sb, KERN_WARNING, "bad geometry: first data"
"block %u is beyond end of filesystem (%llu)\n", "block %u is beyond end of filesystem (%llu)",
le32_to_cpu(es->s_first_data_block), le32_to_cpu(es->s_first_data_block),
ext4_blocks_count(es)); ext4_blocks_count(es));
goto failed_mount; goto failed_mount;
...@@ -2587,9 +2595,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2587,9 +2595,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
EXT4_BLOCKS_PER_GROUP(sb) - 1); EXT4_BLOCKS_PER_GROUP(sb) - 1);
do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb)); do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) { if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
printk(KERN_WARNING "EXT4-fs: groups count too large: %u " ext4_msg(sb, KERN_WARNING, "groups count too large: %u "
"(block count %llu, first data block %u, " "(block count %llu, first data block %u, "
"blocks per group %lu)\n", sbi->s_groups_count, "blocks per group %lu)", sbi->s_groups_count,
ext4_blocks_count(es), ext4_blocks_count(es),
le32_to_cpu(es->s_first_data_block), le32_to_cpu(es->s_first_data_block),
EXT4_BLOCKS_PER_GROUP(sb)); EXT4_BLOCKS_PER_GROUP(sb));
...@@ -2601,7 +2609,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2601,7 +2609,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
sbi->s_group_desc = kmalloc(db_count * sizeof(struct buffer_head *), sbi->s_group_desc = kmalloc(db_count * sizeof(struct buffer_head *),
GFP_KERNEL); GFP_KERNEL);
if (sbi->s_group_desc == NULL) { if (sbi->s_group_desc == NULL) {
printk(KERN_ERR "EXT4-fs: not enough memory\n"); ext4_msg(sb, KERN_ERR, "not enough memory");
goto failed_mount; goto failed_mount;
} }
...@@ -2616,21 +2624,21 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2616,21 +2624,21 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
block = descriptor_loc(sb, logical_sb_block, i); block = descriptor_loc(sb, logical_sb_block, i);
sbi->s_group_desc[i] = sb_bread(sb, block); sbi->s_group_desc[i] = sb_bread(sb, block);
if (!sbi->s_group_desc[i]) { if (!sbi->s_group_desc[i]) {
printk(KERN_ERR "EXT4-fs: " ext4_msg(sb, KERN_ERR,
"can't read group descriptor %d\n", i); "can't read group descriptor %d", i);
db_count = i; db_count = i;
goto failed_mount2; goto failed_mount2;
} }
} }
if (!ext4_check_descriptors(sb)) { if (!ext4_check_descriptors(sb)) {
printk(KERN_ERR "EXT4-fs: group descriptors corrupted!\n"); ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
goto failed_mount2; goto failed_mount2;
} }
if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
if (!ext4_fill_flex_info(sb)) { if (!ext4_fill_flex_info(sb)) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: unable to initialize " "unable to initialize "
"flex_bg meta info!\n"); "flex_bg meta info!");
goto failed_mount2; goto failed_mount2;
} }
...@@ -2652,7 +2660,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2652,7 +2660,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
err = percpu_counter_init(&sbi->s_dirtyblocks_counter, 0); err = percpu_counter_init(&sbi->s_dirtyblocks_counter, 0);
} }
if (err) { if (err) {
printk(KERN_ERR "EXT4-fs: insufficient memory\n"); ext4_msg(sb, KERN_ERR, "insufficient memory");
goto failed_mount3; goto failed_mount3;
} }
...@@ -2692,13 +2700,13 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2692,13 +2700,13 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
goto failed_mount3; goto failed_mount3;
if (!(sb->s_flags & MS_RDONLY) && if (!(sb->s_flags & MS_RDONLY) &&
EXT4_SB(sb)->s_journal->j_failed_commit) { EXT4_SB(sb)->s_journal->j_failed_commit) {
printk(KERN_CRIT "EXT4-fs error (device %s): " ext4_msg(sb, KERN_CRIT, "error: "
"ext4_fill_super: Journal transaction " "ext4_fill_super: Journal transaction "
"%u is corrupt\n", sb->s_id, "%u is corrupt",
EXT4_SB(sb)->s_journal->j_failed_commit); EXT4_SB(sb)->s_journal->j_failed_commit);
if (test_opt(sb, ERRORS_RO)) { if (test_opt(sb, ERRORS_RO)) {
printk(KERN_CRIT ext4_msg(sb, KERN_CRIT,
"Mounting filesystem read-only\n"); "Mounting filesystem read-only");
sb->s_flags |= MS_RDONLY; sb->s_flags |= MS_RDONLY;
EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS; EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
es->s_state |= cpu_to_le16(EXT4_ERROR_FS); es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
...@@ -2712,8 +2720,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2712,8 +2720,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
} }
} else if (test_opt(sb, NOLOAD) && !(sb->s_flags & MS_RDONLY) && } else if (test_opt(sb, NOLOAD) && !(sb->s_flags & MS_RDONLY) &&
EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) { EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
printk(KERN_ERR "EXT4-fs: required journal recovery " ext4_msg(sb, KERN_ERR, "required journal recovery "
"suppressed and not mounted read-only\n"); "suppressed and not mounted read-only");
goto failed_mount4; goto failed_mount4;
} else { } else {
clear_opt(sbi->s_mount_opt, DATA_FLAGS); clear_opt(sbi->s_mount_opt, DATA_FLAGS);
...@@ -2726,7 +2734,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2726,7 +2734,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
if (ext4_blocks_count(es) > 0xffffffffULL && if (ext4_blocks_count(es) > 0xffffffffULL &&
!jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0, !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
JBD2_FEATURE_INCOMPAT_64BIT)) { JBD2_FEATURE_INCOMPAT_64BIT)) {
printk(KERN_ERR "EXT4-fs: Failed to set 64-bit journal feature\n"); ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature");
goto failed_mount4; goto failed_mount4;
} }
...@@ -2764,8 +2772,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2764,8 +2772,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
case EXT4_MOUNT_WRITEBACK_DATA: case EXT4_MOUNT_WRITEBACK_DATA:
if (!jbd2_journal_check_available_features if (!jbd2_journal_check_available_features
(sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) { (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
printk(KERN_ERR "EXT4-fs: Journal does not support " ext4_msg(sb, KERN_ERR, "Journal does not support "
"requested data journaling mode\n"); "requested data journaling mode");
goto failed_mount4; goto failed_mount4;
} }
default: default:
...@@ -2777,8 +2785,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2777,8 +2785,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
if (test_opt(sb, NOBH)) { if (test_opt(sb, NOBH)) {
if (!(test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)) { if (!(test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)) {
printk(KERN_WARNING "EXT4-fs: Ignoring nobh option - " ext4_msg(sb, KERN_WARNING, "Ignoring nobh option - "
"its supported only with writeback mode\n"); "its supported only with writeback mode");
clear_opt(sbi->s_mount_opt, NOBH); clear_opt(sbi->s_mount_opt, NOBH);
} }
} }
...@@ -2789,18 +2797,18 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2789,18 +2797,18 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
root = ext4_iget(sb, EXT4_ROOT_INO); root = ext4_iget(sb, EXT4_ROOT_INO);
if (IS_ERR(root)) { if (IS_ERR(root)) {
printk(KERN_ERR "EXT4-fs: get root inode failed\n"); ext4_msg(sb, KERN_ERR, "get root inode failed");
ret = PTR_ERR(root); ret = PTR_ERR(root);
goto failed_mount4; goto failed_mount4;
} }
if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) { if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
iput(root); iput(root);
printk(KERN_ERR "EXT4-fs: corrupt root inode, run e2fsck\n"); ext4_msg(sb, KERN_ERR, "corrupt root inode, run e2fsck");
goto failed_mount4; goto failed_mount4;
} }
sb->s_root = d_alloc_root(root); sb->s_root = d_alloc_root(root);
if (!sb->s_root) { if (!sb->s_root) {
printk(KERN_ERR "EXT4-fs: get root dentry failed\n"); ext4_msg(sb, KERN_ERR, "get root dentry failed");
iput(root); iput(root);
ret = -ENOMEM; ret = -ENOMEM;
goto failed_mount4; goto failed_mount4;
...@@ -2829,20 +2837,20 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2829,20 +2837,20 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
sbi->s_inode_size) { sbi->s_inode_size) {
sbi->s_want_extra_isize = sizeof(struct ext4_inode) - sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
EXT4_GOOD_OLD_INODE_SIZE; EXT4_GOOD_OLD_INODE_SIZE;
printk(KERN_INFO "EXT4-fs: required extra inode space not" ext4_msg(sb, KERN_INFO, "required extra inode space not"
"available.\n"); "available");
} }
if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) { if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
printk(KERN_WARNING "EXT4-fs: Ignoring delalloc option - " ext4_msg(sb, KERN_WARNING, "Ignoring delalloc option - "
"requested data journaling mode\n"); "requested data journaling mode");
clear_opt(sbi->s_mount_opt, DELALLOC); clear_opt(sbi->s_mount_opt, DELALLOC);
} else if (test_opt(sb, DELALLOC)) } else if (test_opt(sb, DELALLOC))
printk(KERN_INFO "EXT4-fs: delayed allocation enabled\n"); ext4_msg(sb, KERN_INFO, "delayed allocation enabled");
err = ext4_setup_system_zone(sb); err = ext4_setup_system_zone(sb);
if (err) { if (err) {
printk(KERN_ERR "EXT4-fs: failed to initialize system " ext4_msg(sb, KERN_ERR, "failed to initialize system "
"zone (%d)\n", err); "zone (%d)\n", err);
goto failed_mount4; goto failed_mount4;
} }
...@@ -2850,7 +2858,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2850,7 +2858,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
ext4_ext_init(sb); ext4_ext_init(sb);
err = ext4_mb_init(sb, needs_recovery); err = ext4_mb_init(sb, needs_recovery);
if (err) { if (err) {
printk(KERN_ERR "EXT4-fs: failed to initalize mballoc (%d)\n", ext4_msg(sb, KERN_ERR, "failed to initalize mballoc (%d)",
err); err);
goto failed_mount4; goto failed_mount4;
} }
...@@ -2869,7 +2877,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2869,7 +2877,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
ext4_orphan_cleanup(sb, es); ext4_orphan_cleanup(sb, es);
EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS; EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
if (needs_recovery) { if (needs_recovery) {
printk(KERN_INFO "EXT4-fs: recovery complete.\n"); ext4_msg(sb, KERN_INFO, "recovery complete");
ext4_mark_recovery_complete(sb, es); ext4_mark_recovery_complete(sb, es);
} }
if (EXT4_SB(sb)->s_journal) { if (EXT4_SB(sb)->s_journal) {
...@@ -2882,20 +2890,18 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ...@@ -2882,20 +2890,18 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
} else } else
descr = "out journal"; descr = "out journal";
printk(KERN_INFO "EXT4-fs: mounted filesystem %s with%s\n", ext4_msg(sb, KERN_INFO, "mounted filesystem with%s", descr);
sb->s_id, descr);
lock_kernel(); lock_kernel();
return 0; return 0;
cantfind_ext4: cantfind_ext4:
if (!silent) if (!silent)
printk(KERN_ERR "VFS: Can't find ext4 filesystem on dev %s.\n", ext4_msg(sb, KERN_ERR, "VFS: Can't find ext4 filesystem");
sb->s_id);
goto failed_mount; goto failed_mount;
failed_mount4: failed_mount4:
printk(KERN_ERR "EXT4-fs (device %s): mount failed\n", sb->s_id); ext4_msg(sb, KERN_ERR, "mount failed");
ext4_release_system_zone(sb); ext4_release_system_zone(sb);
if (sbi->s_journal) { if (sbi->s_journal) {
jbd2_journal_destroy(sbi->s_journal); jbd2_journal_destroy(sbi->s_journal);
...@@ -2973,27 +2979,27 @@ static journal_t *ext4_get_journal(struct super_block *sb, ...@@ -2973,27 +2979,27 @@ static journal_t *ext4_get_journal(struct super_block *sb,
journal_inode = ext4_iget(sb, journal_inum); journal_inode = ext4_iget(sb, journal_inum);
if (IS_ERR(journal_inode)) { if (IS_ERR(journal_inode)) {
printk(KERN_ERR "EXT4-fs: no journal found.\n"); ext4_msg(sb, KERN_ERR, "no journal found");
return NULL; return NULL;
} }
if (!journal_inode->i_nlink) { if (!journal_inode->i_nlink) {
make_bad_inode(journal_inode); make_bad_inode(journal_inode);
iput(journal_inode); iput(journal_inode);
printk(KERN_ERR "EXT4-fs: journal inode is deleted.\n"); ext4_msg(sb, KERN_ERR, "journal inode is deleted");
return NULL; return NULL;
} }
jbd_debug(2, "Journal inode found at %p: %lld bytes\n", jbd_debug(2, "Journal inode found at %p: %lld bytes\n",
journal_inode, journal_inode->i_size); journal_inode, journal_inode->i_size);
if (!S_ISREG(journal_inode->i_mode)) { if (!S_ISREG(journal_inode->i_mode)) {
printk(KERN_ERR "EXT4-fs: invalid journal inode.\n"); ext4_msg(sb, KERN_ERR, "invalid journal inode");
iput(journal_inode); iput(journal_inode);
return NULL; return NULL;
} }
journal = jbd2_journal_init_inode(journal_inode); journal = jbd2_journal_init_inode(journal_inode);
if (!journal) { if (!journal) {
printk(KERN_ERR "EXT4-fs: Could not load journal inode\n"); ext4_msg(sb, KERN_ERR, "Could not load journal inode");
iput(journal_inode); iput(journal_inode);
return NULL; return NULL;
} }
...@@ -3017,13 +3023,13 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb, ...@@ -3017,13 +3023,13 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)); BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL));
bdev = ext4_blkdev_get(j_dev); bdev = ext4_blkdev_get(j_dev, sb);
if (bdev == NULL) if (bdev == NULL)
return NULL; return NULL;
if (bd_claim(bdev, sb)) { if (bd_claim(bdev, sb)) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: failed to claim external journal device.\n"); "failed to claim external journal device");
blkdev_put(bdev, FMODE_READ|FMODE_WRITE); blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
return NULL; return NULL;
} }
...@@ -3031,8 +3037,8 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb, ...@@ -3031,8 +3037,8 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
blocksize = sb->s_blocksize; blocksize = sb->s_blocksize;
hblock = bdev_hardsect_size(bdev); hblock = bdev_hardsect_size(bdev);
if (blocksize < hblock) { if (blocksize < hblock) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: blocksize too small for journal device.\n"); "blocksize too small for journal device");
goto out_bdev; goto out_bdev;
} }
...@@ -3040,8 +3046,8 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb, ...@@ -3040,8 +3046,8 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
offset = EXT4_MIN_BLOCK_SIZE % blocksize; offset = EXT4_MIN_BLOCK_SIZE % blocksize;
set_blocksize(bdev, blocksize); set_blocksize(bdev, blocksize);
if (!(bh = __bread(bdev, sb_block, blocksize))) { if (!(bh = __bread(bdev, sb_block, blocksize))) {
printk(KERN_ERR "EXT4-fs: couldn't read superblock of " ext4_msg(sb, KERN_ERR, "couldn't read superblock of "
"external journal\n"); "external journal");
goto out_bdev; goto out_bdev;
} }
...@@ -3049,14 +3055,14 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb, ...@@ -3049,14 +3055,14 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) || if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
!(le32_to_cpu(es->s_feature_incompat) & !(le32_to_cpu(es->s_feature_incompat) &
EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) { EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
printk(KERN_ERR "EXT4-fs: external journal has " ext4_msg(sb, KERN_ERR, "external journal has "
"bad superblock\n"); "bad superblock");
brelse(bh); brelse(bh);
goto out_bdev; goto out_bdev;
} }
if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) { if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
printk(KERN_ERR "EXT4-fs: journal UUID does not match\n"); ext4_msg(sb, KERN_ERR, "journal UUID does not match");
brelse(bh); brelse(bh);
goto out_bdev; goto out_bdev;
} }
...@@ -3068,19 +3074,19 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb, ...@@ -3068,19 +3074,19 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
journal = jbd2_journal_init_dev(bdev, sb->s_bdev, journal = jbd2_journal_init_dev(bdev, sb->s_bdev,
start, len, blocksize); start, len, blocksize);
if (!journal) { if (!journal) {
printk(KERN_ERR "EXT4-fs: failed to create device journal\n"); ext4_msg(sb, KERN_ERR, "failed to create device journal");
goto out_bdev; goto out_bdev;
} }
journal->j_private = sb; journal->j_private = sb;
ll_rw_block(READ, 1, &journal->j_sb_buffer); ll_rw_block(READ, 1, &journal->j_sb_buffer);
wait_on_buffer(journal->j_sb_buffer); wait_on_buffer(journal->j_sb_buffer);
if (!buffer_uptodate(journal->j_sb_buffer)) { if (!buffer_uptodate(journal->j_sb_buffer)) {
printk(KERN_ERR "EXT4-fs: I/O error on journal device\n"); ext4_msg(sb, KERN_ERR, "I/O error on journal device");
goto out_journal; goto out_journal;
} }
if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) { if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
printk(KERN_ERR "EXT4-fs: External journal has more than one " ext4_msg(sb, KERN_ERR, "External journal has more than one "
"user (unsupported) - %d\n", "user (unsupported) - %d",
be32_to_cpu(journal->j_superblock->s_nr_users)); be32_to_cpu(journal->j_superblock->s_nr_users));
goto out_journal; goto out_journal;
} }
...@@ -3109,8 +3115,8 @@ static int ext4_load_journal(struct super_block *sb, ...@@ -3109,8 +3115,8 @@ static int ext4_load_journal(struct super_block *sb,
if (journal_devnum && if (journal_devnum &&
journal_devnum != le32_to_cpu(es->s_journal_dev)) { journal_devnum != le32_to_cpu(es->s_journal_dev)) {
printk(KERN_INFO "EXT4-fs: external journal device major/minor " ext4_msg(sb, KERN_INFO, "external journal device major/minor "
"numbers have changed\n"); "numbers have changed");
journal_dev = new_decode_dev(journal_devnum); journal_dev = new_decode_dev(journal_devnum);
} else } else
journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev)); journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
...@@ -3124,21 +3130,21 @@ static int ext4_load_journal(struct super_block *sb, ...@@ -3124,21 +3130,21 @@ static int ext4_load_journal(struct super_block *sb,
*/ */
if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) { if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
if (sb->s_flags & MS_RDONLY) { if (sb->s_flags & MS_RDONLY) {
printk(KERN_INFO "EXT4-fs: INFO: recovery " ext4_msg(sb, KERN_INFO, "INFO: recovery "
"required on readonly filesystem.\n"); "required on readonly filesystem");
if (really_read_only) { if (really_read_only) {
printk(KERN_ERR "EXT4-fs: write access " ext4_msg(sb, KERN_ERR, "write access "
"unavailable, cannot proceed.\n"); "unavailable, cannot proceed");
return -EROFS; return -EROFS;
} }
printk(KERN_INFO "EXT4-fs: write access will " ext4_msg(sb, KERN_INFO, "write access will "
"be enabled during recovery.\n"); "be enabled during recovery");
} }
} }
if (journal_inum && journal_dev) { if (journal_inum && journal_dev) {
printk(KERN_ERR "EXT4-fs: filesystem has both journal " ext4_msg(sb, KERN_ERR, "filesystem has both journal "
"and inode journals!\n"); "and inode journals!");
return -EINVAL; return -EINVAL;
} }
...@@ -3151,14 +3157,14 @@ static int ext4_load_journal(struct super_block *sb, ...@@ -3151,14 +3157,14 @@ static int ext4_load_journal(struct super_block *sb,
} }
if (journal->j_flags & JBD2_BARRIER) if (journal->j_flags & JBD2_BARRIER)
printk(KERN_INFO "EXT4-fs: barriers enabled\n"); ext4_msg(sb, KERN_INFO, "barriers enabled");
else else
printk(KERN_INFO "EXT4-fs: barriers disabled\n"); ext4_msg(sb, KERN_INFO, "barriers disabled");
if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) { if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
err = jbd2_journal_update_format(journal); err = jbd2_journal_update_format(journal);
if (err) { if (err) {
printk(KERN_ERR "EXT4-fs: error updating journal.\n"); ext4_msg(sb, KERN_ERR, "error updating journal");
jbd2_journal_destroy(journal); jbd2_journal_destroy(journal);
return err; return err;
} }
...@@ -3170,7 +3176,7 @@ static int ext4_load_journal(struct super_block *sb, ...@@ -3170,7 +3176,7 @@ static int ext4_load_journal(struct super_block *sb,
err = jbd2_journal_load(journal); err = jbd2_journal_load(journal);
if (err) { if (err) {
printk(KERN_ERR "EXT4-fs: error loading journal.\n"); ext4_msg(sb, KERN_ERR, "error loading journal");
jbd2_journal_destroy(journal); jbd2_journal_destroy(journal);
return err; return err;
} }
...@@ -3206,8 +3212,8 @@ static int ext4_commit_super(struct super_block *sb, int sync) ...@@ -3206,8 +3212,8 @@ static int ext4_commit_super(struct super_block *sb, int sync)
* be remapped. Nothing we can do but to retry the * be remapped. Nothing we can do but to retry the
* write and hope for the best. * write and hope for the best.
*/ */
printk(KERN_ERR "EXT4-fs: previous I/O error to " ext4_msg(sb, KERN_ERR, "previous I/O error to "
"superblock detected for %s.\n", sb->s_id); "superblock detected");
clear_buffer_write_io_error(sbh); clear_buffer_write_io_error(sbh);
set_buffer_uptodate(sbh); set_buffer_uptodate(sbh);
} }
...@@ -3230,8 +3236,8 @@ static int ext4_commit_super(struct super_block *sb, int sync) ...@@ -3230,8 +3236,8 @@ static int ext4_commit_super(struct super_block *sb, int sync)
error = buffer_write_io_error(sbh); error = buffer_write_io_error(sbh);
if (error) { if (error) {
printk(KERN_ERR "EXT4-fs: I/O error while writing " ext4_msg(sb, KERN_ERR, "I/O error while writing "
"superblock for %s.\n", sb->s_id); "superblock");
clear_buffer_write_io_error(sbh); clear_buffer_write_io_error(sbh);
set_buffer_uptodate(sbh); set_buffer_uptodate(sbh);
} }
...@@ -3478,9 +3484,9 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) ...@@ -3478,9 +3484,9 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
int ret; int ret;
if ((ret = EXT4_HAS_RO_COMPAT_FEATURE(sb, if ((ret = EXT4_HAS_RO_COMPAT_FEATURE(sb,
~EXT4_FEATURE_RO_COMPAT_SUPP))) { ~EXT4_FEATURE_RO_COMPAT_SUPP))) {
printk(KERN_WARNING "EXT4-fs: %s: couldn't " ext4_msg(sb, KERN_WARNING, "couldn't "
"remount RDWR because of unsupported " "remount RDWR because of unsupported "
"optional features (%x).\n", sb->s_id, "optional features (%x)",
(le32_to_cpu(sbi->s_es->s_feature_ro_compat) & (le32_to_cpu(sbi->s_es->s_feature_ro_compat) &
~EXT4_FEATURE_RO_COMPAT_SUPP)); ~EXT4_FEATURE_RO_COMPAT_SUPP));
err = -EROFS; err = -EROFS;
...@@ -3496,9 +3502,8 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) ...@@ -3496,9 +3502,8 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
ext4_get_group_desc(sb, g, NULL); ext4_get_group_desc(sb, g, NULL);
if (!ext4_group_desc_csum_verify(sbi, g, gdp)) { if (!ext4_group_desc_csum_verify(sbi, g, gdp)) {
printk(KERN_ERR ext4_msg(sb, KERN_ERR,
"EXT4-fs: ext4_remount: " "ext4_remount: Checksum for group %u failed (%u!=%u)",
"Checksum for group %u failed (%u!=%u)\n",
g, le16_to_cpu(ext4_group_desc_csum(sbi, g, gdp)), g, le16_to_cpu(ext4_group_desc_csum(sbi, g, gdp)),
le16_to_cpu(gdp->bg_checksum)); le16_to_cpu(gdp->bg_checksum));
err = -EINVAL; err = -EINVAL;
...@@ -3512,11 +3517,10 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) ...@@ -3512,11 +3517,10 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
* require a full umount/remount for now. * require a full umount/remount for now.
*/ */
if (es->s_last_orphan) { if (es->s_last_orphan) {
printk(KERN_WARNING "EXT4-fs: %s: couldn't " ext4_msg(sb, KERN_WARNING, "Couldn't "
"remount RDWR because of unprocessed " "remount RDWR because of unprocessed "
"orphan inode list. Please " "orphan inode list. Please "
"umount/remount instead.\n", "umount/remount instead");
sb->s_id);
err = -EINVAL; err = -EINVAL;
goto restore_opts; goto restore_opts;
} }
...@@ -3772,9 +3776,9 @@ static int ext4_quota_on(struct super_block *sb, int type, int format_id, ...@@ -3772,9 +3776,9 @@ static int ext4_quota_on(struct super_block *sb, int type, int format_id,
if (EXT4_SB(sb)->s_qf_names[type]) { if (EXT4_SB(sb)->s_qf_names[type]) {
/* Quotafile not in fs root? */ /* Quotafile not in fs root? */
if (path.dentry->d_parent != sb->s_root) if (path.dentry->d_parent != sb->s_root)
printk(KERN_WARNING ext4_msg(sb, KERN_WARNING,
"EXT4-fs: Quota file not on filesystem root. " "Quota file not on filesystem root. "
"Journaled quota will not work.\n"); "Journaled quota will not work");
} }
/* /*
...@@ -3857,8 +3861,8 @@ static ssize_t ext4_quota_write(struct super_block *sb, int type, ...@@ -3857,8 +3861,8 @@ static ssize_t ext4_quota_write(struct super_block *sb, int type,
handle_t *handle = journal_current_handle(); handle_t *handle = journal_current_handle();
if (EXT4_SB(sb)->s_journal && !handle) { if (EXT4_SB(sb)->s_journal && !handle) {
printk(KERN_WARNING "EXT4-fs: Quota write (off=%llu, len=%llu)" ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
" cancelled because transaction is not started.\n", " cancelled because transaction is not started",
(unsigned long long)off, (unsigned long long)len); (unsigned long long)off, (unsigned long long)len);
return -EIO; return -EIO;
} }
...@@ -3930,10 +3934,10 @@ static struct file_system_type ext4_fs_type = { ...@@ -3930,10 +3934,10 @@ static struct file_system_type ext4_fs_type = {
static int ext4dev_get_sb(struct file_system_type *fs_type, int flags, static int ext4dev_get_sb(struct file_system_type *fs_type, int flags,
const char *dev_name, void *data,struct vfsmount *mnt) const char *dev_name, void *data,struct vfsmount *mnt)
{ {
printk(KERN_WARNING "EXT4-fs: Update your userspace programs " printk(KERN_WARNING "EXT4-fs (%s): Update your userspace programs "
"to mount using ext4\n"); "to mount using ext4\n", dev_name);
printk(KERN_WARNING "EXT4-fs: ext4dev backwards compatibility " printk(KERN_WARNING "EXT4-fs (%s): ext4dev backwards compatibility "
"will go away by 2.6.31\n"); "will go away by 2.6.31\n", dev_name);
return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super,mnt); return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super,mnt);
} }
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或