group.h File Reference

Go to the source code of this file.

Macros
#define	ext4_free_blocks_after_init(sb, group, desc)    ext4_init_block_bitmap(sb, NULL, group, desc)

Functions
__le16	ext4_group_desc_csum (struct ext4_sb_info *sbi, __u32 group, struct ext4_group_desc *gdp)
int	ext4_group_desc_csum_verify (struct ext4_sb_info *sbi, __u32 group, struct ext4_group_desc *gdp)
struct buffer_head *	ext4_read_block_bitmap (struct super_block *sb, ext4_group_t block_group)
unsigned	ext4_init_block_bitmap (struct super_block *sb, struct buffer_head *bh, ext4_group_t group, struct ext4_group_desc *desc)
unsigned	ext4_init_inode_bitmap (struct super_block *sb, struct buffer_head *bh, ext4_group_t group, struct ext4_group_desc *desc)
void	mark_bitmap_end (int start_bit, int end_bit, char *bitmap)

Macro Definition Documentation

ext4_free_blocks_after_init

#define ext4_free_blocks_after_init	(		sb,
			group,
			desc
	)		ext4_init_block_bitmap(sb, NULL, group, desc)

Definition at line 22 of file group.h.

Function Documentation

ext4_group_desc_csum()

__le16 ext4_group_desc_csum	(	struct ext4_sb_info *	sbi,
		__u32	group,
		struct ext4_group_desc *	gdp
	)

ext4_group_desc_csum_verify()

int ext4_group_desc_csum_verify	(	struct ext4_sb_info *	sbi,
		__u32	group,
		struct ext4_group_desc *	gdp
	)

ext4_init_block_bitmap()

unsigned ext4_init_block_bitmap	(	struct super_block *	sb,
		struct buffer_head *	bh,
		ext4_group_t	group,
		struct ext4_group_desc *	desc
	)

Definition at line 2877 of file generic.c.

{
    int bit, bit_max;
    unsigned free_blocks, group_blocks;
    struct ext3_sb_info *sbi = EXT3_SB(sb);
 
    if (bh) {
        mark_buffer_dirty(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)) {
            ext4_error(sb, __FUNCTION__,
                       "Checksum bad for group %u", block_group);
            ext4_free_blks_set(sb, gdp, 0);
            ext4_free_inodes_set(sb, gdp, 0);
            ext4_itable_unused_set(sb, gdp, 0);
            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 = ext3_bg_has_super(sb, block_group);
 
    if (!EXT3_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 */
        bit_max += ext4_bg_num_gdb(sb, block_group);
    }
 
    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 = (unsigned int)(ext3_blocks_count(sbi->s_es) -
                                      le32_to_cpu(sbi->s_es->s_first_data_block) -
                                      (EXT4_BLOCKS_PER_GROUP(sb) * (sbi->s_groups_count - 1)));
    } else {
        group_blocks = EXT4_BLOCKS_PER_GROUP(sb);
    }
 
    free_blocks = group_blocks - bit_max;
 
    if (bh) {
        ext4_fsblk_t start, tmp;
        int flex_bg = 0;
 
        for (bit = 0; bit < bit_max; bit++)
            ext4_set_bit(bit, bh->b_data);
 
        start = ext3_group_first_block_no(sb, block_group);
 
        if (EXT3_HAS_INCOMPAT_FEATURE(sb,
                                      EXT4_FEATURE_INCOMPAT_FLEX_BG))
            flex_bg = 1;
 
        /* 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);
        }
        /*
         * 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);
    }
    return free_blocks - ext4_group_used_meta_blocks(sb, block_group);
}

Referenced by Ext2NewBlock(), and Ext2NewInode().

ext4_init_inode_bitmap()

unsigned ext4_init_inode_bitmap	(	struct super_block *	sb,
		struct buffer_head *	bh,
		ext4_group_t	group,
		struct ext4_group_desc *	desc
	)

Definition at line 2786 of file generic.c.

{
    struct ext3_sb_info *sbi = EXT3_SB(sb);
 
    mark_buffer_dirty(bh);
 
    /* If checksum is bad mark all blocks and inodes use to prevent
     * allocation, essentially implementing a per-group read-only flag. */
    if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
        ext4_error(sb, __FUNCTION__, "Checksum bad for group %u",
                   block_group);
        ext4_free_blks_set(sb, gdp, 0);
        ext4_free_inodes_set(sb, gdp, 0);
        ext4_itable_unused_set(sb, gdp, 0);
        memset(bh->b_data, 0xff, sb->s_blocksize);
        return 0;
    }
 
    memset(bh->b_data, 0, (EXT4_INODES_PER_GROUP(sb) + 7) / 8);
    mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), sb->s_blocksize * 8,
                    bh->b_data);
    ext4_itable_unused_set(sb, gdp, EXT4_INODES_PER_GROUP(sb));
 
    return EXT4_INODES_PER_GROUP(sb);
}

Referenced by Ext2NewInode().

ext4_read_block_bitmap()

struct buffer_head * ext4_read_block_bitmap	(	struct super_block *	sb,
		ext4_group_t	block_group
	)

mark_bitmap_end()

void mark_bitmap_end	(	int	start_bit,
		int	end_bit,
		char *	bitmap
	)

Definition at line 2771 of file generic.c.

{
    int i;
 
    if (start_bit >= end_bit)
        return;
 
    DEBUG(DL_INF, ("mark end bits +%d through +%d used\n", start_bit, end_bit));
    for (i = start_bit; (unsigned)i < ((start_bit + 7) & ~7UL); i++)
        ext4_set_bit(i, bitmap);
    if (i < end_bit)
        memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);
}

Referenced by ext4_init_block_bitmap(), and ext4_init_inode_bitmap().