Difuse/u-boot
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

ext4: Rename block group descriptor table from gd to bgd

Browse source 
On x86 machines gd is unfortunately a #define, so we should avoid using
gd for anything. This patch changes uses of gd to bgd so that ext4fs
can be used on x86.

A better fix would be to remove the #define in x86, but I'm not sure
how to do that.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass 2012-10-03 11:37:49 +00:00 committed by Tom Rini
parent bb64d1c92f
commit 73c15c634d
3 changed files with 95 additions and 91 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

85
fs/ext4/ext4_common.c
View file

@ -314,7 +314,7 @@ int ext4fs_checksum_update(unsigned int i)
struct ext_filesystem *fs = get_fs(); struct ext_filesystem *fs = get_fs();
__u16 crc = 0; __u16 crc = 0;
desc = (struct ext2_block_group *)&fs->gd[i]; desc = (struct ext2_block_group *)&fs->bgd[i];
if (fs->sb->feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { if (fs->sb->feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) {
int offset = offsetof(struct ext2_block_group, bg_checksum); int offset = offsetof(struct ext2_block_group, bg_checksum);
@ -874,17 +874,17 @@ long int ext4fs_get_new_blk_no(void)
char *zero_buffer = zalloc(fs->blksz); char *zero_buffer = zalloc(fs->blksz);
if (!journal_buffer || !zero_buffer) if (!journal_buffer || !zero_buffer)
goto fail; goto fail;
struct ext2_block_group *gd = (struct ext2_block_group *)fs->gdtable; struct ext2_block_group *bgd = (struct ext2_block_group *)fs->gdtable;
if (fs->first_pass_bbmap == 0) { if (fs->first_pass_bbmap == 0) {
for (i = 0; i < fs->no_blkgrp; i++) { for (i = 0; i < fs->no_blkgrp; i++) {
if (gd[i].free_blocks) { if (bgd[i].free_blocks) {
if (gd[i].bg_flags & EXT4_BG_BLOCK_UNINIT) { if (bgd[i].bg_flags & EXT4_BG_BLOCK_UNINIT) {
put_ext4(((uint64_t) (gd[i].block_id * put_ext4(((uint64_t) (bgd[i].block_id *
fs->blksz)), fs->blksz)),
zero_buffer, fs->blksz); zero_buffer, fs->blksz);
gd[i].bg_flags = bgd[i].bg_flags =
gd[i]. bgd[i].
bg_flags & ~EXT4_BG_BLOCK_UNINIT; bg_flags & ~EXT4_BG_BLOCK_UNINIT;
memcpy(fs->blk_bmaps[i], zero_buffer, memcpy(fs->blk_bmaps[i], zero_buffer,
fs->blksz); fs->blksz);
@ -897,16 +897,16 @@ long int ext4fs_get_new_blk_no(void)
fs->curr_blkno = fs->curr_blkno + fs->curr_blkno = fs->curr_blkno +
(i * fs->blksz * 8); (i * fs->blksz * 8);
fs->first_pass_bbmap++; fs->first_pass_bbmap++;
gd[i].free_blocks--; bgd[i].free_blocks--;
fs->sb->free_blocks--; fs->sb->free_blocks--;
status = ext4fs_devread(gd[i].block_id * status = ext4fs_devread(bgd[i].block_id *
fs->sect_perblk, 0, fs->sect_perblk, 0,
fs->blksz, fs->blksz,
journal_buffer); journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[i].block_id)) bgd[i].block_id))
goto fail; goto fail;
goto success; goto success;
} else { } else {
@ -935,19 +935,19 @@ restart:
if (bg_idx >= fs->no_blkgrp) if (bg_idx >= fs->no_blkgrp)
goto fail; goto fail;
if (gd[bg_idx].free_blocks == 0) { if (bgd[bg_idx].free_blocks == 0) {
debug("block group %u is full. Skipping\n", bg_idx); debug("block group %u is full. Skipping\n", bg_idx);
fs->curr_blkno = fs->curr_blkno + blk_per_grp; fs->curr_blkno = fs->curr_blkno + blk_per_grp;
fs->curr_blkno--; fs->curr_blkno--;
goto restart; goto restart;
} }
if (gd[bg_idx].bg_flags & EXT4_BG_BLOCK_UNINIT) { if (bgd[bg_idx].bg_flags & EXT4_BG_BLOCK_UNINIT) {
memset(zero_buffer, '\0', fs->blksz); memset(zero_buffer, '\0', fs->blksz);
put_ext4(((uint64_t) (gd[bg_idx].block_id * fs->blksz)), put_ext4(((uint64_t) (bgd[bg_idx].block_id *
zero_buffer, fs->blksz); fs->blksz)), zero_buffer, fs->blksz);
memcpy(fs->blk_bmaps[bg_idx], zero_buffer, fs->blksz); memcpy(fs->blk_bmaps[bg_idx], zero_buffer, fs->blksz);
gd[bg_idx].bg_flags = gd[bg_idx].bg_flags & bgd[bg_idx].bg_flags = bgd[bg_idx].bg_flags &
~EXT4_BG_BLOCK_UNINIT; ~EXT4_BG_BLOCK_UNINIT;
} }
@ -961,18 +961,18 @@ restart:
/* journal backup */ /* journal backup */
if (prev_bg_bitmap_index != bg_idx) { if (prev_bg_bitmap_index != bg_idx) {
memset(journal_buffer, '\0', fs->blksz); memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread(gd[bg_idx].block_id status = ext4fs_devread(bgd[bg_idx].block_id
* fs->sect_perblk, * fs->sect_perblk,
0, fs->blksz, journal_buffer); 0, fs->blksz, journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id)) bgd[bg_idx].block_id))
goto fail; goto fail;
prev_bg_bitmap_index = bg_idx; prev_bg_bitmap_index = bg_idx;
} }
gd[bg_idx].free_blocks--; bgd[bg_idx].free_blocks--;
fs->sb->free_blocks--; fs->sb->free_blocks--;
goto success; goto success;
} }
@ -1000,19 +1000,21 @@ int ext4fs_get_new_inode_no(void)
char *zero_buffer = zalloc(fs->blksz); char *zero_buffer = zalloc(fs->blksz);
if (!journal_buffer || !zero_buffer) if (!journal_buffer || !zero_buffer)
goto fail; goto fail;
struct ext2_block_group *gd = (struct ext2_block_group *)fs->gdtable; struct ext2_block_group *bgd = (struct ext2_block_group *)fs->gdtable;
if (fs->first_pass_ibmap == 0) { if (fs->first_pass_ibmap == 0) {
for (i = 0; i < fs->no_blkgrp; i++) { for (i = 0; i < fs->no_blkgrp; i++) {
if (gd[i].free_inodes) { if (bgd[i].free_inodes) {
if (gd[i].bg_itable_unused != gd[i].free_inodes) if (bgd[i].bg_itable_unused !=
gd[i].bg_itable_unused = bgd[i].free_inodes)
gd[i].free_inodes; bgd[i].bg_itable_unused =
if (gd[i].bg_flags & EXT4_BG_INODE_UNINIT) { bgd[i].free_inodes;
if (bgd[i].bg_flags & EXT4_BG_INODE_UNINIT) {
put_ext4(((uint64_t) put_ext4(((uint64_t)
(gd[i].inode_id * fs->blksz)), (bgd[i].inode_id *
fs->blksz)),
zero_buffer, fs->blksz); zero_buffer, fs->blksz);
gd[i].bg_flags = gd[i].bg_flags & bgd[i].bg_flags = bgd[i].bg_flags &
~EXT4_BG_INODE_UNINIT; ~EXT4_BG_INODE_UNINIT;
memcpy(fs->inode_bmaps[i], memcpy(fs->inode_bmaps[i],
zero_buffer, fs->blksz); zero_buffer, fs->blksz);
@ -1025,17 +1027,17 @@ int ext4fs_get_new_inode_no(void)
fs->curr_inode_no = fs->curr_inode_no + fs->curr_inode_no = fs->curr_inode_no +
(i * inodes_per_grp); (i * inodes_per_grp);
fs->first_pass_ibmap++; fs->first_pass_ibmap++;
gd[i].free_inodes--; bgd[i].free_inodes--;
gd[i].bg_itable_unused--; bgd[i].bg_itable_unused--;
fs->sb->free_inodes--; fs->sb->free_inodes--;
status = ext4fs_devread(gd[i].inode_id * status = ext4fs_devread(bgd[i].inode_id *
fs->sect_perblk, 0, fs->sect_perblk, 0,
fs->blksz, fs->blksz,
journal_buffer); journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[i].inode_id)) bgd[i].inode_id))
goto fail; goto fail;
goto success; goto success;
} else } else
@ -1047,13 +1049,13 @@ restart:
fs->curr_inode_no++; fs->curr_inode_no++;
/* get the blockbitmap index respective to blockno */ /* get the blockbitmap index respective to blockno */
ibmap_idx = fs->curr_inode_no / inodes_per_grp; ibmap_idx = fs->curr_inode_no / inodes_per_grp;
if (gd[ibmap_idx].bg_flags & EXT4_BG_INODE_UNINIT) { if (bgd[ibmap_idx].bg_flags & EXT4_BG_INODE_UNINIT) {
memset(zero_buffer, '\0', fs->blksz); memset(zero_buffer, '\0', fs->blksz);
put_ext4(((uint64_t) (gd[ibmap_idx].inode_id * put_ext4(((uint64_t) (bgd[ibmap_idx].inode_id *
fs->blksz)), zero_buffer, fs->blksz)), zero_buffer,
fs->blksz); fs->blksz);
gd[ibmap_idx].bg_flags = bgd[ibmap_idx].bg_flags =
gd[ibmap_idx].bg_flags & ~EXT4_BG_INODE_UNINIT; bgd[ibmap_idx].bg_flags & ~EXT4_BG_INODE_UNINIT;
memcpy(fs->inode_bmaps[ibmap_idx], zero_buffer, memcpy(fs->inode_bmaps[ibmap_idx], zero_buffer,
fs->blksz); fs->blksz);
} }
@ -1069,21 +1071,22 @@ restart:
/* journal backup */ /* journal backup */
if (prev_inode_bitmap_index != ibmap_idx) { if (prev_inode_bitmap_index != ibmap_idx) {
memset(journal_buffer, '\0', fs->blksz); memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread(gd[ibmap_idx].inode_id status = ext4fs_devread(bgd[ibmap_idx].inode_id
* fs->sect_perblk, * fs->sect_perblk,
0, fs->blksz, journal_buffer); 0, fs->blksz, journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[ibmap_idx].inode_id)) bgd[ibmap_idx].inode_id))
goto fail; goto fail;
prev_inode_bitmap_index = ibmap_idx; prev_inode_bitmap_index = ibmap_idx;
} }
if (gd[ibmap_idx].bg_itable_unused != gd[ibmap_idx].free_inodes) if (bgd[ibmap_idx].bg_itable_unused !=
gd[ibmap_idx].bg_itable_unused = bgd[ibmap_idx].free_inodes)
gd[ibmap_idx].free_inodes; bgd[ibmap_idx].bg_itable_unused =
gd[ibmap_idx].free_inodes--; bgd[ibmap_idx].free_inodes;
gd[ibmap_idx].bg_itable_unused--; bgd[ibmap_idx].free_inodes--;
bgd[ibmap_idx].bg_itable_unused--;
fs->sb->free_inodes--; fs->sb->free_inodes--;
goto success; goto success;
} }

99
fs/ext4/ext4fs.c
View file

@ -209,14 +209,14 @@ static void ext4fs_update(void)
/* update block groups */ /* update block groups */
for (i = 0; i < fs->no_blkgrp; i++) { for (i = 0; i < fs->no_blkgrp; i++) {
fs->gd[i].bg_checksum = ext4fs_checksum_update(i); fs->bgd[i].bg_checksum = ext4fs_checksum_update(i);
put_ext4((uint64_t)(fs->gd[i].block_id * fs->blksz), put_ext4((uint64_t)(fs->bgd[i].block_id * fs->blksz),
fs->blk_bmaps[i], fs->blksz); fs->blk_bmaps[i], fs->blksz);
} }
/* update inode table groups */ /* update inode table groups */
for (i = 0; i < fs->no_blkgrp; i++) { for (i = 0; i < fs->no_blkgrp; i++) {
put_ext4((uint64_t) (fs->gd[i].inode_id * fs->blksz), put_ext4((uint64_t) (fs->bgd[i].inode_id * fs->blksz),
fs->inode_bmaps[i], fs->blksz); fs->inode_bmaps[i], fs->blksz);
} }
@ -266,7 +266,7 @@ fail:
static void delete_single_indirect_block(struct ext2_inode *inode) static void delete_single_indirect_block(struct ext2_inode *inode)
{ {
struct ext2_block_group *gd = NULL; struct ext2_block_group *bgd = NULL;
static int prev_bg_bmap_idx = -1; static int prev_bg_bmap_idx = -1;
long int blknr; long int blknr;
int remainder; int remainder;
@ -280,7 +280,7 @@ static void delete_single_indirect_block(struct ext2_inode *inode)
return; return;
} }
/* get block group descriptor table */ /* get block group descriptor table */
gd = (struct ext2_block_group *)fs->gdtable; bgd = (struct ext2_block_group *)fs->gdtable;
/* deleting the single indirect block associated with inode */ /* deleting the single indirect block associated with inode */
if (inode->b.blocks.indir_block != 0) { if (inode->b.blocks.indir_block != 0) {
@ -295,18 +295,18 @@ static void delete_single_indirect_block(struct ext2_inode *inode)
bg_idx--; bg_idx--;
} }
ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
gd[bg_idx].free_blocks++; bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++; fs->sb->free_blocks++;
/* journal backup */ /* journal backup */
if (prev_bg_bmap_idx != bg_idx) { if (prev_bg_bmap_idx != bg_idx) {
status = status =
ext4fs_devread(gd[bg_idx].block_id * ext4fs_devread(bgd[bg_idx].block_id *
fs->sect_perblk, 0, fs->blksz, fs->sect_perblk, 0, fs->blksz,
journal_buffer); journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal if (ext4fs_log_journal
(journal_buffer, gd[bg_idx].block_id)) (journal_buffer, bgd[bg_idx].block_id))
goto fail; goto fail;
prev_bg_bmap_idx = bg_idx; prev_bg_bmap_idx = bg_idx;
} }
@ -326,7 +326,7 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group; unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
unsigned int *di_buffer = NULL; unsigned int *di_buffer = NULL;
unsigned int *DIB_start_addr = NULL; unsigned int *DIB_start_addr = NULL;
struct ext2_block_group *gd = NULL; struct ext2_block_group *bgd = NULL;
struct ext_filesystem *fs = get_fs(); struct ext_filesystem *fs = get_fs();
char *journal_buffer = zalloc(fs->blksz); char *journal_buffer = zalloc(fs->blksz);
if (!journal_buffer) { if (!journal_buffer) {
@ -334,7 +334,7 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
return; return;
} }
/* get the block group descriptor table */ /* get the block group descriptor table */
gd = (struct ext2_block_group *)fs->gdtable; bgd = (struct ext2_block_group *)fs->gdtable;
if (inode->b.blocks.double_indir_block != 0) { if (inode->b.blocks.double_indir_block != 0) {
di_buffer = zalloc(fs->blksz); di_buffer = zalloc(fs->blksz);
@ -362,11 +362,11 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
ext4fs_reset_block_bmap(*di_buffer, ext4fs_reset_block_bmap(*di_buffer,
fs->blk_bmaps[bg_idx], bg_idx); fs->blk_bmaps[bg_idx], bg_idx);
di_buffer++; di_buffer++;
gd[bg_idx].free_blocks++; bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++; fs->sb->free_blocks++;
/* journal backup */ /* journal backup */
if (prev_bg_bmap_idx != bg_idx) { if (prev_bg_bmap_idx != bg_idx) {
status = ext4fs_devread(gd[bg_idx].block_id status = ext4fs_devread(bgd[bg_idx].block_id
* fs->sect_perblk, 0, * fs->sect_perblk, 0,
fs->blksz, fs->blksz,
journal_buffer); journal_buffer);
@ -374,7 +374,7 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id)) bgd[bg_idx].block_id))
goto fail; goto fail;
prev_bg_bmap_idx = bg_idx; prev_bg_bmap_idx = bg_idx;
} }
@ -391,19 +391,19 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
bg_idx--; bg_idx--;
} }
ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
gd[bg_idx].free_blocks++; bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++; fs->sb->free_blocks++;
/* journal backup */ /* journal backup */
if (prev_bg_bmap_idx != bg_idx) { if (prev_bg_bmap_idx != bg_idx) {
memset(journal_buffer, '\0', fs->blksz); memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread(gd[bg_idx].block_id * status = ext4fs_devread(bgd[bg_idx].block_id *
fs->sect_perblk, 0, fs->blksz, fs->sect_perblk, 0, fs->blksz,
journal_buffer); journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id)) bgd[bg_idx].block_id))
goto fail; goto fail;
prev_bg_bmap_idx = bg_idx; prev_bg_bmap_idx = bg_idx;
} }
@ -427,7 +427,7 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
unsigned int *tib_start_addr = NULL; unsigned int *tib_start_addr = NULL;
unsigned int *tip_buffer = NULL; unsigned int *tip_buffer = NULL;
unsigned int *tipb_start_addr = NULL; unsigned int *tipb_start_addr = NULL;
struct ext2_block_group *gd = NULL; struct ext2_block_group *bgd = NULL;
struct ext_filesystem *fs = get_fs(); struct ext_filesystem *fs = get_fs();
char *journal_buffer = zalloc(fs->blksz); char *journal_buffer = zalloc(fs->blksz);
if (!journal_buffer) { if (!journal_buffer) {
@ -435,7 +435,7 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
return; return;
} }
/* get block group descriptor table */ /* get block group descriptor table */
gd = (struct ext2_block_group *)fs->gdtable; bgd = (struct ext2_block_group *)fs->gdtable;
if (inode->b.blocks.triple_indir_block != 0) { if (inode->b.blocks.triple_indir_block != 0) {
tigp_buffer = zalloc(fs->blksz); tigp_buffer = zalloc(fs->blksz);
@ -477,20 +477,21 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
bg_idx); bg_idx);
tip_buffer++; tip_buffer++;
gd[bg_idx].free_blocks++; bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++; fs->sb->free_blocks++;
/* journal backup */ /* journal backup */
if (prev_bg_bmap_idx != bg_idx) { if (prev_bg_bmap_idx != bg_idx) {
status = status =
ext4fs_devread(gd[bg_idx].block_id * ext4fs_devread(
fs->sect_perblk, 0, bgd[bg_idx].block_id *
fs->blksz, fs->sect_perblk, 0,
journal_buffer); fs->blksz,
journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[bg_idx]. bgd[bg_idx].
block_id)) block_id))
goto fail; goto fail;
prev_bg_bmap_idx = bg_idx; prev_bg_bmap_idx = bg_idx;
@ -516,20 +517,20 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
fs->blk_bmaps[bg_idx], bg_idx); fs->blk_bmaps[bg_idx], bg_idx);
tigp_buffer++; tigp_buffer++;
gd[bg_idx].free_blocks++; bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++; fs->sb->free_blocks++;
/* journal backup */ /* journal backup */
if (prev_bg_bmap_idx != bg_idx) { if (prev_bg_bmap_idx != bg_idx) {
memset(journal_buffer, '\0', fs->blksz); memset(journal_buffer, '\0', fs->blksz);
status = status =
ext4fs_devread(gd[bg_idx].block_id * ext4fs_devread(bgd[bg_idx].block_id *
fs->sect_perblk, 0, fs->sect_perblk, 0,
fs->blksz, journal_buffer); fs->blksz, journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id)) bgd[bg_idx].block_id))
goto fail; goto fail;
prev_bg_bmap_idx = bg_idx; prev_bg_bmap_idx = bg_idx;
} }
@ -546,19 +547,19 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
bg_idx--; bg_idx--;
} }
ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
gd[bg_idx].free_blocks++; bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++; fs->sb->free_blocks++;
/* journal backup */ /* journal backup */
if (prev_bg_bmap_idx != bg_idx) { if (prev_bg_bmap_idx != bg_idx) {
memset(journal_buffer, '\0', fs->blksz); memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread(gd[bg_idx].block_id * status = ext4fs_devread(bgd[bg_idx].block_id *
fs->sect_perblk, 0, fs->blksz, fs->sect_perblk, 0, fs->blksz,
journal_buffer); journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id)) bgd[bg_idx].block_id))
goto fail; goto fail;
prev_bg_bmap_idx = bg_idx; prev_bg_bmap_idx = bg_idx;
} }
@ -590,13 +591,13 @@ static int ext4fs_delete_file(int inodeno)
unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group; unsigned int blk_per_grp = ext4fs_root->sblock.blocks_per_group;
unsigned int inode_per_grp = ext4fs_root->sblock.inodes_per_group; unsigned int inode_per_grp = ext4fs_root->sblock.inodes_per_group;
struct ext2_inode *inode_buffer = NULL; struct ext2_inode *inode_buffer = NULL;
struct ext2_block_group *gd = NULL; struct ext2_block_group *bgd = NULL;
struct ext_filesystem *fs = get_fs(); struct ext_filesystem *fs = get_fs();
char *journal_buffer = zalloc(fs->blksz); char *journal_buffer = zalloc(fs->blksz);
if (!journal_buffer) if (!journal_buffer)
return -ENOMEM; return -ENOMEM;
/* get the block group descriptor table */ /* get the block group descriptor table */
gd = (struct ext2_block_group *)fs->gdtable; bgd = (struct ext2_block_group *)fs->gdtable;
status = ext4fs_read_inode(ext4fs_root, inodeno, &inode); status = ext4fs_read_inode(ext4fs_root, inodeno, &inode);
if (status == 0) if (status == 0)
goto fail; goto fail;
@ -631,19 +632,19 @@ static int ext4fs_delete_file(int inodeno)
debug("EXT4_EXTENTS Block releasing %ld: %d\n", debug("EXT4_EXTENTS Block releasing %ld: %d\n",
blknr, bg_idx); blknr, bg_idx);
gd[bg_idx].free_blocks++; bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++; fs->sb->free_blocks++;
/* journal backup */ /* journal backup */
if (prev_bg_bmap_idx != bg_idx) { if (prev_bg_bmap_idx != bg_idx) {
status = status =
ext4fs_devread(gd[bg_idx].block_id * ext4fs_devread(bgd[bg_idx].block_id *
fs->sect_perblk, 0, fs->sect_perblk, 0,
fs->blksz, journal_buffer); fs->blksz, journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id)) bgd[bg_idx].block_id))
goto fail; goto fail;
prev_bg_bmap_idx = bg_idx; prev_bg_bmap_idx = bg_idx;
} }
@ -676,19 +677,19 @@ static int ext4fs_delete_file(int inodeno)
bg_idx); bg_idx);
debug("ActualB releasing %ld: %d\n", blknr, bg_idx); debug("ActualB releasing %ld: %d\n", blknr, bg_idx);
gd[bg_idx].free_blocks++; bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++; fs->sb->free_blocks++;
/* journal backup */ /* journal backup */
if (prev_bg_bmap_idx != bg_idx) { if (prev_bg_bmap_idx != bg_idx) {
memset(journal_buffer, '\0', fs->blksz); memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread(gd[bg_idx].block_id status = ext4fs_devread(bgd[bg_idx].block_id
* fs->sect_perblk, * fs->sect_perblk,
0, fs->blksz, 0, fs->blksz,
journal_buffer); journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id)) bgd[bg_idx].block_id))
goto fail; goto fail;
prev_bg_bmap_idx = bg_idx; prev_bg_bmap_idx = bg_idx;
} }
@ -701,7 +702,7 @@ static int ext4fs_delete_file(int inodeno)
/* get the block no */ /* get the block no */
inodeno--; inodeno--;
blkno = __le32_to_cpu(gd[ibmap_idx].inode_table_id) + blkno = __le32_to_cpu(bgd[ibmap_idx].inode_table_id) +
(inodeno % __le32_to_cpu(inode_per_grp)) / inodes_per_block; (inodeno % __le32_to_cpu(inode_per_grp)) / inodes_per_block;
/* get the offset of the inode */ /* get the offset of the inode */
@ -731,15 +732,15 @@ static int ext4fs_delete_file(int inodeno)
/* update the respective inode bitmaps */ /* update the respective inode bitmaps */
inodeno++; inodeno++;
ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx); ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx);
gd[ibmap_idx].free_inodes++; bgd[ibmap_idx].free_inodes++;
fs->sb->free_inodes++; fs->sb->free_inodes++;
/* journal backup */ /* journal backup */
memset(journal_buffer, '\0', fs->blksz); memset(journal_buffer, '\0', fs->blksz);
status = ext4fs_devread(gd[ibmap_idx].inode_id * status = ext4fs_devread(bgd[ibmap_idx].inode_id *
fs->sect_perblk, 0, fs->blksz, journal_buffer); fs->sect_perblk, 0, fs->blksz, journal_buffer);
if (status == 0) if (status == 0)
goto fail; goto fail;
if (ext4fs_log_journal(journal_buffer, gd[ibmap_idx].inode_id)) if (ext4fs_log_journal(journal_buffer, bgd[ibmap_idx].inode_id))
goto fail; goto fail;
ext4fs_update(); ext4fs_update();
@ -797,7 +798,7 @@ int ext4fs_init(void)
printf("Error in getting the block group descriptor table\n"); printf("Error in getting the block group descriptor table\n");
goto fail; goto fail;
} }
fs->gd = (struct ext2_block_group *)fs->gdtable; fs->bgd = (struct ext2_block_group *)fs->gdtable;
/* load all the available bitmap block of the partition */ /* load all the available bitmap block of the partition */
fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *)); fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *));
@ -811,7 +812,7 @@ int ext4fs_init(void)
for (i = 0; i < fs->no_blkgrp; i++) { for (i = 0; i < fs->no_blkgrp; i++) {
status = status =
ext4fs_devread(fs->gd[i].block_id * fs->sect_perblk, 0, ext4fs_devread(fs->bgd[i].block_id * fs->sect_perblk, 0,
fs->blksz, (char *)fs->blk_bmaps[i]); fs->blksz, (char *)fs->blk_bmaps[i]);
if (status == 0) if (status == 0)
goto fail; goto fail;
@ -828,7 +829,7 @@ int ext4fs_init(void)
} }
for (i = 0; i < fs->no_blkgrp; i++) { for (i = 0; i < fs->no_blkgrp; i++) {
status = ext4fs_devread(fs->gd[i].inode_id * fs->sect_perblk, status = ext4fs_devread(fs->bgd[i].inode_id * fs->sect_perblk,
0, fs->blksz, 0, fs->blksz,
(char *)fs->inode_bmaps[i]); (char *)fs->inode_bmaps[i]);
if (status == 0) if (status == 0)
@ -842,7 +843,7 @@ int ext4fs_init(void)
* reboot of a linux kernel * reboot of a linux kernel
*/ */
for (i = 0; i < fs->no_blkgrp; i++) for (i = 0; i < fs->no_blkgrp; i++)
real_free_blocks = real_free_blocks + fs->gd[i].free_blocks; real_free_blocks = real_free_blocks + fs->bgd[i].free_blocks;
if (real_free_blocks != fs->sb->free_blocks) if (real_free_blocks != fs->sb->free_blocks)
fs->sb->free_blocks = real_free_blocks; fs->sb->free_blocks = real_free_blocks;
@ -907,7 +908,7 @@ void ext4fs_deinit(void)
free(fs->gdtable); free(fs->gdtable);
fs->gdtable = NULL; fs->gdtable = NULL;
fs->gd = NULL; fs->bgd = NULL;
/* /*
* reinitiliazed the global inode and * reinitiliazed the global inode and
* block bitmap first execution check variables * block bitmap first execution check variables
@ -1087,7 +1088,7 @@ int ext4fs_write(const char *fname, unsigned char *buffer,
goto fail; goto fail;
ibmap_idx = inodeno / ext4fs_root->sblock.inodes_per_group; ibmap_idx = inodeno / ext4fs_root->sblock.inodes_per_group;
inodeno--; inodeno--;
itable_blkno = __le32_to_cpu(fs->gd[ibmap_idx].inode_table_id) + itable_blkno = __le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) +
(inodeno % __le32_to_cpu(sblock->inodes_per_group)) / (inodeno % __le32_to_cpu(sblock->inodes_per_group)) /
inodes_per_block; inodes_per_block;
blkoff = (inodeno % inodes_per_block) * fs->inodesz; blkoff = (inodeno % inodes_per_block) * fs->inodesz;
@ -1105,7 +1106,7 @@ int ext4fs_write(const char *fname, unsigned char *buffer,
} }
ibmap_idx = parent_inodeno / ext4fs_root->sblock.inodes_per_group; ibmap_idx = parent_inodeno / ext4fs_root->sblock.inodes_per_group;
parent_inodeno--; parent_inodeno--;
parent_itable_blkno = __le32_to_cpu(fs->gd[ibmap_idx].inode_table_id) + parent_itable_blkno = __le32_to_cpu(fs->bgd[ibmap_idx].inode_table_id) +
(parent_inodeno % (parent_inodeno %
__le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block; __le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz; blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz;

2
include/ext4fs.h
View file

@ -94,7 +94,7 @@ struct ext_filesystem {
/* Superblock */ /* Superblock */
struct ext2_sblock *sb; struct ext2_sblock *sb;
/* Block group descritpor table */ /* Block group descritpor table */
struct ext2_block_group *gd; struct ext2_block_group *bgd;
char *gdtable; char *gdtable;
/* Block Bitmap Related */ /* Block Bitmap Related */