2006-10-11 02:20:50 -06:00
|
|
|
/*
|
2006-10-11 02:20:53 -06:00
|
|
|
* linux/fs/ext4/balloc.c
|
2006-10-11 02:20:50 -06:00
|
|
|
*
|
|
|
|
* Copyright (C) 1992, 1993, 1994, 1995
|
|
|
|
* Remy Card (card@masi.ibp.fr)
|
|
|
|
* Laboratoire MASI - Institut Blaise Pascal
|
|
|
|
* Universite Pierre et Marie Curie (Paris VI)
|
|
|
|
*
|
|
|
|
* Enhanced block allocation by Stephen Tweedie (sct@redhat.com), 1993
|
|
|
|
* Big-endian to little-endian byte-swapping/bitmaps by
|
|
|
|
* David S. Miller (davem@caip.rutgers.edu), 1995
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/capability.h>
|
|
|
|
#include <linux/fs.h>
|
2006-10-11 02:21:01 -06:00
|
|
|
#include <linux/jbd2.h>
|
2006-10-11 02:20:50 -06:00
|
|
|
#include <linux/quotaops.h>
|
|
|
|
#include <linux/buffer_head.h>
|
2008-04-29 16:13:32 -06:00
|
|
|
#include "ext4.h"
|
|
|
|
#include "ext4_jbd2.h"
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
#include "group.h"
|
2009-01-05 19:36:02 -07:00
|
|
|
#include "mballoc.h"
|
2008-04-29 16:13:32 -06:00
|
|
|
|
2006-10-11 02:20:50 -06:00
|
|
|
/*
|
|
|
|
* balloc.c contains the blocks allocation and deallocation routines
|
|
|
|
*/
|
|
|
|
|
2006-10-11 02:21:18 -06:00
|
|
|
/*
|
|
|
|
* Calculate the block group number and offset, given a block number
|
|
|
|
*/
|
|
|
|
void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,
|
2008-01-28 21:58:27 -07:00
|
|
|
ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp)
|
2006-10-11 02:21:18 -06:00
|
|
|
{
|
2007-05-24 11:04:54 -06:00
|
|
|
struct ext4_super_block *es = EXT4_SB(sb)->s_es;
|
2006-10-11 02:21:18 -06:00
|
|
|
ext4_grpblk_t offset;
|
|
|
|
|
2007-05-24 11:04:54 -06:00
|
|
|
blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
|
2006-10-11 02:21:19 -06:00
|
|
|
offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb));
|
2006-10-11 02:21:18 -06:00
|
|
|
if (offsetp)
|
|
|
|
*offsetp = offset;
|
|
|
|
if (blockgrpp)
|
2007-05-24 11:04:54 -06:00
|
|
|
*blockgrpp = blocknr;
|
2006-10-11 02:21:18 -06:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-06-03 12:07:29 -06:00
|
|
|
static int ext4_block_in_group(struct super_block *sb, ext4_fsblk_t block,
|
|
|
|
ext4_group_t block_group)
|
|
|
|
{
|
|
|
|
ext4_group_t actual_group;
|
2008-07-11 17:27:31 -06:00
|
|
|
ext4_get_group_no_and_offset(sb, block, &actual_group, NULL);
|
2008-06-03 12:07:29 -06:00
|
|
|
if (actual_group == block_group)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ext4_group_used_meta_blocks(struct super_block *sb,
|
|
|
|
ext4_group_t block_group)
|
|
|
|
{
|
|
|
|
ext4_fsblk_t tmp;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
|
|
|
/* block bitmap, inode bitmap, and inode table blocks */
|
|
|
|
int used_blocks = sbi->s_itb_per_group + 2;
|
|
|
|
|
|
|
|
if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
|
|
|
|
struct ext4_group_desc *gdp;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
|
|
|
|
gdp = ext4_get_group_desc(sb, block_group, &bh);
|
|
|
|
if (!ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp),
|
|
|
|
block_group))
|
|
|
|
used_blocks--;
|
|
|
|
|
|
|
|
if (!ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp),
|
|
|
|
block_group))
|
|
|
|
used_blocks--;
|
|
|
|
|
|
|
|
tmp = ext4_inode_table(sb, gdp);
|
|
|
|
for (; tmp < ext4_inode_table(sb, gdp) +
|
|
|
|
sbi->s_itb_per_group; tmp++) {
|
|
|
|
if (!ext4_block_in_group(sb, tmp, block_group))
|
|
|
|
used_blocks -= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return used_blocks;
|
|
|
|
}
|
2008-10-10 07:40:52 -06:00
|
|
|
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
/* Initializes an uninitialized block bitmap if given, and returns the
|
|
|
|
* number of blocks free in the group. */
|
|
|
|
unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
|
2008-01-28 21:58:27 -07:00
|
|
|
ext4_group_t block_group, struct ext4_group_desc *gdp)
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
{
|
|
|
|
int bit, bit_max;
|
|
|
|
unsigned free_blocks, group_blocks;
|
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
|
|
|
|
|
|
|
if (bh) {
|
|
|
|
J_ASSERT_BH(bh, buffer_locked(bh));
|
|
|
|
|
|
|
|
/* If checksum is bad mark all blocks used to prevent allocation
|
|
|
|
* essentially implementing a per-group read-only flag. */
|
|
|
|
if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
|
2008-04-17 08:38:59 -06:00
|
|
|
ext4_error(sb, __func__,
|
2009-01-05 20:18:16 -07:00
|
|
|
"Checksum bad for group %u", block_group);
|
2009-01-05 20:20:24 -07:00
|
|
|
ext4_free_blks_set(sb, gdp, 0);
|
|
|
|
ext4_free_inodes_set(sb, gdp, 0);
|
|
|
|
ext4_itable_unused_set(sb, gdp, 0);
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
memset(bh->b_data, 0xff, sb->s_blocksize);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
memset(bh->b_data, 0, sb->s_blocksize);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check for superblock and gdt backups in this group */
|
|
|
|
bit_max = ext4_bg_has_super(sb, block_group);
|
|
|
|
|
|
|
|
if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||
|
|
|
|
block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
|
|
|
|
sbi->s_desc_per_block) {
|
|
|
|
if (bit_max) {
|
|
|
|
bit_max += ext4_bg_num_gdb(sb, block_group);
|
|
|
|
bit_max +=
|
|
|
|
le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
|
|
|
|
}
|
|
|
|
} else { /* For META_BG_BLOCK_GROUPS */
|
2008-07-11 17:27:31 -06:00
|
|
|
bit_max += ext4_bg_num_gdb(sb, block_group);
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (block_group == sbi->s_groups_count - 1) {
|
|
|
|
/*
|
|
|
|
* Even though mke2fs always initialize first and last group
|
|
|
|
* if some other tool enabled the EXT4_BG_BLOCK_UNINIT we need
|
|
|
|
* to make sure we calculate the right free blocks
|
|
|
|
*/
|
|
|
|
group_blocks = ext4_blocks_count(sbi->s_es) -
|
|
|
|
le32_to_cpu(sbi->s_es->s_first_data_block) -
|
2008-09-08 20:25:24 -06:00
|
|
|
(EXT4_BLOCKS_PER_GROUP(sb) * (sbi->s_groups_count - 1));
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
} else {
|
|
|
|
group_blocks = EXT4_BLOCKS_PER_GROUP(sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
free_blocks = group_blocks - bit_max;
|
|
|
|
|
|
|
|
if (bh) {
|
2008-06-03 12:07:29 -06:00
|
|
|
ext4_fsblk_t start, tmp;
|
|
|
|
int flex_bg = 0;
|
2008-04-17 08:38:59 -06:00
|
|
|
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
for (bit = 0; bit < bit_max; bit++)
|
|
|
|
ext4_set_bit(bit, bh->b_data);
|
|
|
|
|
2008-04-17 08:38:59 -06:00
|
|
|
start = ext4_group_first_block_no(sb, block_group);
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
|
2008-06-03 12:07:29 -06:00
|
|
|
if (EXT4_HAS_INCOMPAT_FEATURE(sb,
|
|
|
|
EXT4_FEATURE_INCOMPAT_FLEX_BG))
|
|
|
|
flex_bg = 1;
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
|
2008-06-03 12:07:29 -06:00
|
|
|
/* Set bits for block and inode bitmaps, and inode table */
|
|
|
|
tmp = ext4_block_bitmap(sb, gdp);
|
|
|
|
if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
|
|
|
|
ext4_set_bit(tmp - start, bh->b_data);
|
|
|
|
|
|
|
|
tmp = ext4_inode_bitmap(sb, gdp);
|
|
|
|
if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
|
|
|
|
ext4_set_bit(tmp - start, bh->b_data);
|
|
|
|
|
|
|
|
tmp = ext4_inode_table(sb, gdp);
|
|
|
|
for (; tmp < ext4_inode_table(sb, gdp) +
|
|
|
|
sbi->s_itb_per_group; tmp++) {
|
|
|
|
if (!flex_bg ||
|
|
|
|
ext4_block_in_group(sb, tmp, block_group))
|
|
|
|
ext4_set_bit(tmp - start, bh->b_data);
|
|
|
|
}
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
/*
|
|
|
|
* Also if the number of blocks within the group is
|
|
|
|
* less than the blocksize * 8 ( which is the size
|
|
|
|
* of bitmap ), set rest of the block bitmap to 1
|
|
|
|
*/
|
|
|
|
mark_bitmap_end(group_blocks, sb->s_blocksize * 8, bh->b_data);
|
|
|
|
}
|
2008-06-03 12:07:29 -06:00
|
|
|
return free_blocks - ext4_group_used_meta_blocks(sb, block_group);
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-11 02:20:50 -06:00
|
|
|
/*
|
|
|
|
* The free blocks are managed by bitmaps. A file system contains several
|
|
|
|
* blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap
|
|
|
|
* block for inodes, N blocks for the inode table and data blocks.
|
|
|
|
*
|
|
|
|
* The file system contains group descriptors which are located after the
|
|
|
|
* super block. Each descriptor contains the number of the bitmap block and
|
|
|
|
* the free blocks count in the block. The descriptors are loaded in memory
|
2007-02-20 14:57:58 -07:00
|
|
|
* when a file system is mounted (see ext4_fill_super).
|
2006-10-11 02:20:50 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
|
|
|
|
|
|
|
|
/**
|
2006-10-11 02:20:53 -06:00
|
|
|
* ext4_get_group_desc() -- load group descriptor from disk
|
2006-10-11 02:20:50 -06:00
|
|
|
* @sb: super block
|
|
|
|
* @block_group: given block group
|
|
|
|
* @bh: pointer to the buffer head to store the block
|
|
|
|
* group descriptor
|
|
|
|
*/
|
2008-09-08 20:25:24 -06:00
|
|
|
struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
|
2008-01-28 21:58:27 -07:00
|
|
|
ext4_group_t block_group,
|
2008-09-08 20:25:24 -06:00
|
|
|
struct buffer_head **bh)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2008-11-04 22:14:04 -07:00
|
|
|
unsigned int group_desc;
|
|
|
|
unsigned int offset;
|
2008-09-08 20:25:24 -06:00
|
|
|
struct ext4_group_desc *desc;
|
2006-10-11 02:20:53 -06:00
|
|
|
struct ext4_sb_info *sbi = EXT4_SB(sb);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
|
|
|
if (block_group >= sbi->s_groups_count) {
|
2008-09-08 20:25:24 -06:00
|
|
|
ext4_error(sb, "ext4_get_group_desc",
|
|
|
|
"block_group >= groups_count - "
|
2009-01-05 20:18:16 -07:00
|
|
|
"block_group = %u, groups_count = %u",
|
2008-09-08 20:25:24 -06:00
|
|
|
block_group, sbi->s_groups_count);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
smp_rmb();
|
|
|
|
|
2006-10-11 02:20:53 -06:00
|
|
|
group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
|
|
|
|
offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
|
2006-10-11 02:20:50 -06:00
|
|
|
if (!sbi->s_group_desc[group_desc]) {
|
2008-09-08 20:25:24 -06:00
|
|
|
ext4_error(sb, "ext4_get_group_desc",
|
|
|
|
"Group descriptor not loaded - "
|
2008-11-04 22:14:04 -07:00
|
|
|
"block_group = %u, group_desc = %u, desc = %u",
|
2008-09-08 20:25:24 -06:00
|
|
|
block_group, group_desc, offset);
|
2006-10-11 02:20:50 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-10-11 02:21:14 -06:00
|
|
|
desc = (struct ext4_group_desc *)(
|
|
|
|
(__u8 *)sbi->s_group_desc[group_desc]->b_data +
|
|
|
|
offset * EXT4_DESC_SIZE(sb));
|
2006-10-11 02:20:50 -06:00
|
|
|
if (bh)
|
|
|
|
*bh = sbi->s_group_desc[group_desc];
|
2006-10-11 02:21:14 -06:00
|
|
|
return desc;
|
2006-10-11 02:20:50 -06:00
|
|
|
}
|
|
|
|
|
2008-01-28 21:58:27 -07:00
|
|
|
static int ext4_valid_block_bitmap(struct super_block *sb,
|
|
|
|
struct ext4_group_desc *desc,
|
|
|
|
unsigned int block_group,
|
|
|
|
struct buffer_head *bh)
|
|
|
|
{
|
|
|
|
ext4_grpblk_t offset;
|
|
|
|
ext4_grpblk_t next_zero_bit;
|
|
|
|
ext4_fsblk_t bitmap_blk;
|
|
|
|
ext4_fsblk_t group_first_block;
|
|
|
|
|
|
|
|
if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
|
|
|
|
/* with FLEX_BG, the inode/block bitmaps and itable
|
|
|
|
* blocks may not be in the group at all
|
|
|
|
* so the bitmap validation will be skipped for those groups
|
|
|
|
* or it has to also read the block group where the bitmaps
|
|
|
|
* are located to verify they are set.
|
|
|
|
*/
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
group_first_block = ext4_group_first_block_no(sb, block_group);
|
|
|
|
|
|
|
|
/* check whether block bitmap block number is set */
|
|
|
|
bitmap_blk = ext4_block_bitmap(sb, desc);
|
|
|
|
offset = bitmap_blk - group_first_block;
|
|
|
|
if (!ext4_test_bit(offset, bh->b_data))
|
|
|
|
/* bad block bitmap */
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
/* check whether the inode bitmap block number is set */
|
|
|
|
bitmap_blk = ext4_inode_bitmap(sb, desc);
|
|
|
|
offset = bitmap_blk - group_first_block;
|
|
|
|
if (!ext4_test_bit(offset, bh->b_data))
|
|
|
|
/* bad block bitmap */
|
|
|
|
goto err_out;
|
|
|
|
|
|
|
|
/* check whether the inode table block number is set */
|
|
|
|
bitmap_blk = ext4_inode_table(sb, desc);
|
|
|
|
offset = bitmap_blk - group_first_block;
|
|
|
|
next_zero_bit = ext4_find_next_zero_bit(bh->b_data,
|
|
|
|
offset + EXT4_SB(sb)->s_itb_per_group,
|
|
|
|
offset);
|
|
|
|
if (next_zero_bit >= offset + EXT4_SB(sb)->s_itb_per_group)
|
|
|
|
/* good bitmap for inode tables */
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
err_out:
|
2008-04-17 08:38:59 -06:00
|
|
|
ext4_error(sb, __func__,
|
2008-01-28 21:58:27 -07:00
|
|
|
"Invalid block bitmap - "
|
|
|
|
"block_group = %d, block = %llu",
|
|
|
|
block_group, bitmap_blk);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-10-11 02:20:50 -06:00
|
|
|
/**
|
2008-07-11 17:27:31 -06:00
|
|
|
* ext4_read_block_bitmap()
|
2006-10-11 02:20:50 -06:00
|
|
|
* @sb: super block
|
|
|
|
* @block_group: given block group
|
|
|
|
*
|
2008-01-28 21:58:27 -07:00
|
|
|
* Read the bitmap for a given block_group,and validate the
|
|
|
|
* bits for block/inode/inode tables are set in the bitmaps
|
2006-10-11 02:20:50 -06:00
|
|
|
*
|
|
|
|
* Return buffer_head on success or NULL in case of failure.
|
|
|
|
*/
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
struct buffer_head *
|
2008-07-11 17:27:31 -06:00
|
|
|
ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2008-09-08 20:25:24 -06:00
|
|
|
struct ext4_group_desc *desc;
|
|
|
|
struct buffer_head *bh = NULL;
|
2007-10-17 00:27:02 -06:00
|
|
|
ext4_fsblk_t bitmap_blk;
|
2006-10-11 02:20:50 -06:00
|
|
|
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
desc = ext4_get_group_desc(sb, block_group, NULL);
|
2006-10-11 02:20:50 -06:00
|
|
|
if (!desc)
|
2007-10-17 00:27:02 -06:00
|
|
|
return NULL;
|
|
|
|
bitmap_blk = ext4_block_bitmap(sb, desc);
|
2008-01-28 21:58:27 -07:00
|
|
|
bh = sb_getblk(sb, bitmap_blk);
|
|
|
|
if (unlikely(!bh)) {
|
2008-04-17 08:38:59 -06:00
|
|
|
ext4_error(sb, __func__,
|
2008-01-28 21:58:27 -07:00
|
|
|
"Cannot read block bitmap - "
|
2009-01-05 20:18:16 -07:00
|
|
|
"block_group = %u, block_bitmap = %llu",
|
2008-08-02 19:21:02 -06:00
|
|
|
block_group, bitmap_blk);
|
2008-01-28 21:58:27 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
2009-01-05 19:49:55 -07:00
|
|
|
|
|
|
|
if (bitmap_uptodate(bh))
|
2008-01-28 21:58:27 -07:00
|
|
|
return bh;
|
|
|
|
|
ext4: fix initialization of UNINIT bitmap blocks
This fixes a bug which caused on-line resizing of filesystems with a
1k blocksize to fail. The root cause of this bug was the fact that if
an uninitalized bitmap block gets read in by userspace (which
e2fsprogs does try to avoid, but can happen when the blocksize is less
than the pagesize and an adjacent blocks is read into memory)
ext4_read_block_bitmap() was erroneously depending on the buffer
uptodate flag to decide whether it needed to initialize the bitmap
block in memory --- i.e., to set the standard set of blocks in use by
a block group (superblock, bitmaps, inode table, etc.). Essentially,
ext4_read_block_bitmap() assumed it was the only routine that might
try to read a block containing a block bitmap, which is simply not
true.
To fix this, ext4_read_block_bitmap() and ext4_read_inode_bitmap()
must always initialize uninitialized bitmap blocks. Once a block or
inode is allocated out of that bitmap, it will be marked as
initialized in the block group descriptor, so in general this won't
result any extra unnecessary work.
Signed-off-by: Frederic Bohe <frederic.bohe@bull.net>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2008-10-10 06:09:18 -06:00
|
|
|
lock_buffer(bh);
|
2009-01-05 19:49:55 -07:00
|
|
|
if (bitmap_uptodate(bh)) {
|
|
|
|
unlock_buffer(bh);
|
|
|
|
return bh;
|
|
|
|
}
|
2008-08-02 19:21:08 -06:00
|
|
|
spin_lock(sb_bgl_lock(EXT4_SB(sb), block_group));
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
|
2008-01-28 21:58:27 -07:00
|
|
|
ext4_init_block_bitmap(sb, bh, block_group, desc);
|
2009-01-05 19:49:55 -07:00
|
|
|
set_bitmap_uptodate(bh);
|
2008-01-28 21:58:27 -07:00
|
|
|
set_buffer_uptodate(bh);
|
2008-08-02 19:21:08 -06:00
|
|
|
spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
|
2009-01-03 20:33:39 -07:00
|
|
|
unlock_buffer(bh);
|
2008-01-28 21:58:27 -07:00
|
|
|
return bh;
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
}
|
2008-08-02 19:21:08 -06:00
|
|
|
spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
|
2009-01-05 19:49:55 -07:00
|
|
|
if (buffer_uptodate(bh)) {
|
|
|
|
/*
|
|
|
|
* if not uninit if bh is uptodate,
|
|
|
|
* bitmap is also uptodate
|
|
|
|
*/
|
|
|
|
set_bitmap_uptodate(bh);
|
|
|
|
unlock_buffer(bh);
|
|
|
|
return bh;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* submit the buffer_head for read. We can
|
|
|
|
* safely mark the bitmap as uptodate now.
|
|
|
|
* We do it here so the bitmap uptodate bit
|
|
|
|
* get set with buffer lock held.
|
|
|
|
*/
|
|
|
|
set_bitmap_uptodate(bh);
|
2008-01-28 21:58:27 -07:00
|
|
|
if (bh_submit_read(bh) < 0) {
|
|
|
|
put_bh(bh);
|
2008-04-17 08:38:59 -06:00
|
|
|
ext4_error(sb, __func__,
|
2006-10-11 02:20:50 -06:00
|
|
|
"Cannot read block bitmap - "
|
2009-01-05 20:18:16 -07:00
|
|
|
"block_group = %u, block_bitmap = %llu",
|
2008-08-02 19:21:02 -06:00
|
|
|
block_group, bitmap_blk);
|
2008-01-28 21:58:27 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
2008-05-15 12:43:20 -06:00
|
|
|
ext4_valid_block_bitmap(sb, desc, block_group, bh);
|
|
|
|
/*
|
|
|
|
* file system mounted not to panic on error,
|
|
|
|
* continue with corrupt bitmap
|
|
|
|
*/
|
2006-10-11 02:20:50 -06:00
|
|
|
return bh;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-01-05 19:36:02 -07:00
|
|
|
* ext4_add_groupblocks() -- Add given blocks to an existing group
|
2006-10-11 02:20:50 -06:00
|
|
|
* @handle: handle to this transaction
|
|
|
|
* @sb: super block
|
2009-01-05 19:36:02 -07:00
|
|
|
* @block: start physcial block to add to the block group
|
2006-10-11 02:20:50 -06:00
|
|
|
* @count: number of blocks to free
|
2008-10-10 07:40:52 -06:00
|
|
|
*
|
2009-01-05 19:36:02 -07:00
|
|
|
* This marks the blocks as free in the bitmap. We ask the
|
|
|
|
* mballoc to reload the buddy after this by setting group
|
|
|
|
* EXT4_GROUP_INFO_NEED_INIT_BIT flag
|
2006-10-11 02:20:50 -06:00
|
|
|
*/
|
2009-01-05 19:36:02 -07:00
|
|
|
void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,
|
|
|
|
ext4_fsblk_t block, unsigned long count)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
|
|
|
struct buffer_head *bitmap_bh = NULL;
|
|
|
|
struct buffer_head *gd_bh;
|
2008-01-28 21:58:27 -07:00
|
|
|
ext4_group_t block_group;
|
2006-10-11 02:20:53 -06:00
|
|
|
ext4_grpblk_t bit;
|
2008-11-04 22:14:04 -07:00
|
|
|
unsigned int i;
|
2008-09-08 20:25:24 -06:00
|
|
|
struct ext4_group_desc *desc;
|
|
|
|
struct ext4_super_block *es;
|
2006-10-11 02:20:53 -06:00
|
|
|
struct ext4_sb_info *sbi;
|
2009-01-05 20:20:24 -07:00
|
|
|
int err = 0, ret, blk_free_count;
|
2009-01-05 19:36:02 -07:00
|
|
|
ext4_grpblk_t blocks_freed;
|
|
|
|
struct ext4_group_info *grp;
|
2006-10-11 02:20:50 -06:00
|
|
|
|
2006-10-11 02:20:53 -06:00
|
|
|
sbi = EXT4_SB(sb);
|
2006-10-11 02:20:50 -06:00
|
|
|
es = sbi->s_es;
|
2009-01-05 19:36:02 -07:00
|
|
|
ext4_debug("Adding block(s) %llu-%llu\n", block, block + count - 1);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
2006-10-11 02:21:05 -06:00
|
|
|
ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
|
2009-01-05 19:36:19 -07:00
|
|
|
grp = ext4_get_group_info(sb, block_group);
|
2006-10-11 02:20:50 -06:00
|
|
|
/*
|
|
|
|
* Check to see if we are freeing blocks across a group
|
|
|
|
* boundary.
|
|
|
|
*/
|
2006-10-11 02:20:53 -06:00
|
|
|
if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) {
|
2009-01-05 19:36:02 -07:00
|
|
|
goto error_return;
|
2006-10-11 02:20:50 -06:00
|
|
|
}
|
2008-07-11 17:27:31 -06:00
|
|
|
bitmap_bh = ext4_read_block_bitmap(sb, block_group);
|
2006-10-11 02:20:50 -06:00
|
|
|
if (!bitmap_bh)
|
|
|
|
goto error_return;
|
2008-09-08 20:25:24 -06:00
|
|
|
desc = ext4_get_group_desc(sb, block_group, &gd_bh);
|
2006-10-11 02:20:50 -06:00
|
|
|
if (!desc)
|
|
|
|
goto error_return;
|
|
|
|
|
2006-10-11 02:21:15 -06:00
|
|
|
if (in_range(ext4_block_bitmap(sb, desc), block, count) ||
|
|
|
|
in_range(ext4_inode_bitmap(sb, desc), block, count) ||
|
|
|
|
in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||
|
|
|
|
in_range(block + count - 1, ext4_inode_table(sb, desc),
|
2008-01-28 21:58:27 -07:00
|
|
|
sbi->s_itb_per_group)) {
|
2009-01-05 19:36:02 -07:00
|
|
|
ext4_error(sb, __func__,
|
|
|
|
"Adding blocks in system zones - "
|
2008-09-08 20:25:24 -06:00
|
|
|
"Block = %llu, count = %lu",
|
|
|
|
block, count);
|
2008-01-28 21:58:27 -07:00
|
|
|
goto error_return;
|
|
|
|
}
|
2006-10-11 02:20:50 -06:00
|
|
|
|
|
|
|
/*
|
2009-01-05 19:36:02 -07:00
|
|
|
* We are about to add blocks to the bitmap,
|
2006-10-11 02:20:50 -06:00
|
|
|
* so we need undo access.
|
|
|
|
*/
|
|
|
|
BUFFER_TRACE(bitmap_bh, "getting undo access");
|
2006-10-11 02:20:53 -06:00
|
|
|
err = ext4_journal_get_undo_access(handle, bitmap_bh);
|
2006-10-11 02:20:50 -06:00
|
|
|
if (err)
|
|
|
|
goto error_return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We are about to modify some metadata. Call the journal APIs
|
|
|
|
* to unshare ->b_data if a currently-committing transaction is
|
|
|
|
* using it
|
|
|
|
*/
|
|
|
|
BUFFER_TRACE(gd_bh, "get_write_access");
|
2006-10-11 02:20:53 -06:00
|
|
|
err = ext4_journal_get_write_access(handle, gd_bh);
|
2006-10-11 02:20:50 -06:00
|
|
|
if (err)
|
|
|
|
goto error_return;
|
2009-01-05 19:36:19 -07:00
|
|
|
/*
|
|
|
|
* make sure we don't allow a parallel init on other groups in the
|
|
|
|
* same buddy cache
|
|
|
|
*/
|
|
|
|
down_write(&grp->alloc_sem);
|
2009-01-05 19:36:02 -07:00
|
|
|
for (i = 0, blocks_freed = 0; i < count; i++) {
|
2006-10-11 02:20:50 -06:00
|
|
|
BUFFER_TRACE(bitmap_bh, "clear bit");
|
2006-10-11 02:20:53 -06:00
|
|
|
if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
|
2006-10-11 02:20:50 -06:00
|
|
|
bit + i, bitmap_bh->b_data)) {
|
2008-04-17 08:38:59 -06:00
|
|
|
ext4_error(sb, __func__,
|
2006-10-11 02:21:11 -06:00
|
|
|
"bit already cleared for block %llu",
|
2006-10-11 02:21:10 -06:00
|
|
|
(ext4_fsblk_t)(block + i));
|
2006-10-11 02:20:50 -06:00
|
|
|
BUFFER_TRACE(bitmap_bh, "bit already cleared");
|
|
|
|
} else {
|
2009-01-05 19:36:02 -07:00
|
|
|
blocks_freed++;
|
2006-10-11 02:20:50 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_lock(sb_bgl_lock(sbi, block_group));
|
2009-01-05 20:20:24 -07:00
|
|
|
blk_free_count = blocks_freed + ext4_free_blks_count(sb, desc);
|
|
|
|
ext4_free_blks_set(sb, desc, blk_free_count);
|
Ext4: Uninitialized Block Groups
In pass1 of e2fsck, every inode table in the fileystem is scanned and checked,
regardless of whether it is in use. This is this the most time consuming part
of the filesystem check. The unintialized block group feature can greatly
reduce e2fsck time by eliminating checking of uninitialized inodes.
With this feature, there is a a high water mark of used inodes for each block
group. Block and inode bitmaps can be uninitialized on disk via a flag in the
group descriptor to avoid reading or scanning them at e2fsck time. A checksum
of each group descriptor is used to ensure that corruption in the group
descriptor's bit flags does not cause incorrect operation.
The feature is enabled through a mkfs option
mke2fs /dev/ -O uninit_groups
A patch adding support for uninitialized block groups to e2fsprogs tools has
been posted to the linux-ext4 mailing list.
The patches have been stress tested with fsstress and fsx. In performance
tests testing e2fsck time, we have seen that e2fsck time on ext3 grows
linearly with the total number of inodes in the filesytem. In ext4 with the
uninitialized block groups feature, the e2fsck time is constant, based
solely on the number of used inodes rather than the total inode count.
Since typical ext4 filesystems only use 1-10% of their inodes, this feature can
greatly reduce e2fsck time for users. With performance improvement of 2-20
times, depending on how full the filesystem is.
The attached graph shows the major improvements in e2fsck times in filesystems
with a large total inode count, but few inodes in use.
In each group descriptor if we have
EXT4_BG_INODE_UNINIT set in bg_flags:
Inode table is not initialized/used in this group. So we can skip
the consistency check during fsck.
EXT4_BG_BLOCK_UNINIT set in bg_flags:
No block in the group is used. So we can skip the block bitmap
verification for this group.
We also add two new fields to group descriptor as a part of
uninitialized group patch.
__le16 bg_itable_unused; /* Unused inodes count */
__le16 bg_checksum; /* crc16(sb_uuid+group+desc) */
bg_itable_unused:
If we have EXT4_BG_INODE_UNINIT not set in bg_flags
then bg_itable_unused will give the offset within
the inode table till the inodes are used. This can be
used by fsck to skip list of inodes that are marked unused.
bg_checksum:
Now that we depend on bg_flags and bg_itable_unused to determine
the block and inode usage, we need to make sure group descriptor
is not corrupt. We add checksum to group descriptor to
detect corruption. If the descriptor is found to be corrupt, we
mark all the blocks and inodes in the group used.
Signed-off-by: Avantika Mathur <mathur@us.ibm.com>
Signed-off-by: Andreas Dilger <adilger@clusterfs.com>
Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
2007-10-16 16:38:25 -06:00
|
|
|
desc->bg_checksum = ext4_group_desc_csum(sbi, block_group, desc);
|
2006-10-11 02:20:50 -06:00
|
|
|
spin_unlock(sb_bgl_lock(sbi, block_group));
|
2009-01-05 19:36:02 -07:00
|
|
|
percpu_counter_add(&sbi->s_freeblocks_counter, blocks_freed);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
2008-07-11 17:27:31 -06:00
|
|
|
if (sbi->s_log_groups_per_flex) {
|
|
|
|
ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
|
|
|
|
spin_lock(sb_bgl_lock(sbi, flex_group));
|
2009-01-05 19:36:02 -07:00
|
|
|
sbi->s_flex_groups[flex_group].free_blocks += blocks_freed;
|
2008-07-11 17:27:31 -06:00
|
|
|
spin_unlock(sb_bgl_lock(sbi, flex_group));
|
|
|
|
}
|
2009-01-05 19:36:19 -07:00
|
|
|
/*
|
|
|
|
* request to reload the buddy with the
|
|
|
|
* new bitmap information
|
|
|
|
*/
|
|
|
|
set_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &(grp->bb_state));
|
|
|
|
ext4_mb_update_group_info(grp, blocks_freed);
|
|
|
|
up_write(&grp->alloc_sem);
|
2008-07-11 17:27:31 -06:00
|
|
|
|
2006-10-11 02:20:50 -06:00
|
|
|
/* We dirtied the bitmap block */
|
|
|
|
BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
|
2009-01-06 22:06:22 -07:00
|
|
|
err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
|
|
|
/* And the group descriptor block */
|
|
|
|
BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
|
2009-01-06 22:06:22 -07:00
|
|
|
ret = ext4_handle_dirty_metadata(handle, NULL, gd_bh);
|
2009-01-05 19:36:02 -07:00
|
|
|
if (!err)
|
|
|
|
err = ret;
|
2006-10-11 02:20:50 -06:00
|
|
|
sb->s_dirt = 1;
|
2009-01-05 19:36:02 -07:00
|
|
|
|
2006-10-11 02:20:50 -06:00
|
|
|
error_return:
|
|
|
|
brelse(bitmap_bh);
|
2006-10-11 02:20:53 -06:00
|
|
|
ext4_std_error(sb, err);
|
2006-10-11 02:20:50 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-10-11 02:20:53 -06:00
|
|
|
* ext4_free_blocks() -- Free given blocks and update quota
|
2006-10-11 02:20:50 -06:00
|
|
|
* @handle: handle for this transaction
|
|
|
|
* @inode: inode
|
|
|
|
* @block: start physical block to free
|
|
|
|
* @count: number of blocks to count
|
2008-01-28 22:19:52 -07:00
|
|
|
* @metadata: Are these metadata blocks
|
2006-10-11 02:20:50 -06:00
|
|
|
*/
|
2006-10-11 02:20:53 -06:00
|
|
|
void ext4_free_blocks(handle_t *handle, struct inode *inode,
|
2008-01-28 22:19:52 -07:00
|
|
|
ext4_fsblk_t block, unsigned long count,
|
|
|
|
int metadata)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2008-09-08 20:25:24 -06:00
|
|
|
struct super_block *sb;
|
2006-10-11 02:20:50 -06:00
|
|
|
unsigned long dquot_freed_blocks;
|
|
|
|
|
2008-01-28 22:19:52 -07:00
|
|
|
/* this isn't the right place to decide whether block is metadata
|
|
|
|
* inode.c/extents.c knows better, but for safety ... */
|
2008-10-10 18:13:31 -06:00
|
|
|
if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
|
|
|
|
metadata = 1;
|
|
|
|
|
|
|
|
/* We need to make sure we don't reuse
|
|
|
|
* block released untill the transaction commit.
|
|
|
|
* writeback mode have weak data consistency so
|
|
|
|
* don't force data as metadata when freeing block
|
|
|
|
* for writeback mode.
|
|
|
|
*/
|
|
|
|
if (metadata == 0 && !ext4_should_writeback_data(inode))
|
2008-01-28 22:19:52 -07:00
|
|
|
metadata = 1;
|
|
|
|
|
2006-10-11 02:20:50 -06:00
|
|
|
sb = inode->i_sb;
|
2008-01-28 22:19:52 -07:00
|
|
|
|
2008-10-10 07:40:52 -06:00
|
|
|
ext4_mb_free_blocks(handle, inode, block, count,
|
|
|
|
metadata, &dquot_freed_blocks);
|
2006-10-11 02:20:50 -06:00
|
|
|
if (dquot_freed_blocks)
|
|
|
|
DQUOT_FREE_BLOCK(inode, dquot_freed_blocks);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-10-27 22:08:12 -06:00
|
|
|
/**
|
|
|
|
* ext4_has_free_blocks()
|
|
|
|
* @sbi: in-core super block structure.
|
|
|
|
* @nblocks: number of needed blocks
|
|
|
|
*
|
|
|
|
* Check if filesystem has nblocks free & available for allocation.
|
|
|
|
* On success return 1, return 0 on failure.
|
|
|
|
*/
|
|
|
|
int ext4_has_free_blocks(struct ext4_sb_info *sbi, s64 nblocks)
|
2008-10-09 08:56:23 -06:00
|
|
|
{
|
2008-10-27 22:08:17 -06:00
|
|
|
s64 free_blocks, dirty_blocks, root_blocks;
|
2008-10-09 08:56:23 -06:00
|
|
|
struct percpu_counter *fbc = &sbi->s_freeblocks_counter;
|
2008-10-10 07:39:00 -06:00
|
|
|
struct percpu_counter *dbc = &sbi->s_dirtyblocks_counter;
|
2008-10-09 08:56:23 -06:00
|
|
|
|
2008-10-10 07:39:00 -06:00
|
|
|
free_blocks = percpu_counter_read_positive(fbc);
|
|
|
|
dirty_blocks = percpu_counter_read_positive(dbc);
|
2008-10-27 22:08:17 -06:00
|
|
|
root_blocks = ext4_r_blocks_count(sbi->s_es);
|
2008-10-09 08:56:23 -06:00
|
|
|
|
2008-10-10 07:39:00 -06:00
|
|
|
if (free_blocks - (nblocks + root_blocks + dirty_blocks) <
|
|
|
|
EXT4_FREEBLOCKS_WATERMARK) {
|
2008-12-09 14:14:14 -07:00
|
|
|
free_blocks = percpu_counter_sum_positive(fbc);
|
|
|
|
dirty_blocks = percpu_counter_sum_positive(dbc);
|
2008-10-10 07:39:00 -06:00
|
|
|
if (dirty_blocks < 0) {
|
|
|
|
printk(KERN_CRIT "Dirty block accounting "
|
|
|
|
"went wrong %lld\n",
|
2008-10-29 15:13:08 -06:00
|
|
|
(long long)dirty_blocks);
|
2008-10-10 07:39:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Check whether we have space after
|
2008-10-27 22:08:17 -06:00
|
|
|
* accounting for current dirty blocks & root reserved blocks.
|
2008-10-10 07:39:00 -06:00
|
|
|
*/
|
2008-10-27 22:08:17 -06:00
|
|
|
if (free_blocks >= ((root_blocks + nblocks) + dirty_blocks))
|
|
|
|
return 1;
|
2008-10-09 08:56:23 -06:00
|
|
|
|
2008-10-27 22:08:17 -06:00
|
|
|
/* Hm, nope. Are (enough) root reserved blocks available? */
|
2008-11-13 16:38:51 -07:00
|
|
|
if (sbi->s_resuid == current_fsuid() ||
|
2008-10-27 22:08:17 -06:00
|
|
|
((sbi->s_resgid != 0) && in_group_p(sbi->s_resgid)) ||
|
|
|
|
capable(CAP_SYS_RESOURCE)) {
|
|
|
|
if (free_blocks >= (nblocks + dirty_blocks))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2008-10-09 08:56:23 -06:00
|
|
|
}
|
|
|
|
|
2008-10-27 22:08:12 -06:00
|
|
|
int ext4_claim_free_blocks(struct ext4_sb_info *sbi,
|
2008-10-08 21:12:24 -06:00
|
|
|
s64 nblocks)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2008-10-27 22:08:12 -06:00
|
|
|
if (ext4_has_free_blocks(sbi, nblocks)) {
|
|
|
|
percpu_counter_add(&sbi->s_dirtyblocks_counter, nblocks);
|
2008-08-19 19:16:54 -06:00
|
|
|
return 0;
|
2008-10-27 22:08:12 -06:00
|
|
|
} else
|
|
|
|
return -ENOSPC;
|
2008-10-09 08:56:23 -06:00
|
|
|
}
|
2008-07-11 17:27:31 -06:00
|
|
|
|
2006-10-11 02:20:50 -06:00
|
|
|
/**
|
2006-10-11 02:20:53 -06:00
|
|
|
* ext4_should_retry_alloc()
|
2006-10-11 02:20:50 -06:00
|
|
|
* @sb: super block
|
|
|
|
* @retries number of attemps has been made
|
|
|
|
*
|
2006-10-11 02:20:53 -06:00
|
|
|
* ext4_should_retry_alloc() is called when ENOSPC is returned, and if
|
2006-10-11 02:20:50 -06:00
|
|
|
* it is profitable to retry the operation, this function will wait
|
|
|
|
* for the current or commiting transaction to complete, and then
|
|
|
|
* return TRUE.
|
|
|
|
*
|
|
|
|
* if the total number of retries exceed three times, return FALSE.
|
|
|
|
*/
|
2006-10-11 02:20:53 -06:00
|
|
|
int ext4_should_retry_alloc(struct super_block *sb, int *retries)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2009-02-25 22:57:35 -07:00
|
|
|
if (!ext4_has_free_blocks(EXT4_SB(sb), 1) ||
|
|
|
|
(*retries)++ > 3 ||
|
|
|
|
!EXT4_SB(sb)->s_journal)
|
2006-10-11 02:20:50 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
|
|
|
|
|
2006-10-11 02:21:01 -06:00
|
|
|
return jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal);
|
2006-10-11 02:20:50 -06:00
|
|
|
}
|
|
|
|
|
2008-07-11 17:27:31 -06:00
|
|
|
/*
|
2008-07-14 15:52:37 -06:00
|
|
|
* ext4_new_meta_blocks() -- allocate block for meta data (indexing) blocks
|
2008-07-11 17:27:31 -06:00
|
|
|
*
|
|
|
|
* @handle: handle to this transaction
|
|
|
|
* @inode: file inode
|
|
|
|
* @goal: given target block(filesystem wide)
|
2008-12-12 10:41:28 -07:00
|
|
|
* @count: pointer to total number of blocks needed
|
2008-07-11 17:27:31 -06:00
|
|
|
* @errp: error code
|
|
|
|
*
|
2008-12-12 10:41:28 -07:00
|
|
|
* Return 1st allocated block number on success, *count stores total account
|
2008-07-14 15:52:37 -06:00
|
|
|
* error stores in errp pointer
|
2008-07-11 17:27:31 -06:00
|
|
|
*/
|
2008-07-14 15:52:37 -06:00
|
|
|
ext4_fsblk_t ext4_new_meta_blocks(handle_t *handle, struct inode *inode,
|
|
|
|
ext4_fsblk_t goal, unsigned long *count, int *errp)
|
2008-07-11 17:27:31 -06:00
|
|
|
{
|
2008-12-12 10:41:28 -07:00
|
|
|
struct ext4_allocation_request ar;
|
2008-07-14 15:52:37 -06:00
|
|
|
ext4_fsblk_t ret;
|
2008-12-12 10:41:28 -07:00
|
|
|
|
|
|
|
memset(&ar, 0, sizeof(ar));
|
|
|
|
/* Fill with neighbour allocated blocks */
|
|
|
|
ar.inode = inode;
|
|
|
|
ar.goal = goal;
|
|
|
|
ar.len = count ? *count : 1;
|
|
|
|
|
|
|
|
ret = ext4_mb_new_blocks(handle, &ar, errp);
|
|
|
|
if (count)
|
|
|
|
*count = ar.len;
|
|
|
|
|
2008-07-14 15:52:37 -06:00
|
|
|
/*
|
|
|
|
* Account for the allocated meta blocks
|
|
|
|
*/
|
2008-09-08 21:08:40 -06:00
|
|
|
if (!(*errp) && EXT4_I(inode)->i_delalloc_reserved_flag) {
|
2008-07-14 15:52:37 -06:00
|
|
|
spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
|
2008-12-12 10:41:28 -07:00
|
|
|
EXT4_I(inode)->i_allocated_meta_blocks += ar.len;
|
2008-07-14 15:52:37 -06:00
|
|
|
spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
|
|
|
|
}
|
|
|
|
return ret;
|
2008-07-11 17:27:31 -06:00
|
|
|
}
|
|
|
|
|
2006-10-11 02:20:50 -06:00
|
|
|
/**
|
2006-10-11 02:20:53 -06:00
|
|
|
* ext4_count_free_blocks() -- count filesystem free blocks
|
2006-10-11 02:20:50 -06:00
|
|
|
* @sb: superblock
|
|
|
|
*
|
|
|
|
* Adds up the number of free blocks from each block group.
|
|
|
|
*/
|
2006-10-11 02:20:53 -06:00
|
|
|
ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2006-10-11 02:20:53 -06:00
|
|
|
ext4_fsblk_t desc_count;
|
|
|
|
struct ext4_group_desc *gdp;
|
2008-01-28 21:58:27 -07:00
|
|
|
ext4_group_t i;
|
|
|
|
ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
|
2006-10-11 02:20:53 -06:00
|
|
|
#ifdef EXT4FS_DEBUG
|
|
|
|
struct ext4_super_block *es;
|
|
|
|
ext4_fsblk_t bitmap_count;
|
2008-11-04 22:14:04 -07:00
|
|
|
unsigned int x;
|
2006-10-11 02:20:50 -06:00
|
|
|
struct buffer_head *bitmap_bh = NULL;
|
|
|
|
|
2006-10-11 02:20:53 -06:00
|
|
|
es = EXT4_SB(sb)->s_es;
|
2006-10-11 02:20:50 -06:00
|
|
|
desc_count = 0;
|
|
|
|
bitmap_count = 0;
|
|
|
|
gdp = NULL;
|
|
|
|
|
|
|
|
smp_rmb();
|
|
|
|
for (i = 0; i < ngroups; i++) {
|
2006-10-11 02:20:53 -06:00
|
|
|
gdp = ext4_get_group_desc(sb, i, NULL);
|
2006-10-11 02:20:50 -06:00
|
|
|
if (!gdp)
|
|
|
|
continue;
|
2009-01-26 17:26:26 -07:00
|
|
|
desc_count += ext4_free_blks_count(sb, gdp);
|
2006-10-11 02:20:50 -06:00
|
|
|
brelse(bitmap_bh);
|
2008-07-11 17:27:31 -06:00
|
|
|
bitmap_bh = ext4_read_block_bitmap(sb, i);
|
2006-10-11 02:20:50 -06:00
|
|
|
if (bitmap_bh == NULL)
|
|
|
|
continue;
|
|
|
|
|
2006-10-11 02:20:53 -06:00
|
|
|
x = ext4_count_free(bitmap_bh, sb->s_blocksize);
|
2009-01-26 17:26:26 -07:00
|
|
|
printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n",
|
|
|
|
i, ext4_free_blks_count(sb, gdp), x);
|
2006-10-11 02:20:50 -06:00
|
|
|
bitmap_count += x;
|
|
|
|
}
|
|
|
|
brelse(bitmap_bh);
|
2008-09-08 21:00:52 -06:00
|
|
|
printk(KERN_DEBUG "ext4_count_free_blocks: stored = %llu"
|
|
|
|
", computed = %llu, %llu\n", ext4_free_blocks_count(es),
|
|
|
|
desc_count, bitmap_count);
|
2006-10-11 02:20:50 -06:00
|
|
|
return bitmap_count;
|
|
|
|
#else
|
|
|
|
desc_count = 0;
|
|
|
|
smp_rmb();
|
|
|
|
for (i = 0; i < ngroups; i++) {
|
2006-10-11 02:20:53 -06:00
|
|
|
gdp = ext4_get_group_desc(sb, i, NULL);
|
2006-10-11 02:20:50 -06:00
|
|
|
if (!gdp)
|
|
|
|
continue;
|
2009-01-05 20:20:24 -07:00
|
|
|
desc_count += ext4_free_blks_count(sb, gdp);
|
2006-10-11 02:20:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return desc_count;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-01-28 21:58:27 -07:00
|
|
|
static inline int test_root(ext4_group_t a, int b)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
|
|
|
int num = b;
|
|
|
|
|
|
|
|
while (a > num)
|
|
|
|
num *= b;
|
|
|
|
return num == a;
|
|
|
|
}
|
|
|
|
|
2008-01-28 21:58:27 -07:00
|
|
|
static int ext4_group_sparse(ext4_group_t group)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
|
|
|
if (group <= 1)
|
|
|
|
return 1;
|
|
|
|
if (!(group & 1))
|
|
|
|
return 0;
|
|
|
|
return (test_root(group, 7) || test_root(group, 5) ||
|
|
|
|
test_root(group, 3));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-10-11 02:20:53 -06:00
|
|
|
* ext4_bg_has_super - number of blocks used by the superblock in group
|
2006-10-11 02:20:50 -06:00
|
|
|
* @sb: superblock for filesystem
|
|
|
|
* @group: group number to check
|
|
|
|
*
|
|
|
|
* Return the number of blocks used by the superblock (primary or backup)
|
|
|
|
* in this group. Currently this will be only 0 or 1.
|
|
|
|
*/
|
2008-01-28 21:58:27 -07:00
|
|
|
int ext4_bg_has_super(struct super_block *sb, ext4_group_t group)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2006-10-11 02:20:53 -06:00
|
|
|
if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
|
|
|
|
EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER) &&
|
|
|
|
!ext4_group_sparse(group))
|
2006-10-11 02:20:50 -06:00
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-01-28 21:58:27 -07:00
|
|
|
static unsigned long ext4_bg_num_gdb_meta(struct super_block *sb,
|
|
|
|
ext4_group_t group)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2006-10-11 02:20:53 -06:00
|
|
|
unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
|
2008-01-28 21:58:27 -07:00
|
|
|
ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb);
|
|
|
|
ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1;
|
2006-10-11 02:20:50 -06:00
|
|
|
|
|
|
|
if (group == first || group == first + 1 || group == last)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-28 21:58:27 -07:00
|
|
|
static unsigned long ext4_bg_num_gdb_nometa(struct super_block *sb,
|
|
|
|
ext4_group_t group)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
2008-02-06 02:40:17 -07:00
|
|
|
return ext4_bg_has_super(sb, group) ? EXT4_SB(sb)->s_gdb_count : 0;
|
2006-10-11 02:20:50 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-10-11 02:20:53 -06:00
|
|
|
* ext4_bg_num_gdb - number of blocks used by the group table in group
|
2006-10-11 02:20:50 -06:00
|
|
|
* @sb: superblock for filesystem
|
|
|
|
* @group: group number to check
|
|
|
|
*
|
|
|
|
* Return the number of blocks used by the group descriptor table
|
|
|
|
* (primary or backup) in this group. In the future there may be a
|
|
|
|
* different number of descriptor blocks in each group.
|
|
|
|
*/
|
2008-01-28 21:58:27 -07:00
|
|
|
unsigned long ext4_bg_num_gdb(struct super_block *sb, ext4_group_t group)
|
2006-10-11 02:20:50 -06:00
|
|
|
{
|
|
|
|
unsigned long first_meta_bg =
|
2006-10-11 02:20:53 -06:00
|
|
|
le32_to_cpu(EXT4_SB(sb)->s_es->s_first_meta_bg);
|
|
|
|
unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
2006-10-11 02:20:53 -06:00
|
|
|
if (!EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) ||
|
2006-10-11 02:20:50 -06:00
|
|
|
metagroup < first_meta_bg)
|
2008-09-08 20:25:24 -06:00
|
|
|
return ext4_bg_num_gdb_nometa(sb, group);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
2006-10-11 02:20:53 -06:00
|
|
|
return ext4_bg_num_gdb_meta(sb,group);
|
2006-10-11 02:20:50 -06:00
|
|
|
|
|
|
|
}
|
2008-10-10 07:40:52 -06:00
|
|
|
|