Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases 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>
master
Simon Glass 13 years ago committed by Tom Rini
parent bb64d1c92f
commit 73c15c634d
3 changed files with 95 additions and 91 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 85
      fs/ext4/ext4_common.c
  2. 99
      fs/ext4/ext4fs.c
  3. 2
      include/ext4fs.h

85
fs/ext4/ext4_common.c
Unescape View File

@ -314,7 +314,7 @@ int ext4fs_checksum_update(unsigned int i)
struct ext_filesystem *fs = get_fs();
__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) {
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);
if (!journal_buffer || !zero_buffer)
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) {
for (i = 0; i < fs->no_blkgrp; i++) {
if (gd[i].free_blocks) {
if (gd[i].bg_flags & EXT4_BG_BLOCK_UNINIT) {
put_ext4(((uint64_t) (gd[i].block_id *
if (bgd[i].free_blocks) {
if (bgd[i].bg_flags & EXT4_BG_BLOCK_UNINIT) {
put_ext4(((uint64_t) (bgd[i].block_id *
fs->blksz)),
zero_buffer, fs->blksz);
gd[i].bg_flags =
gd[i].
bgd[i].bg_flags =
bgd[i].
bg_flags & ~EXT4_BG_BLOCK_UNINIT;
memcpy(fs->blk_bmaps[i], zero_buffer,
fs->blksz);
@ -897,16 +897,16 @@ long int ext4fs_get_new_blk_no(void)
fs->curr_blkno = fs->curr_blkno +
(i * fs->blksz * 8);
fs->first_pass_bbmap++;
gd[i].free_blocks--;
bgd[i].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->blksz,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[i].block_id))
bgd[i].block_id))
goto fail;
goto success;
} else {
@ -935,19 +935,19 @@ restart:
if (bg_idx >= fs->no_blkgrp)
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);
fs->curr_blkno = fs->curr_blkno + blk_per_grp;
fs->curr_blkno--;
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);
put_ext4(((uint64_t) (gd[bg_idx].block_id * fs->blksz)),
zero_buffer, fs->blksz);
put_ext4(((uint64_t) (bgd[bg_idx].block_id *
fs->blksz)), 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;
}
@ -961,18 +961,18 @@ restart:
/* journal backup */
if (prev_bg_bitmap_index != bg_idx) {
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, journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id))
bgd[bg_idx].block_id))
goto fail;
prev_bg_bitmap_index = bg_idx;
}
gd[bg_idx].free_blocks--;
bgd[bg_idx].free_blocks--;
fs->sb->free_blocks--;
goto success;
}
@ -1000,19 +1000,21 @@ int ext4fs_get_new_inode_no(void)
char *zero_buffer = zalloc(fs->blksz);
if (!journal_buffer || !zero_buffer)
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) {
for (i = 0; i < fs->no_blkgrp; i++) {
if (gd[i].free_inodes) {
if (gd[i].bg_itable_unused != gd[i].free_inodes)
gd[i].bg_itable_unused =
gd[i].free_inodes;
if (gd[i].bg_flags & EXT4_BG_INODE_UNINIT) {
if (bgd[i].free_inodes) {
if (bgd[i].bg_itable_unused !=
bgd[i].free_inodes)
bgd[i].bg_itable_unused =
bgd[i].free_inodes;
if (bgd[i].bg_flags & EXT4_BG_INODE_UNINIT) {
put_ext4(((uint64_t)
(gd[i].inode_id * fs->blksz)),
(bgd[i].inode_id *
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;
memcpy(fs->inode_bmaps[i],
zero_buffer, fs->blksz);
@ -1025,17 +1027,17 @@ int ext4fs_get_new_inode_no(void)
fs->curr_inode_no = fs->curr_inode_no +
(i * inodes_per_grp);
fs->first_pass_ibmap++;
gd[i].free_inodes--;
gd[i].bg_itable_unused--;
bgd[i].free_inodes--;
bgd[i].bg_itable_unused--;
fs->sb->free_inodes--;
status = ext4fs_devread(gd[i].inode_id *
status = ext4fs_devread(bgd[i].inode_id *
fs->sect_perblk, 0,
fs->blksz,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[i].inode_id))
bgd[i].inode_id))
goto fail;
goto success;
} else
@ -1047,13 +1049,13 @@ restart:
fs->curr_inode_no++;
/* get the blockbitmap index respective to blockno */
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);
put_ext4(((uint64_t) (gd[ibmap_idx].inode_id *
put_ext4(((uint64_t) (bgd[ibmap_idx].inode_id *
fs->blksz)), zero_buffer,
fs->blksz);
gd[ibmap_idx].bg_flags =
gd[ibmap_idx].bg_flags & ~EXT4_BG_INODE_UNINIT;
bgd[ibmap_idx].bg_flags =
bgd[ibmap_idx].bg_flags & ~EXT4_BG_INODE_UNINIT;
memcpy(fs->inode_bmaps[ibmap_idx], zero_buffer,
fs->blksz);
}
@ -1069,21 +1071,22 @@ restart:
/* journal backup */
if (prev_inode_bitmap_index != ibmap_idx) {
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);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[ibmap_idx].inode_id))
bgd[ibmap_idx].inode_id))
goto fail;
prev_inode_bitmap_index = ibmap_idx;
}
if (gd[ibmap_idx].bg_itable_unused != gd[ibmap_idx].free_inodes)
gd[ibmap_idx].bg_itable_unused =
gd[ibmap_idx].free_inodes;
gd[ibmap_idx].free_inodes--;
gd[ibmap_idx].bg_itable_unused--;
if (bgd[ibmap_idx].bg_itable_unused !=
bgd[ibmap_idx].free_inodes)
bgd[ibmap_idx].bg_itable_unused =
bgd[ibmap_idx].free_inodes;
bgd[ibmap_idx].free_inodes--;
bgd[ibmap_idx].bg_itable_unused--;
fs->sb->free_inodes--;
goto success;
}

99
fs/ext4/ext4fs.c
Unescape View File

@ -209,14 +209,14 @@ static void ext4fs_update(void)
/* update block groups */
for (i = 0; i < fs->no_blkgrp; i++) {
fs->gd[i].bg_checksum = ext4fs_checksum_update(i);
put_ext4((uint64_t)(fs->gd[i].block_id * fs->blksz),
fs->bgd[i].bg_checksum = ext4fs_checksum_update(i);
put_ext4((uint64_t)(fs->bgd[i].block_id * fs->blksz),
fs->blk_bmaps[i], fs->blksz);
}
/* update inode table groups */
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);
}
@ -266,7 +266,7 @@ fail:
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;
long int blknr;
int remainder;
@ -280,7 +280,7 @@ static void delete_single_indirect_block(struct ext2_inode *inode)
return;
}
/* 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 */
if (inode->b.blocks.indir_block != 0) {
@ -295,18 +295,18 @@ static void delete_single_indirect_block(struct ext2_inode *inode)
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++;
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
status =
ext4fs_devread(gd[bg_idx].block_id *
ext4fs_devread(bgd[bg_idx].block_id *
fs->sect_perblk, 0, fs->blksz,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal
(journal_buffer, gd[bg_idx].block_id))
(journal_buffer, bgd[bg_idx].block_id))
goto fail;
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 *di_buffer = 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();
char *journal_buffer = zalloc(fs->blksz);
if (!journal_buffer) {
@ -334,7 +334,7 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
return;
}
/* 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) {
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,
fs->blk_bmaps[bg_idx], bg_idx);
di_buffer++;
gd[bg_idx].free_blocks++;
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
/* journal backup */
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->blksz,
journal_buffer);
@ -374,7 +374,7 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id))
bgd[bg_idx].block_id))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
@ -391,19 +391,19 @@ static void delete_double_indirect_block(struct ext2_inode *inode)
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++;
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
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,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id))
bgd[bg_idx].block_id))
goto fail;
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 *tip_buffer = 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();
char *journal_buffer = zalloc(fs->blksz);
if (!journal_buffer) {
@ -435,7 +435,7 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
return;
}
/* 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) {
tigp_buffer = zalloc(fs->blksz);
@ -477,20 +477,21 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
bg_idx);
tip_buffer++;
gd[bg_idx].free_blocks++;
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
status =
ext4fs_devread(gd[bg_idx].block_id *
fs->sect_perblk, 0,
fs->blksz,
journal_buffer);
ext4fs_devread(
bgd[bg_idx].block_id *
fs->sect_perblk, 0,
fs->blksz,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].
bgd[bg_idx].
block_id))
goto fail;
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);
tigp_buffer++;
gd[bg_idx].free_blocks++;
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
memset(journal_buffer, '\0', fs->blksz);
status =
ext4fs_devread(gd[bg_idx].block_id *
ext4fs_devread(bgd[bg_idx].block_id *
fs->sect_perblk, 0,
fs->blksz, journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id))
bgd[bg_idx].block_id))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
@ -546,19 +547,19 @@ static void delete_triple_indirect_block(struct ext2_inode *inode)
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++;
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
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,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id))
bgd[bg_idx].block_id))
goto fail;
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 inode_per_grp = ext4fs_root->sblock.inodes_per_group;
struct ext2_inode *inode_buffer = NULL;
struct ext2_block_group *gd = NULL;
struct ext2_block_group *bgd = NULL;
struct ext_filesystem *fs = get_fs();
char *journal_buffer = zalloc(fs->blksz);
if (!journal_buffer)
return -ENOMEM;
/* 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);
if (status == 0)
goto fail;
@ -631,19 +632,19 @@ static int ext4fs_delete_file(int inodeno)
debug("EXT4_EXTENTS Block releasing %ld: %d\n",
blknr, bg_idx);
gd[bg_idx].free_blocks++;
bgd[bg_idx].free_blocks++;
fs->sb->free_blocks++;
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
status =
ext4fs_devread(gd[bg_idx].block_id *
ext4fs_devread(bgd[bg_idx].block_id *
fs->sect_perblk, 0,
fs->blksz, journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id))
bgd[bg_idx].block_id))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
@ -676,19 +677,19 @@ static int ext4fs_delete_file(int inodeno)
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++;
/* journal backup */
if (prev_bg_bmap_idx != bg_idx) {
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,
journal_buffer);
if (status == 0)
goto fail;
if (ext4fs_log_journal(journal_buffer,
gd[bg_idx].block_id))
bgd[bg_idx].block_id))
goto fail;
prev_bg_bmap_idx = bg_idx;
}
@ -701,7 +702,7 @@ static int ext4fs_delete_file(int inodeno)
/* get the block no */
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;
/* get the offset of the inode */
@ -731,15 +732,15 @@ static int ext4fs_delete_file(int inodeno)
/* update the respective inode bitmaps */
inodeno++;
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++;
/* journal backup */
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);
if (status == 0)
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;
ext4fs_update();
@ -797,7 +798,7 @@ int ext4fs_init(void)
printf("Error in getting the block group descriptor table\n");
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 */
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++) {
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]);
if (status == 0)
goto fail;
@ -828,7 +829,7 @@ int ext4fs_init(void)
}
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,
(char *)fs->inode_bmaps[i]);
if (status == 0)
@ -842,7 +843,7 @@ int ext4fs_init(void)
* reboot of a linux kernel
*/
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)
fs->sb->free_blocks = real_free_blocks;
@ -907,7 +908,7 @@ void ext4fs_deinit(void)
free(fs->gdtable);
fs->gdtable = NULL;
fs->gd = NULL;
fs->bgd = NULL;
/*
* reinitiliazed the global inode and
* block bitmap first execution check variables
@ -1087,7 +1088,7 @@ int ext4fs_write(const char *fname, unsigned char *buffer,
goto fail;
ibmap_idx = inodeno / ext4fs_root->sblock.inodes_per_group;
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)) /
inodes_per_block;
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;
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 %
__le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz;

2
include/ext4fs.h
Unescape View File

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

Write Preview
Loading…
Cancel
Save