|
|
@@ -48,65 +48,54 @@ static int verify_group_input(struct super_block *sb,
|
|
|
|
|
|
ext4_get_group_no_and_offset(sb, start, NULL, &offset);
|
|
|
if (group != sbi->s_groups_count)
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Cannot add at group %u (only %u groups)",
|
|
|
+ ext4_warning(sb, "Cannot add at group %u (only %u groups)",
|
|
|
input->group, sbi->s_groups_count);
|
|
|
else if (offset != 0)
|
|
|
- ext4_warning(sb, __func__, "Last group not full");
|
|
|
+ ext4_warning(sb, "Last group not full");
|
|
|
else if (input->reserved_blocks > input->blocks_count / 5)
|
|
|
- ext4_warning(sb, __func__, "Reserved blocks too high (%u)",
|
|
|
+ ext4_warning(sb, "Reserved blocks too high (%u)",
|
|
|
input->reserved_blocks);
|
|
|
else if (free_blocks_count < 0)
|
|
|
- ext4_warning(sb, __func__, "Bad blocks count %u",
|
|
|
+ ext4_warning(sb, "Bad blocks count %u",
|
|
|
input->blocks_count);
|
|
|
else if (!(bh = sb_bread(sb, end - 1)))
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Cannot read last block (%llu)",
|
|
|
+ ext4_warning(sb, "Cannot read last block (%llu)",
|
|
|
end - 1);
|
|
|
else if (outside(input->block_bitmap, start, end))
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Block bitmap not in group (block %llu)",
|
|
|
+ ext4_warning(sb, "Block bitmap not in group (block %llu)",
|
|
|
(unsigned long long)input->block_bitmap);
|
|
|
else if (outside(input->inode_bitmap, start, end))
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Inode bitmap not in group (block %llu)",
|
|
|
+ ext4_warning(sb, "Inode bitmap not in group (block %llu)",
|
|
|
(unsigned long long)input->inode_bitmap);
|
|
|
else if (outside(input->inode_table, start, end) ||
|
|
|
outside(itend - 1, start, end))
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Inode table not in group (blocks %llu-%llu)",
|
|
|
+ ext4_warning(sb, "Inode table not in group (blocks %llu-%llu)",
|
|
|
(unsigned long long)input->inode_table, itend - 1);
|
|
|
else if (input->inode_bitmap == input->block_bitmap)
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Block bitmap same as inode bitmap (%llu)",
|
|
|
+ ext4_warning(sb, "Block bitmap same as inode bitmap (%llu)",
|
|
|
(unsigned long long)input->block_bitmap);
|
|
|
else if (inside(input->block_bitmap, input->inode_table, itend))
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Block bitmap (%llu) in inode table (%llu-%llu)",
|
|
|
+ ext4_warning(sb, "Block bitmap (%llu) in inode table "
|
|
|
+ "(%llu-%llu)",
|
|
|
(unsigned long long)input->block_bitmap,
|
|
|
(unsigned long long)input->inode_table, itend - 1);
|
|
|
else if (inside(input->inode_bitmap, input->inode_table, itend))
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Inode bitmap (%llu) in inode table (%llu-%llu)",
|
|
|
+ ext4_warning(sb, "Inode bitmap (%llu) in inode table "
|
|
|
+ "(%llu-%llu)",
|
|
|
(unsigned long long)input->inode_bitmap,
|
|
|
(unsigned long long)input->inode_table, itend - 1);
|
|
|
else if (inside(input->block_bitmap, start, metaend))
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Block bitmap (%llu) in GDT table"
|
|
|
- " (%llu-%llu)",
|
|
|
+ ext4_warning(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)",
|
|
|
(unsigned long long)input->block_bitmap,
|
|
|
start, metaend - 1);
|
|
|
else if (inside(input->inode_bitmap, start, metaend))
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Inode bitmap (%llu) in GDT table"
|
|
|
- " (%llu-%llu)",
|
|
|
+ ext4_warning(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)",
|
|
|
(unsigned long long)input->inode_bitmap,
|
|
|
start, metaend - 1);
|
|
|
else if (inside(input->inode_table, start, metaend) ||
|
|
|
inside(itend - 1, start, metaend))
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Inode table (%llu-%llu) overlaps"
|
|
|
- "GDT table (%llu-%llu)",
|
|
|
+ ext4_warning(sb, "Inode table (%llu-%llu) overlaps GDT table "
|
|
|
+ "(%llu-%llu)",
|
|
|
(unsigned long long)input->inode_table,
|
|
|
itend - 1, start, metaend - 1);
|
|
|
else
|
|
|
@@ -364,8 +353,7 @@ static int verify_reserved_gdb(struct super_block *sb,
|
|
|
while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) {
|
|
|
if (le32_to_cpu(*p++) !=
|
|
|
grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "reserved GDT %llu"
|
|
|
+ ext4_warning(sb, "reserved GDT %llu"
|
|
|
" missing grp %d (%llu)",
|
|
|
blk, grp,
|
|
|
grp *
|
|
|
@@ -420,8 +408,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
|
|
|
*/
|
|
|
if (EXT4_SB(sb)->s_sbh->b_blocknr !=
|
|
|
le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "won't resize using backup superblock at %llu",
|
|
|
+ ext4_warning(sb, "won't resize using backup superblock at %llu",
|
|
|
(unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
|
|
|
return -EPERM;
|
|
|
}
|
|
|
@@ -444,8 +431,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
|
|
|
|
|
|
data = (__le32 *)dind->b_data;
|
|
|
if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "new group %u GDT block %llu not reserved",
|
|
|
+ ext4_warning(sb, "new group %u GDT block %llu not reserved",
|
|
|
input->group, gdblock);
|
|
|
err = -EINVAL;
|
|
|
goto exit_dind;
|
|
|
@@ -468,7 +454,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
|
|
|
GFP_NOFS);
|
|
|
if (!n_group_desc) {
|
|
|
err = -ENOMEM;
|
|
|
- ext4_warning(sb, __func__,
|
|
|
+ ext4_warning(sb,
|
|
|
"not enough memory for %lu groups", gdb_num + 1);
|
|
|
goto exit_inode;
|
|
|
}
|
|
|
@@ -567,8 +553,7 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
|
|
|
/* Get each reserved primary GDT block and verify it holds backups */
|
|
|
for (res = 0; res < reserved_gdb; res++, blk++) {
|
|
|
if (le32_to_cpu(*data) != blk) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "reserved block %llu"
|
|
|
+ ext4_warning(sb, "reserved block %llu"
|
|
|
" not at offset %ld",
|
|
|
blk,
|
|
|
(long)(data - (__le32 *)dind->b_data));
|
|
|
@@ -713,8 +698,7 @@ static void update_backups(struct super_block *sb,
|
|
|
*/
|
|
|
exit_err:
|
|
|
if (err) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "can't update backup for group %u (err %d), "
|
|
|
+ ext4_warning(sb, "can't update backup for group %u (err %d), "
|
|
|
"forcing fsck on next reboot", group, err);
|
|
|
sbi->s_mount_state &= ~EXT4_VALID_FS;
|
|
|
sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
|
|
|
@@ -753,20 +737,19 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
|
|
|
|
|
|
if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb,
|
|
|
EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Can't resize non-sparse filesystem further");
|
|
|
+ ext4_warning(sb, "Can't resize non-sparse filesystem further");
|
|
|
return -EPERM;
|
|
|
}
|
|
|
|
|
|
if (ext4_blocks_count(es) + input->blocks_count <
|
|
|
ext4_blocks_count(es)) {
|
|
|
- ext4_warning(sb, __func__, "blocks_count overflow");
|
|
|
+ ext4_warning(sb, "blocks_count overflow");
|
|
|
return -EINVAL;
|
|
|
}
|
|
|
|
|
|
if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) <
|
|
|
le32_to_cpu(es->s_inodes_count)) {
|
|
|
- ext4_warning(sb, __func__, "inodes_count overflow");
|
|
|
+ ext4_warning(sb, "inodes_count overflow");
|
|
|
return -EINVAL;
|
|
|
}
|
|
|
|
|
|
@@ -774,14 +757,13 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
|
|
|
if (!EXT4_HAS_COMPAT_FEATURE(sb,
|
|
|
EXT4_FEATURE_COMPAT_RESIZE_INODE)
|
|
|
|| !le16_to_cpu(es->s_reserved_gdt_blocks)) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
+ ext4_warning(sb,
|
|
|
"No reserved GDT blocks, can't resize");
|
|
|
return -EPERM;
|
|
|
}
|
|
|
inode = ext4_iget(sb, EXT4_RESIZE_INO);
|
|
|
if (IS_ERR(inode)) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "Error opening resize inode");
|
|
|
+ ext4_warning(sb, "Error opening resize inode");
|
|
|
return PTR_ERR(inode);
|
|
|
}
|
|
|
}
|
|
|
@@ -810,8 +792,7 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
|
|
|
|
|
|
mutex_lock(&sbi->s_resize_lock);
|
|
|
if (input->group != sbi->s_groups_count) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "multiple resizers run on filesystem!");
|
|
|
+ ext4_warning(sb, "multiple resizers run on filesystem!");
|
|
|
err = -EBUSY;
|
|
|
goto exit_journal;
|
|
|
}
|
|
|
@@ -997,13 +978,12 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
|
|
|
" too large to resize to %llu blocks safely\n",
|
|
|
sb->s_id, n_blocks_count);
|
|
|
if (sizeof(sector_t) < 8)
|
|
|
- ext4_warning(sb, __func__, "CONFIG_LBDAF not enabled");
|
|
|
+ ext4_warning(sb, "CONFIG_LBDAF not enabled");
|
|
|
return -EINVAL;
|
|
|
}
|
|
|
|
|
|
if (n_blocks_count < o_blocks_count) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "can't shrink FS - resize aborted");
|
|
|
+ ext4_warning(sb, "can't shrink FS - resize aborted");
|
|
|
return -EBUSY;
|
|
|
}
|
|
|
|
|
|
@@ -1011,15 +991,14 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
|
|
|
ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
|
|
|
|
|
|
if (last == 0) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "need to use ext2online to resize further");
|
|
|
+ ext4_warning(sb, "need to use ext2online to resize further");
|
|
|
return -EPERM;
|
|
|
}
|
|
|
|
|
|
add = EXT4_BLOCKS_PER_GROUP(sb) - last;
|
|
|
|
|
|
if (o_blocks_count + add < o_blocks_count) {
|
|
|
- ext4_warning(sb, __func__, "blocks_count overflow");
|
|
|
+ ext4_warning(sb, "blocks_count overflow");
|
|
|
return -EINVAL;
|
|
|
}
|
|
|
|
|
|
@@ -1027,16 +1006,13 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
|
|
|
add = n_blocks_count - o_blocks_count;
|
|
|
|
|
|
if (o_blocks_count + add < n_blocks_count)
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "will only finish group (%llu"
|
|
|
- " blocks, %u new)",
|
|
|
+ ext4_warning(sb, "will only finish group (%llu blocks, %u new)",
|
|
|
o_blocks_count + add, add);
|
|
|
|
|
|
/* See if the device is actually as big as what was requested */
|
|
|
bh = sb_bread(sb, o_blocks_count + add - 1);
|
|
|
if (!bh) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "can't read last block, resize aborted");
|
|
|
+ ext4_warning(sb, "can't read last block, resize aborted");
|
|
|
return -ENOSPC;
|
|
|
}
|
|
|
brelse(bh);
|
|
|
@@ -1047,14 +1023,13 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
|
|
|
handle = ext4_journal_start_sb(sb, 3);
|
|
|
if (IS_ERR(handle)) {
|
|
|
err = PTR_ERR(handle);
|
|
|
- ext4_warning(sb, __func__, "error %d on journal start", err);
|
|
|
+ ext4_warning(sb, "error %d on journal start", err);
|
|
|
goto exit_put;
|
|
|
}
|
|
|
|
|
|
mutex_lock(&EXT4_SB(sb)->s_resize_lock);
|
|
|
if (o_blocks_count != ext4_blocks_count(es)) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "multiple resizers run on filesystem!");
|
|
|
+ ext4_warning(sb, "multiple resizers run on filesystem!");
|
|
|
mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
|
|
|
ext4_journal_stop(handle);
|
|
|
err = -EBUSY;
|
|
|
@@ -1063,8 +1038,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
|
|
|
|
|
|
if ((err = ext4_journal_get_write_access(handle,
|
|
|
EXT4_SB(sb)->s_sbh))) {
|
|
|
- ext4_warning(sb, __func__,
|
|
|
- "error %d on journal write access", err);
|
|
|
+ ext4_warning(sb, "error %d on journal write access", err);
|
|
|
mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
|
|
|
ext4_journal_stop(handle);
|
|
|
goto exit_put;
|
Eric Sandeen