LinuxLists.cc - [PATCH] ext4: Fix incorrect group count in ext4_fill

2020-03-28 21:54:52

Subject: [PATCH] ext4: Fix incorrect group count in ext4_fill_super error message

ext4_fill_super doublechecks the number of groups before mounting; if
that check fails, the resulting error message prints the group count
from the ext4_sb_info sbi, which hasn't been set yet. Print the freshly
computed group count instead (which at that point has just been computed
in "blocks_count").

Signed-off-by: Josh Triplett <[email protected]>
Fixes: 4ec1102813798 ("ext4: Add sanity checks for the superblock before mounting the filesystem")
---
fs/ext4/super.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 0c7c4adb664e..7f5f37653a03 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -4288,7 +4288,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
ext4_msg(sb, KERN_WARNING, "groups count too large: %u "
"(block count %llu, first data block %u, "
- "blocks per group %lu)", sbi->s_groups_count,
+ "blocks per group %lu)", blocks_count,
ext4_blocks_count(es),
le32_to_cpu(es->s_first_data_block),
EXT4_BLOCKS_PER_GROUP(sb));
--
2.26.0

2020-03-28 22:45:19

by kernel test robot

[permalink] [raw]

Subject: Re: [PATCH] ext4: Fix incorrect group count in ext4_fill_super error message

Hi Josh,

I love your patch!
[auto build test WARNING [also build test WARNING [if your patch is applied improve the system. base tree in git format-patch,
url: wget on ext4/dev]
on linus/master linux/master v5.6-rc7 next-20200327]
to the wrong git tree, please drop us a note to help
BTW, we also suggest to use '--base' option to specify the
please see https://stackoverflow.com/a/37406982]
thub.com/0day-ci/linux/commits/Josh-Triplett/ext4-Fix-incorrect-group-count-in-ext4_fill_super-error-message/20200329-055606">https://github.com/0day-ci/linux/commits/Josh-Triplett/ext4-Fix-incorrect-group-count-in-ext4_fill_super-error-message/20200329-055606
t.kernel.org/pub/scm/linux/kernel/git/tytso/ext4.git">https://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4.git dev
(attached as .config)
(GCC) 9.2.0
://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross">https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
attached .config to linux build tree
make.cross ARCH=sh
kindly add following tag
test robot <[email protected]>
prefixed by >>):
from fs/ext4/super.c:50:
In function 'ext4_fill_super':
warning: format '%u' expects argument of type 'unsigned int', but argument 4 has type '__u64' {aka 'long long unsigned int'} [-Wformat=]
KERN_WARNING, "groups count too large: %u "
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
"(block count %llu, first data block %u, "
"blocks per group %lu)", blocks_count,
~~~~~~~~~~~~
|
__u64 {aka long long unsigned int}
note: in definition of macro 'ext4_msg'
level, fmt, ##__VA_ARGS__)
^~~
note: format string is defined here
KERN_WARNING, "groups count too large: %u "
~^
|
unsigned int
%llu
Krisman Bertazi 2019-04-25 3972
2011-09-03 3973 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
2020-01-23 3974 printk_once(KERN_WARNING "EXT4-fs: Warning: mounting with data=journal disables delayed allocation, dioread_nolock, and O_DIRECT support!\n");
2020-01-23 3975 clear_opt(sb, DIOREAD_NOLOCK);
2011-09-03 3976 if (test_opt2(sb, EXPLICIT_DELALLOC)) {
2011-09-03 3977 ext4_msg(sb, KERN_ERR, "can't mount with "
2011-09-03 3978 "both data=journal and delalloc");
2011-09-03 3979 goto failed_mount;
2011-09-03 3980 }
2011-09-03 3981 if (test_opt(sb, DIOREAD_NOLOCK)) {
2011-09-03 3982 ext4_msg(sb, KERN_ERR, "can't mount with "
2013-08-08 3983 "both data=journal and dioread_nolock");
2011-09-03 3984 goto failed_mount;
2011-09-03 3985 }
2015-02-16 3986 if (test_opt(sb, DAX)) {
2015-02-16 3987 ext4_msg(sb, KERN_ERR, "can't mount with "
2015-02-16 3988 "both data=journal and dax");
2015-02-16 3989 goto failed_mount;
2015-02-16 3990 }
2016-12-10 3991 if (ext4_has_feature_encrypt(sb)) {
2016-12-10 3992 ext4_msg(sb, KERN_WARNING,
2016-12-10 3993 "encrypted files will use data=ordered "
2016-12-10 3994 "instead of data journaling mode");
2016-12-10 3995 }
2011-09-03 3996 if (test_opt(sb, DELALLOC))
2011-09-03 3997 clear_opt(sb, DELALLOC);
2015-07-21 3998 } else {
2015-07-21 3999 sb->s_iflags |= SB_I_CGROUPWB;
2011-09-03 4000 }
2011-09-03 4001
2017-11-27 4002 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
2017-11-27 4003 (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
2006-10-11 4004
2006-10-11 4005 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
2015-10-17 4006 (ext4_has_compat_features(sb) ||
2015-10-17 4007 ext4_has_ro_compat_features(sb) ||
2015-10-17 4008 ext4_has_incompat_features(sb)))
2009-06-04 4009 ext4_msg(sb, KERN_WARNING,
2009-06-04 4010 "feature flags set on rev 0 fs, "
2009-06-04 4011 "running e2fsck is recommended");
2008-02-10 4012
2014-03-24 4013 if (es->s_creator_os == cpu_to_le32(EXT4_OS_HURD)) {
2014-03-24 4014 set_opt2(sb, HURD_COMPAT);
2015-10-17 4015 if (ext4_has_feature_64bit(sb)) {
2014-03-24 4016 ext4_msg(sb, KERN_ERR,
2014-03-24 4017 "The Hurd can't support 64-bit file systems");
2014-03-24 4018 goto failed_mount;
2014-03-24 4019 }
2017-06-22 4020
2017-06-22 4021 /*
2017-06-22 4022 * ea_inode feature uses l_i_version field which is not
2017-06-22 4023 * available in HURD_COMPAT mode.
2017-06-22 4024 */
2017-06-22 4025 if (ext4_has_feature_ea_inode(sb)) {
2017-06-22 4026 ext4_msg(sb, KERN_ERR,
2017-06-22 4027 "ea_inode feature is not supported for Hurd");
2017-06-22 4028 goto failed_mount;
2017-06-22 4029 }
2014-03-24 4030 }
2014-03-24 4031
2011-04-18 4032 if (IS_EXT2_SB(sb)) {
2011-04-18 4033 if (ext2_feature_set_ok(sb))
2011-04-18 4034 ext4_msg(sb, KERN_INFO, "mounting ext2 file system "
2011-04-18 4035 "using the ext4 subsystem");
2011-04-18 4036 else {
2018-03-22 4037 /*
2018-03-22 4038 * If we're probing be silent, if this looks like
2018-03-22 4039 * it's actually an ext[34] filesystem.
2018-03-22 4040 */
2018-03-22 4041 if (silent && ext4_feature_set_ok(sb, sb_rdonly(sb)))
2018-03-22 4042 goto failed_mount;
2011-04-18 4043 ext4_msg(sb, KERN_ERR, "couldn't mount as ext2 due "
2011-04-18 4044 "to feature incompatibilities");
2011-04-18 4045 goto failed_mount;
2011-04-18 4046 }
2011-04-18 4047 }
2011-04-18 4048
2011-04-18 4049 if (IS_EXT3_SB(sb)) {
2011-04-18 4050 if (ext3_feature_set_ok(sb))
2011-04-18 4051 ext4_msg(sb, KERN_INFO, "mounting ext3 file system "
2011-04-18 4052 "using the ext4 subsystem");
2011-04-18 4053 else {
2018-03-22 4054 /*
2018-03-22 4055 * If we're probing be silent, if this looks like
2018-03-22 4056 * it's actually an ext4 filesystem.
2018-03-22 4057 */
2018-03-22 4058 if (silent && ext4_feature_set_ok(sb, sb_rdonly(sb)))
2018-03-22 4059 goto failed_mount;
2011-04-18 4060 ext4_msg(sb, KERN_ERR, "couldn't mount as ext3 due "
2011-04-18 4061 "to feature incompatibilities");
2011-04-18 4062 goto failed_mount;
2011-04-18 4063 }
2011-04-18 4064 }
2011-04-18 4065
2006-10-11 4066 /*
2006-10-11 4067 * Check feature flags regardless of the revision level, since we
2006-10-11 4068 * previously didn't change the revision level when setting the flags,
2006-10-11 4069 * so there is a chance incompat flags are set on a rev 0 filesystem.
2006-10-11 4070 */
2017-07-17 4071 if (!ext4_feature_set_ok(sb, (sb_rdonly(sb))))
2006-10-11 4072 goto failed_mount;
2009-08-18 4073
2016-11-18 4074 if (le32_to_cpu(es->s_log_block_size) >
2016-11-18 4075 (EXT4_MAX_BLOCK_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
2016-11-18 4076 ext4_msg(sb, KERN_ERR,
2016-11-18 4077 "Invalid log block size: %u",
2016-11-18 4078 le32_to_cpu(es->s_log_block_size));
2006-10-11 4079 goto failed_mount;
2006-10-11 4080 }
2018-06-17 4081 if (le32_to_cpu(es->s_log_cluster_size) >
2018-06-17 4082 (EXT4_MAX_CLUSTER_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
2018-06-17 4083 ext4_msg(sb, KERN_ERR,
2018-06-17 4084 "Invalid log cluster size: %u",
2018-06-17 4085 le32_to_cpu(es->s_log_cluster_size));
2018-06-17 4086 goto failed_mount;
2018-06-17 4087 }
2006-10-11 4088
2016-07-05 4089 if (le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) > (blocksize / 4)) {
2016-07-05 4090 ext4_msg(sb, KERN_ERR,
2016-07-05 4091 "Number of reserved GDT blocks insanely large: %d",
2016-07-05 4092 le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks));
2016-07-05 4093 goto failed_mount;
2016-07-05 4094 }
2016-07-05 4095
2015-02-16 4096 if (sbi->s_mount_opt & EXT4_MOUNT_DAX) {
2017-10-12 4097 if (ext4_has_feature_inline_data(sb)) {
2017-10-12 4098 ext4_msg(sb, KERN_ERR, "Cannot use DAX on a filesystem"
2017-10-12 4099 " that may contain inline data");
2018-12-04 4100 goto failed_mount;
2017-10-12 4101 }
2018-05-30 4102 if (!bdev_dax_supported(sb->s_bdev, blocksize)) {
2017-12-21 4103 ext4_msg(sb, KERN_ERR,
2018-12-04 4104 "DAX unsupported by block device.");
2018-12-04 4105 goto failed_mount;
2017-12-21 4106 }
2015-02-16 4107 }
2015-02-16 4108
2015-10-17 4109 if (ext4_has_feature_encrypt(sb) && es->s_encryption_level) {
2015-04-16 4110 ext4_msg(sb, KERN_ERR, "Unsupported encryption level %d",
2015-04-16 4111 es->s_encryption_level);
2015-04-16 4112 goto failed_mount;
2015-04-16 4113 }
2015-04-16 4114
2006-10-11 4115 if (sb->s_blocksize != blocksize) {
2008-01-28 4116 /* Validate the filesystem blocksize */
2008-01-28 4117 if (!sb_set_blocksize(sb, blocksize)) {
2009-06-04 4118 ext4_msg(sb, KERN_ERR, "bad block size %d",
2008-01-28 4119 blocksize);
2006-10-11 4120 goto failed_mount;
2006-10-11 4121 }
2006-10-11 4122
2006-10-11 4123 brelse(bh);
2006-10-11 4124 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
2006-10-11 4125 offset = do_div(logical_sb_block, blocksize);
2014-09-04 4126 bh = sb_bread_unmovable(sb, logical_sb_block);
2006-10-11 4127 if (!bh) {
2009-06-04 4128 ext4_msg(sb, KERN_ERR,
2009-06-04 4129 "Can't read superblock on 2nd try");
2006-10-11 4130 goto failed_mount;
2006-10-11 4131 }
2012-05-28 4132 es = (struct ext4_super_block *)(bh->b_data + offset);
2006-10-11 4133 sbi->s_es = es;
2006-10-11 4134 if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
2009-06-04 4135 ext4_msg(sb, KERN_ERR,
2009-06-04 4136 "Magic mismatch, very weird!");
2006-10-11 4137 goto failed_mount;
2006-10-11 4138 }
2006-10-11 4139 }
2006-10-11 4140
2015-10-17 4141 has_huge_files = ext4_has_feature_huge_file(sb);
2008-10-16 4142 sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(sb->s_blocksize_bits,
2008-10-16 4143 has_huge_files);
2008-10-16 4144 sb->s_maxbytes = ext4_max_size(sb->s_blocksize_bits, has_huge_files);
2006-10-11 4145
2006-10-11 4146 sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
2015-10-17 4147 if (ext4_has_feature_64bit(sb)) {
2006-10-11 4148 if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
2006-10-11 4149 sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
2007-10-16 4150 !is_power_of_2(sbi->s_desc_size)) {
2009-06-04 4151 ext4_msg(sb, KERN_ERR,
2009-06-04 4152 "unsupported descriptor size %lu",
2006-10-11 4153 sbi->s_desc_size);
2006-10-11 4154 goto failed_mount;
2006-10-11 4155 }
2006-10-11 4156 } else
2006-10-11 4157 sbi->s_desc_size = EXT4_MIN_DESC_SIZE;
2009-06-03 4158
2006-10-11 4159 sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
2006-10-11 4160 sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
2009-06-03 4161
2006-10-11 4162 sbi->s_inodes_per_block = blocksize / EXT4_INODE_SIZE(sb);
2006-10-11 4163 if (sbi->s_inodes_per_block == 0)
2006-10-11 4164 goto cantfind_ext4;
2016-11-18 4165 if (sbi->s_inodes_per_group < sbi->s_inodes_per_block ||
2016-11-18 4166 sbi->s_inodes_per_group > blocksize * 8) {
2016-11-18 4167 ext4_msg(sb, KERN_ERR, "invalid inodes per group: %lu\n",
2016-11-18 4168 sbi->s_blocks_per_group);
2016-11-18 4169 goto failed_mount;
2016-11-18 4170 }
2006-10-11 4171 sbi->s_itb_per_group = sbi->s_inodes_per_group /
2006-10-11 4172 sbi->s_inodes_per_block;
2006-10-11 4173 sbi->s_desc_per_block = blocksize / EXT4_DESC_SIZE(sb);
2006-10-11 4174 sbi->s_sbh = bh;
2006-10-11 4175 sbi->s_mount_state = le16_to_cpu(es->s_state);
2007-10-16 4176 sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
2007-10-16 4177 sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
2009-06-03 4178
2006-10-11 4179 for (i = 0; i < 4; i++)
2006-10-11 4180 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
2006-10-11 4181 sbi->s_def_hash_version = es->s_def_hash_version;
2015-10-17 4182 if (ext4_has_feature_dir_index(sb)) {
2008-10-28 4183 i = le32_to_cpu(es->s_flags);
2008-10-28 4184 if (i & EXT2_FLAGS_UNSIGNED_HASH)
2008-10-28 4185 sbi->s_hash_unsigned = 3;
2008-10-28 4186 else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
2008-10-28 4187 #ifdef __CHAR_UNSIGNED__
2017-07-17 4188 if (!sb_rdonly(sb))
2014-02-12 4189 es->s_flags |=
2014-02-12 4190 cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
2008-10-28 4191 sbi->s_hash_unsigned = 3;
2008-10-28 4192 #else
2017-07-17 4193 if (!sb_rdonly(sb))
2014-02-12 4194 es->s_flags |=
2014-02-12 4195 cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
2008-10-28 4196 #endif
2008-10-28 4197 }
2014-02-12 4198 }
2006-10-11 4199
2011-09-09 4200 /* Handle clustersize */
2011-09-09 4201 clustersize = BLOCK_SIZE << le32_to_cpu(es->s_log_cluster_size);
2015-10-17 4202 has_bigalloc = ext4_has_feature_bigalloc(sb);
2011-09-09 4203 if (has_bigalloc) {
2011-09-09 4204 if (clustersize < blocksize) {
2011-09-09 4205 ext4_msg(sb, KERN_ERR,
2011-09-09 4206 "cluster size (%d) smaller than "
2011-09-09 4207 "block size (%d)", clustersize, blocksize);
2011-09-09 4208 goto failed_mount;
2011-09-09 4209 }
2011-09-09 4210 sbi->s_cluster_bits = le32_to_cpu(es->s_log_cluster_size) -
2011-09-09 4211 le32_to_cpu(es->s_log_block_size);
2011-09-09 4212 sbi->s_clusters_per_group =
2011-09-09 4213 le32_to_cpu(es->s_clusters_per_group);
2011-09-09 4214 if (sbi->s_clusters_per_group > blocksize * 8) {
2011-09-09 4215 ext4_msg(sb, KERN_ERR,
2011-09-09 4216 "#clusters per group too big: %lu",
2011-09-09 4217 sbi->s_clusters_per_group);
2011-09-09 4218 goto failed_mount;
2011-09-09 4219 }
2011-09-09 4220 if (sbi->s_blocks_per_group !=
2011-09-09 4221 (sbi->s_clusters_per_group * (clustersize / blocksize))) {
2011-09-09 4222 ext4_msg(sb, KERN_ERR, "blocks per group (%lu) and "
2011-09-09 4223 "clusters per group (%lu) inconsistent",
2011-09-09 4224 sbi->s_blocks_per_group,
2011-09-09 4225 sbi->s_clusters_per_group);
2011-09-09 4226 goto failed_mount;
2011-09-09 4227 }
2011-09-09 4228 } else {
2011-09-09 4229 if (clustersize != blocksize) {
2018-06-17 4230 ext4_msg(sb, KERN_ERR,
2018-06-17 4231 "fragment/cluster size (%d) != "
2018-06-17 4232 "block size (%d)", clustersize, blocksize);
2018-06-17 4233 goto failed_mount;
2011-09-09 4234 }
2006-10-11 4235 if (sbi->s_blocks_per_group > blocksize * 8) {
2009-06-04 4236 ext4_msg(sb, KERN_ERR,
2009-06-04 4237 "#blocks per group too big: %lu",
2006-10-11 4238 sbi->s_blocks_per_group);
2006-10-11 4239 goto failed_mount;
2006-10-11 4240 }
2011-09-09 4241 sbi->s_clusters_per_group = sbi->s_blocks_per_group;
2011-09-09 4242 sbi->s_cluster_bits = 0;
2011-09-09 4243 }
2011-09-09 4244 sbi->s_cluster_ratio = clustersize / blocksize;
2011-09-09 4245
2013-07-05 4246 /* Do we have standard group size of clustersize * 8 blocks ? */
2013-07-05 4247 if (sbi->s_blocks_per_group == clustersize << 3)
2013-07-05 4248 set_opt2(sb, STD_GROUP_SIZE);
2013-07-05 4249
2009-08-17 4250 /*
2009-08-17 4251 * Test whether we have more sectors than will fit in sector_t,
2009-08-17 4252 * and whether the max offset is addressable by the page cache.
2009-08-17 4253 */
2010-11-19 4254 err = generic_check_addressable(sb->s_blocksize_bits,
2010-07-22 4255 ext4_blocks_count(es));
2010-11-19 4256 if (err) {
2009-06-04 4257 ext4_msg(sb, KERN_ERR, "filesystem"
2009-08-17 4258 " too large to mount safely on this system");
2006-10-11 4259 goto failed_mount;
2006-10-11 4260 }
2006-10-11 4261
2006-10-11 4262 if (EXT4_BLOCKS_PER_GROUP(sb) == 0)
2006-10-11 4263 goto cantfind_ext4;
2008-01-28 4264
2009-04-07 4265 /* check blocks count against device size */
2009-04-07 4266 blocks_count = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits;
2009-04-07 4267 if (blocks_count && ext4_blocks_count(es) > blocks_count) {
2009-06-04 4268 ext4_msg(sb, KERN_WARNING, "bad geometry: block count %llu "
2009-06-04 4269 "exceeds size of device (%llu blocks)",
2009-04-07 4270 ext4_blocks_count(es), blocks_count);
2009-04-07 4271 goto failed_mount;
2009-04-07 4272 }
2009-04-07 4273
2009-01-06 4274 /*
2009-01-06 4275 * It makes no sense for the first data block to be beyond the end
2009-01-06 4276 * of the filesystem.
2009-01-06 4277 */
2009-01-06 4278 if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
2009-06-04 4279 ext4_msg(sb, KERN_WARNING, "bad geometry: first data "
2009-06-04 4280 "block %u is beyond end of filesystem (%llu)",
2008-01-28 4281 le32_to_cpu(es->s_first_data_block),
2009-01-06 4282 ext4_blocks_count(es));
2008-01-28 4283 goto failed_mount;
2008-01-28 4284 }
2018-06-17 4285 if ((es->s_first_data_block == 0) && (es->s_log_block_size == 0) &&
2018-06-17 4286 (sbi->s_cluster_ratio == 1)) {
2018-06-17 4287 ext4_msg(sb, KERN_WARNING, "bad geometry: first data "
2018-06-17 4288 "block is 0 with a 1k block and cluster size");
2018-06-17 4289 goto failed_mount;
2018-06-17 4290 }
2018-06-17 4291
2006-10-11 4292 blocks_count = (ext4_blocks_count(es) -
2006-10-11 4293 le32_to_cpu(es->s_first_data_block) +
2006-10-11 4294 EXT4_BLOCKS_PER_GROUP(sb) - 1);
2006-10-11 4295 do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
2009-01-06 4296 if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
2009-06-04 @4297 ext4_msg(sb, KERN_WARNING, "groups count too large: %u "
2009-01-06 4298 "(block count %llu, first data block %u, "
2020-03-28 4299 "blocks per group %lu)", blocks_count,
2009-01-06 4300 ext4_blocks_count(es),
2009-01-06 4301 le32_to_cpu(es->s_first_data_block),
2009-01-06 4302 EXT4_BLOCKS_PER_GROUP(sb));
2009-01-06 4303 goto failed_mount;
2009-01-06 4304 }
2006-10-11 4305 sbi->s_groups_count = blocks_count;
2009-09-16 4306 sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count,
2009-09-16 4307 (EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb)));
2018-11-07 4308 if (((u64)sbi->s_groups_count * sbi->s_inodes_per_group) !=
2018-11-07 4309 le32_to_cpu(es->s_inodes_count)) {
2018-11-07 4310 ext4_msg(sb, KERN_ERR, "inodes count not valid: %u vs %llu",
2018-11-07 4311 le32_to_cpu(es->s_inodes_count),
2018-11-07 4312 ((u64)sbi->s_groups_count * sbi->s_inodes_per_group));
2018-11-07 4313 ret = -EINVAL;
2018-11-07 4314 goto failed_mount;
2018-11-07 4315 }
2006-10-11 4316 db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
2006-10-11 4317 EXT4_DESC_PER_BLOCK(sb);
2016-12-01 4318 if (ext4_has_feature_meta_bg(sb)) {
2017-02-15 4319 if (le32_to_cpu(es->s_first_meta_bg) > db_count) {
2016-12-01 4320 ext4_msg(sb, KERN_WARNING,
2016-12-01 4321 "first meta block group too large: %u "
2016-12-01 4322 "(group descriptor block count %u)",
2016-12-01 4323 le32_to_cpu(es->s_first_meta_bg), db_count);
2016-12-01 4324 goto failed_mount;
2016-12-01 4325 }
2016-12-01 4326 }
2020-02-15 4327 rcu_assign_pointer(sbi->s_group_desc,
2020-02-15 4328 kvmalloc_array(db_count,
2011-08-01 4329 sizeof(struct buffer_head *),
2020-02-15 4330 GFP_KERNEL));
2006-10-11 4331 if (sbi->s_group_desc == NULL) {
2009-06-04 4332 ext4_msg(sb, KERN_ERR, "not enough memory");
2012-05-28 4333 ret = -ENOMEM;
2006-10-11 4334 goto failed_mount;
2006-10-11 4335 }
2006-10-11 4336
2009-02-15 4337 bgl_lock_init(sbi->s_blockgroup_lock);
2006-10-11 4338
2017-04-30 4339 /* Pre-read the descriptors into the buffer cache */
2017-04-30 4340 for (i = 0; i < db_count; i++) {
2017-04-30 4341 block = descriptor_loc(sb, logical_sb_block, i);
2017-04-30 4342 sb_breadahead(sb, block);
2017-04-30 4343 }
2017-04-30 4344
2006-10-11 4345 for (i = 0; i < db_count; i++) {
2020-02-15 4346 struct buffer_head *bh;
2020-02-15 4347
2006-10-11 4348 block = descriptor_loc(sb, logical_sb_block, i);
2020-02-15 4349 bh = sb_bread_unmovable(sb, block);
2020-02-15 4350 if (!bh) {
2009-06-04 4351 ext4_msg(sb, KERN_ERR,
2009-06-04 4352 "can't read group descriptor %d", i);
2006-10-11 4353 db_count = i;
2006-10-11 4354 goto failed_mount2;
2006-10-11 4355 }
2020-02-15 4356 rcu_read_lock();
2020-02-15 4357 rcu_dereference(sbi->s_group_desc)[i] = bh;
2020-02-15 4358 rcu_read_unlock();
2006-10-11 4359 }
2018-07-08 4360 sbi->s_gdb_count = db_count;
2016-08-01 4361 if (!ext4_check_descriptors(sb, logical_sb_block, &first_not_zeroed)) {
2009-06-04 4362 ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
2015-10-17 4363 ret = -EFSCORRUPTED;
2014-07-11 4364 goto failed_mount2;
2006-10-11 4365 }
2008-07-11 4366
2017-10-18 4367 timer_setup(&sbi->s_err_report, print_daily_error_info, 0);
2011-04-05 4368
2013-04-03 4369 /* Register extent status tree shrinker */
2014-09-01 4370 if (ext4_es_register_shrinker(sbi))
2010-11-03 4371 goto failed_mount3;
2010-11-03 4372
2008-01-29 4373 sbi->s_stripe = ext4_get_stripe_size(sbi);
2012-08-17 4374 sbi->s_extent_max_zeroout_kb = 32;
2008-01-29 4375
2014-07-11 4376 /*
2014-07-11 4377 * set up enough so that it can read an inode
2014-07-11 4378 */
2014-07-11 4379 sb->s_op = &ext4_sops;
2006-10-11 4380 sb->s_export_op = &ext4_export_ops;
2006-10-11 4381 sb->s_xattr = ext4_xattr_handlers;
2018-12-12 4382 #ifdef CONFIG_FS_ENCRYPTION
2016-07-10 4383 sb->s_cop = &ext4_cryptops;
2017-10-09 4384 #endif
2019-07-22 4385 #ifdef CONFIG_FS_VERITY
2019-07-22 4386 sb->s_vop = &ext4_verityops;
2019-07-22 4387 #endif
2006-10-11 4388 #ifdef CONFIG_QUOTA
2006-10-11 4389 sb->dq_op = &ext4_quota_operations;
2015-10-17 4390 if (ext4_has_feature_quota(sb))
2014-10-08 4391 sb->s_qcop = &dquot_quotactl_sysfile_ops;
2013-03-02 4392 else
2013-03-02 4393 sb->s_qcop = &ext4_qctl_operations;
2016-01-08 4394 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
2006-10-11 4395 #endif
2017-05-10 4396 memcpy(&sb->s_uuid, es->s_uuid, sizeof(es->s_uuid));
2011-01-29 4397
2006-10-11 4398 INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
2009-04-25 4399 mutex_init(&sbi->s_orphan_lock);
2006-10-11 4400
2006-10-11 4401 sb->s_root = NULL;
2006-10-11 4402
2006-10-11 4403 needs_recovery = (es->s_last_orphan != 0 ||
2015-10-17 4404 ext4_has_feature_journal_needs_recovery(sb));
2006-10-11 4405
2017-07-17 4406 if (ext4_has_feature_mmp(sb) && !sb_rdonly(sb))
2011-05-24 4407 if (ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block)))
2014-10-30 4408 goto failed_mount3a;
2011-05-24 4409
2006-10-11 4410 /*
2006-10-11 4411 * The first inode we look at is the journal inode. Don't try
2006-10-11 4412 * root first: it may be modified in the journal!
2006-10-11 4413 */
2015-10-17 4414 if (!test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb)) {
2017-02-05 4415 err = ext4_load_journal(sb, es, journal_devnum);
2017-02-05 4416 if (err)
2014-10-30 4417 goto failed_mount3a;
2017-07-17 4418 } else if (test_opt(sb, NOLOAD) && !sb_rdonly(sb) &&
2015-10-17 4419 ext4_has_feature_journal_needs_recovery(sb)) {
2009-06-04 4420 ext4_msg(sb, KERN_ERR, "required journal recovery "
2009-06-04 4421 "suppressed and not mounted read-only");
2010-03-04 4422 goto failed_mount_wq;
2006-10-11 4423 } else {
2015-10-18 4424 /* Nojournal mode, all journal mount options are illegal */
2015-10-18 4425 if (test_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM)) {
2015-10-18 4426 ext4_msg(sb, KERN_ERR, "can't mount with "
2015-10-18 4427 "journal_checksum, fs mounted w/o journal");
2015-10-18 4428 goto failed_mount_wq;
2015-10-18 4429 }
2015-10-18 4430 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
2015-10-18 4431 ext4_msg(sb, KERN_ERR, "can't mount with "
2015-10-18 4432 "journal_async_commit, fs mounted w/o journal");
2015-10-18 4433 goto failed_mount_wq;
2015-10-18 4434 }
2015-10-18 4435 if (sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ) {
2015-10-18 4436 ext4_msg(sb, KERN_ERR, "can't mount with "
2015-10-18 4437 "commit=%lu, fs mounted w/o journal",
2015-10-18 4438 sbi->s_commit_interval / HZ);
2015-10-18 4439 goto failed_mount_wq;
2015-10-18 4440 }
2015-10-18 4441 if (EXT4_MOUNT_DATA_FLAGS &
2015-10-18 4442 (sbi->s_mount_opt ^ sbi->s_def_mount_opt)) {
2015-10-18 4443 ext4_msg(sb, KERN_ERR, "can't mount with "
2015-10-18 4444 "data=, fs mounted w/o journal");
2015-10-18 4445 goto failed_mount_wq;
2015-10-18 4446 }
2019-04-30 4447 sbi->s_def_mount_opt &= ~EXT4_MOUNT_JOURNAL_CHECKSUM;
2015-10-18 4448 clear_opt(sb, JOURNAL_CHECKSUM);
2010-12-15 4449 clear_opt(sb, DATA_FLAGS);
2009-01-07 4450 sbi->s_journal = NULL;
2009-01-07 4451 needs_recovery = 0;
2009-01-07 4452 goto no_journal;
2006-10-11 4453 }
2006-10-11 4454
2015-10-17 4455 if (ext4_has_feature_64bit(sb) &&
2007-07-18 4456 !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
2007-07-18 4457 JBD2_FEATURE_INCOMPAT_64BIT)) {
2009-06-04 4458 ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature");
2010-03-04 4459 goto failed_mount_wq;
2007-07-18 4460 }
2007-07-18 4461
2012-05-27 4462 if (!set_journal_csum_feature_set(sb)) {
2012-05-27 4463 ext4_msg(sb, KERN_ERR, "Failed to set journal checksum "
2012-05-27 4464 "feature set");
2012-05-27 4465 goto failed_mount_wq;
2009-11-02 4466 }
2008-01-28 4467
2006-10-11 4468 /* We have now updated the journal if required, so we can
2006-10-11 4469 * validate the data journaling mode. */
2006-10-11 4470 switch (test_opt(sb, DATA_FLAGS)) {
2006-10-11 4471 case 0:
2006-10-11 4472 /* No mode set, assume a default based on the journal
2006-10-11 4473 * capabilities: ORDERED_DATA if the journal can
2006-10-11 4474 * cope, else JOURNAL_DATA
2006-10-11 4475 */
2006-10-11 4476 if (jbd2_journal_check_available_features
2018-03-30 4477 (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
2010-12-15 4478 set_opt(sb, ORDERED_DATA);
2018-03-30 4479 sbi->s_def_mount_opt |= EXT4_MOUNT_ORDERED_DATA;
2018-03-30 4480 } else {
2010-12-15 4481 set_opt(sb, JOURNAL_DATA);
2018-03-30 4482 sbi->s_def_mount_opt |= EXT4_MOUNT_JOURNAL_DATA;
2018-03-30 4483 }
2006-10-11 4484 break;
2006-10-11 4485
2006-10-11 4486 case EXT4_MOUNT_ORDERED_DATA:
2006-10-11 4487 case EXT4_MOUNT_WRITEBACK_DATA:
2006-10-11 4488 if (!jbd2_journal_check_available_features
2006-10-11 4489 (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
2009-06-04 4490 ext4_msg(sb, KERN_ERR, "Journal does not support "
2009-06-04 4491 "requested data journaling mode");
2010-03-04 4492 goto failed_mount_wq;
2006-10-11 4493 }
2006-10-11 4494 default:
2006-10-11 4495 break;
2006-10-11 4496 }
2016-12-03 4497
2016-12-03 4498 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA &&
2016-12-03 4499 test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
2016-12-03 4500 ext4_msg(sb, KERN_ERR, "can't mount with "
2016-12-03 4501 "journal_async_commit in data=ordered mode");
2016-12-03 4502 goto failed_mount_wq;
2016-12-03 4503 }
2016-12-03 4504
2009-01-05 4505 set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
2006-10-11 4506
2012-02-20 4507 sbi->s_journal->j_commit_callback = ext4_journal_commit_callback;
2012-02-20 4508
2010-11-03 4509 no_journal:
2017-06-22 4510 if (!test_opt(sb, NO_MBCACHE)) {
2017-06-22 4511 sbi->s_ea_block_cache = ext4_xattr_create_cache();
2017-06-22 4512 if (!sbi->s_ea_block_cache) {
2017-06-22 4513 ext4_msg(sb, KERN_ERR,
2017-06-22 4514 "Failed to create ea_block_cache");
2014-03-18 4515 goto failed_mount_wq;
2014-03-18 4516 }
2014-03-18 4517
2017-06-22 4518 if (ext4_has_feature_ea_inode(sb)) {
2017-06-22 4519 sbi->s_ea_inode_cache = ext4_xattr_create_cache();
2017-06-22 4520 if (!sbi->s_ea_inode_cache) {
2017-06-22 4521 ext4_msg(sb, KERN_ERR,
2017-06-22 4522 "Failed to create ea_inode_cache");
2017-06-22 4523 goto failed_mount_wq;
2017-06-22 4524 }
2017-06-22 4525 }
2017-06-22 4526 }
2017-06-22 4527
2019-07-22 4528 if (ext4_has_feature_verity(sb) && blocksize != PAGE_SIZE) {
2019-07-22 4529 ext4_msg(sb, KERN_ERR, "Unsupported blocksize for fs-verity");
2019-07-22 4530 goto failed_mount_wq;
2019-07-22 4531 }
2019-07-22 4532
2017-07-17 4533 if (DUMMY_ENCRYPTION_ENABLED(sbi) && !sb_rdonly(sb) &&
2015-10-17 4534 !ext4_has_feature_encrypt(sb)) {
2015-10-17 4535 ext4_set_feature_encrypt(sb);
2015-04-16 4536 ext4_commit_super(sb, 1);
2015-04-16 4537 }
2015-04-16 4538
2012-07-09 4539 /*
2012-07-09 4540 * Get the # of file system overhead blocks from the
2012-07-09 4541 * superblock if present.
2012-07-09 4542 */
2012-07-09 4543 if (es->s_overhead_clusters)
2012-07-09 4544 sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
2012-07-09 4545 else {
2012-11-08 4546 err = ext4_calculate_overhead(sb);
2012-11-08 4547 if (err)
2012-07-09 4548 goto failed_mount_wq;
2012-07-09 4549 }
2012-07-09 4550
2011-02-01 4551 /*
2011-02-01 4552 * The maximum number of concurrent works can be high and
2011-02-01 4553 * concurrency isn't really necessary. Limit it to 1.
2011-02-01 4554 */
2013-06-04 4555 EXT4_SB(sb)->rsv_conversion_wq =
2013-06-04 4556 alloc_workqueue("ext4-rsv-conversion", WQ_MEM_RECLAIM | WQ_UNBOUND, 1);
2013-06-04 4557 if (!EXT4_SB(sb)->rsv_conversion_wq) {
2013-06-04 4558 printk(KERN_ERR "EXT4-fs: failed to create workqueue\n");
2012-11-08 4559 ret = -ENOMEM;
2013-06-04 4560 goto failed_mount4;
2013-06-04 4561 }
2013-06-04 4562
2006-10-11 4563 /*
2006-10-11 4564 * The jbd2_journal_load will have done any necessary log recovery,
2006-10-11 4565 * so we can safely mount the rest of the filesystem now.
2006-10-11 4566 */
2006-10-11 4567
2018-12-19 4568 root = ext4_iget(sb, EXT4_ROOT_INO, EXT4_IGET_SPECIAL);
2008-02-07 4569 if (IS_ERR(root)) {
2009-06-04 4570 ext4_msg(sb, KERN_ERR, "get root inode failed");
2008-02-07 4571 ret = PTR_ERR(root);
2011-02-27 4572 root = NULL;
2006-10-11 4573 goto failed_mount4;
2006-10-11 4574 }
2006-10-11 4575 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
2009-06-04 4576 ext4_msg(sb, KERN_ERR, "corrupt root inode, run e2fsck");
2012-01-09 4577 iput(root);
2006-10-11 4578 goto failed_mount4;
2006-10-11 4579 }
Krisman Bertazi 2019-04-25 4580
line 4297 was first introduced by commit
425d17ce139a62f5af5 ext4: Change all super.c messages to print the device
<[email protected]>
Ts'o <[email protected]>
Service, Intel Corporation
rg/hyperkitty/list/kbuild-all@lists.01.org">https://lists.01.org/hyperkitty/list/[email protected]

Attachments:

(No filename) (55.46 kB)
.config.gz (11.46 kB)
Download all attachments

2020-03-28 23:09:21

by Andreas Dilger

[permalink] [raw]

Subject: Re: [PATCH] ext4: Fix incorrect group count in ext4_fill_super error message

On Mar 28, 2020, at 3:54 PM, Josh Triplett <[email protected]> wrote:
>
> ext4_fill_super doublechecks the number of groups before mounting; if
> that check fails, the resulting error message prints the group count
> from the ext4_sb_info sbi, which hasn't been set yet. Print the freshly
> computed group count instead (which at that point has just been computed
> in "blocks_count").
>
> Signed-off-by: Josh Triplett <[email protected]>
> Fixes: 4ec1102813798 ("ext4: Add sanity checks for the superblock before mounting the filesystem")

Modulo the compiler warning pointed out by kbuild test robot, I think the
patch is correct, but was definitely confusing to read within the shown
context, since "blocks_count" definitely doesn't seem to be "groups count"
(it *is* the "groups count", but is just used as a temporary variable).

Reviewed-by: Andreas Dilger <[email protected]>

> ---
> fs/ext4/super.c | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/fs/ext4/super.c b/fs/ext4/super.c
> index 0c7c4adb664e..7f5f37653a03 100644
> --- a/fs/ext4/super.c
> +++ b/fs/ext4/super.c
> @@ -4288,7 +4288,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
> if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
> ext4_msg(sb, KERN_WARNING, "groups count too large: %u "
> "(block count %llu, first data block %u, "
> - "blocks per group %lu)", sbi->s_groups_count,
> + "blocks per group %lu)", blocks_count,
> ext4_blocks_count(es),
> le32_to_cpu(es->s_first_data_block),
> EXT4_BLOCKS_PER_GROUP(sb));
> --
> 2.26.0

Cheers, Andreas

Attachments:

signature.asc (890.00 B)
Message signed with OpenPGP

2020-03-28 23:56:44

by Josh Triplett

[permalink] [raw]

Subject: Re: [PATCH] ext4: Fix incorrect group count in ext4_fill_super error message

On Sat, Mar 28, 2020 at 05:07:55PM -0600, Andreas Dilger wrote:
> On Mar 28, 2020, at 3:54 PM, Josh Triplett <[email protected]> wrote:
> >
> > ext4_fill_super doublechecks the number of groups before mounting; if
> > that check fails, the resulting error message prints the group count
> > from the ext4_sb_info sbi, which hasn't been set yet. Print the freshly
> > computed group count instead (which at that point has just been computed
> > in "blocks_count").
> >
> > Signed-off-by: Josh Triplett <[email protected]>
> > Fixes: 4ec1102813798 ("ext4: Add sanity checks for the superblock before mounting the filesystem")
>
> Modulo the compiler warning pointed out by kbuild test robot, I think the
> patch is correct, but was definitely confusing to read within the shown
> context, since "blocks_count" definitely doesn't seem to be "groups count"
> (it *is* the "groups count", but is just used as a temporary variable).

I agree that the code and patch read confusingly due to the (lack of)
context. The commit message attempted to explain that, but clearer code
seems preferable to confusing-but-explained code.

I sent a new version of this patch, which instead just moves the
assignment to sbi's group count earlier, so that the error message can
continue referencing it that way. (That also addresses the warning.)

- Josh Triplett

2020-03-29 02:50:51

by Theodore Ts'o

[permalink] [raw]

Subject: Re: [PATCH] ext4: Fix incorrect group count in ext4_fill_super error message

On Sat, Mar 28, 2020 at 02:54:01PM -0700, Josh Triplett wrote:
> ext4_fill_super doublechecks the number of groups before mounting; if
> that check fails, the resulting error message prints the group count
> from the ext4_sb_info sbi, which hasn't been set yet. Print the freshly
> computed group count instead (which at that point has just been computed
> in "blocks_count").
>
> Signed-off-by: Josh Triplett <[email protected]>
> Fixes: 4ec1102813798 ("ext4: Add sanity checks for the superblock before mounting the filesystem")

Applied, with a fix to the format string:

> fs/ext4/super.c | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/fs/ext4/super.c b/fs/ext4/super.c
> index 0c7c4adb664e..7f5f37653a03 100644
> --- a/fs/ext4/super.c
> +++ b/fs/ext4/super.c
> @@ -4288,7 +4288,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
> if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
> ext4_msg(sb, KERN_WARNING, "groups count too large: %u "

s/%u/%llu/

> "(block count %llu, first data block %u, "
> - "blocks per group %lu)", sbi->s_groups_count,
> + "blocks per group %lu)", blocks_count,
> ext4_blocks_count(es),
> le32_to_cpu(es->s_first_data_block),
> EXT4_BLOCKS_PER_GROUP(sb));
> --
> 2.26.0

- Ted

2020-03-29 04:37:33

by Andreas Dilger

[permalink] [raw]

Subject: Re: [PATCH] ext4: Fix incorrect group count in ext4_fill_super error message

You missed the v2 patch, which was better IMHO.

Cheers, Andreas

> On Mar 28, 2020, at 20:47, Theodore Y. Ts'o <[email protected]> wrote:
>
> On Sat, Mar 28, 2020 at 02:54:01PM -0700, Josh Triplett wrote:
>> ext4_fill_super doublechecks the number of groups before mounting; if
>> that check fails, the resulting error message prints the group count
>> from the ext4_sb_info sbi, which hasn't been set yet. Print the freshly
>> computed group count instead (which at that point has just been computed
>> in "blocks_count").
>>
>> Signed-off-by: Josh Triplett <[email protected]>
>> Fixes: 4ec1102813798 ("ext4: Add sanity checks for the superblock before mounting the filesystem")
>
> Applied, with a fix to the format string:
>
>> fs/ext4/super.c | 2 +-
>> 1 file changed, 1 insertion(+), 1 deletion(-)
>>
>> diff --git a/fs/ext4/super.c b/fs/ext4/super.c
>> index 0c7c4adb664e..7f5f37653a03 100644
>> --- a/fs/ext4/super.c
>> +++ b/fs/ext4/super.c
>> @@ -4288,7 +4288,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
>> if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
>> ext4_msg(sb, KERN_WARNING, "groups count too large: %u "
>
> s/%u/%llu/
>
>> "(block count %llu, first data block %u, "
>> - "blocks per group %lu)", sbi->s_groups_count,
>> + "blocks per group %lu)", blocks_count,
>> ext4_blocks_count(es),
>> le32_to_cpu(es->s_first_data_block),
>> EXT4_BLOCKS_PER_GROUP(sb));
>> --
>> 2.26.0
>
> - Ted

2020-03-29 16:48:46

by Theodore Ts'o

[permalink] [raw]

Subject: Re: [PATCH] ext4: Fix incorrect group count in ext4_fill_super error message

On Sat, Mar 28, 2020 at 10:36:07PM -0600, Andreas Dilger wrote:
> You missed the v2 patch, which was better IMHO.

I saw the V2 patch, but the it will print the 32-bit truncated block
count, and it's possible if things are really insane, the number of
block groups calculated will be > 2**32. In which case the V1 patch
with the format string adjusted will print a less confusing message.
e.g.:

groups count too large: 8589934634 ....

as opposed to:

groups count too large: 42 ....

- Ted