vitalif
/
e2fsprogs
mirror of https://github.com/vitalif/e2fsprogs
1
0
Fork 0
Code Issues Releases Wiki Activity

libext2fs: make fs->group_desc opaque 

To prevent direct array indexing of fs->group_desc[i] (because the
group_desc may be a different size for different filesystems) make it
an opaque pointer that may only be accessed through the accessor
functions in blknum.c.  The type itself is still available in a public
header; if we have a group_desc that we know is one type or another,
it's ok to access its fields directly.  This change only prevents us
from indexing off fs->group_desc[i] directly.

Old-style applications who don't want to change their source code can
(as a temporary short-term hack) #define EXT2FS_OLD_32_COMPAT before
including ext2fs.h.

Change the accessors in blknum.c to use ext4fs_group_desc(), a version
of ext2fs_group_desc() which returns a ext4_group_desc pointer.

This simplifies and collapses a fair bit of code in blknum.c

Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
bitmap-optimize
Eric Sandeen 2010-06-13 21:00:00 -04:00 committed by Theodore Ts'o
parent cd5ca12d43
commit efe0b40146
2 changed files with 123 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

299
lib/ext2fs/blknum.c
View File

@ -164,7 +164,7 @@ void ext2fs_free_blocks_count_add(struct ext2_super_block *super, blk64_t blk)
* do the swap there. * do the swap there.
*/ */
struct ext2_group_desc *ext2fs_group_desc(ext2_filsys fs, struct ext2_group_desc *ext2fs_group_desc(ext2_filsys fs,
struct ext2_group_desc *gdp, struct opaque_ext2_group_desc *gdp,
dgrp_t group) dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT)
@ -174,22 +174,26 @@ struct ext2_group_desc *ext2fs_group_desc(ext2_filsys fs,
return (struct ext2_group_desc *) gdp + group; return (struct ext2_group_desc *) gdp + group;
} }
/* Do the same but as an ext4 group desc for internal use here */
static struct ext4_group_desc *ext4fs_group_desc(ext2_filsys fs,
struct opaque_ext2_group_desc *gdp,
dgrp_t group)
{
return (struct ext4_group_desc *)ext2fs_group_desc(fs, gdp, group);
}
/* /*
* Return the block bitmap block of a group * Return the block bitmap block of a group
*/ */
blk64_t ext2fs_block_bitmap_loc(ext2_filsys fs, dgrp_t group) blk64_t ext2fs_block_bitmap_loc(ext2_filsys fs, dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
return gdp->bg_block_bitmap | gdp = ext4fs_group_desc(fs, fs->group_desc, group);
(fs->super->s_feature_incompat return gdp->bg_block_bitmap |
& EXT4_FEATURE_INCOMPAT_64BIT ? (fs->super->s_feature_incompat
(__u64) gdp->bg_block_bitmap_hi << 32 : 0); & EXT4_FEATURE_INCOMPAT_64BIT ?
} (__u64)gdp->bg_block_bitmap_hi << 32 : 0);
return fs->group_desc[group].bg_block_bitmap;
} }
/* /*
@ -197,14 +201,12 @@ blk64_t ext2fs_block_bitmap_loc(ext2_filsys fs, dgrp_t group)
*/ */
void ext2fs_block_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk) void ext2fs_block_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
gdp->bg_block_bitmap = blk; gdp->bg_block_bitmap = blk;
if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
gdp->bg_block_bitmap_hi = (__u64) blk >> 32; gdp->bg_block_bitmap_hi = (__u64) blk >> 32;
} else
fs->group_desc[group].bg_block_bitmap = blk;
} }
/* /*
@ -212,17 +214,13 @@ void ext2fs_block_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
*/ */
blk64_t ext2fs_inode_bitmap_loc(ext2_filsys fs, dgrp_t group) blk64_t ext2fs_inode_bitmap_loc(ext2_filsys fs, dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
return gdp->bg_inode_bitmap | gdp = ext4fs_group_desc(fs, fs->group_desc, group);
(fs->super->s_feature_incompat return gdp->bg_inode_bitmap |
& EXT4_FEATURE_INCOMPAT_64BIT ? (fs->super->s_feature_incompat
(__u64) gdp->bg_inode_bitmap_hi << 32 : 0); & EXT4_FEATURE_INCOMPAT_64BIT ?
} (__u64) gdp->bg_inode_bitmap_hi << 32 : 0);
return fs->group_desc[group].bg_inode_bitmap;
} }
/* /*
@ -230,14 +228,12 @@ blk64_t ext2fs_inode_bitmap_loc(ext2_filsys fs, dgrp_t group)
*/ */
void ext2fs_inode_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk) void ext2fs_inode_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
gdp->bg_inode_bitmap = blk; gdp->bg_inode_bitmap = blk;
if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
gdp->bg_inode_bitmap_hi = (__u64) blk >> 32; gdp->bg_inode_bitmap_hi = (__u64) blk >> 32;
} else
fs->group_desc[group].bg_inode_bitmap = blk;
} }
/* /*
@ -245,17 +241,13 @@ void ext2fs_inode_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
*/ */
blk64_t ext2fs_inode_table_loc(ext2_filsys fs, dgrp_t group) blk64_t ext2fs_inode_table_loc(ext2_filsys fs, dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
return gdp->bg_inode_table | gdp = ext4fs_group_desc(fs, fs->group_desc, group);
(fs->super->s_feature_incompat return gdp->bg_inode_table |
& EXT4_FEATURE_INCOMPAT_64BIT ? (fs->super->s_feature_incompat
(__u64) gdp->bg_inode_table_hi << 32 : 0); & EXT4_FEATURE_INCOMPAT_64BIT ?
} (__u64) gdp->bg_inode_table_hi << 32 : 0);
return fs->group_desc[group].bg_inode_table;
} }
/* /*
@ -263,14 +255,12 @@ blk64_t ext2fs_inode_table_loc(ext2_filsys fs, dgrp_t group)
*/ */
void ext2fs_inode_table_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk) void ext2fs_inode_table_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
gdp->bg_inode_table = blk; gdp->bg_inode_table = blk;
if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
gdp->bg_inode_table_hi = (__u64) blk >> 32; gdp->bg_inode_table_hi = (__u64) blk >> 32;
} else
fs->group_desc[group].bg_inode_table = blk;
} }
/* /*
@ -278,17 +268,13 @@ void ext2fs_inode_table_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
*/ */
__u32 ext2fs_bg_free_blocks_count(ext2_filsys fs, dgrp_t group) __u32 ext2fs_bg_free_blocks_count(ext2_filsys fs, dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
return gdp->bg_free_blocks_count | gdp = ext4fs_group_desc(fs, fs->group_desc, group);
(fs->super->s_feature_incompat return gdp->bg_free_blocks_count |
& EXT4_FEATURE_INCOMPAT_64BIT ? (fs->super->s_feature_incompat
(__u32) gdp->bg_free_blocks_count_hi << 16 : 0); & EXT4_FEATURE_INCOMPAT_64BIT ?
} (__u32) gdp->bg_free_blocks_count_hi << 16 : 0);
return fs->group_desc[group].bg_free_blocks_count;
} }
/* /*
@ -296,14 +282,13 @@ __u32 ext2fs_bg_free_blocks_count(ext2_filsys fs, dgrp_t group)
*/ */
void ext2fs_bg_free_blocks_count_set(ext2_filsys fs, dgrp_t group, __u32 n) void ext2fs_bg_free_blocks_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
gdp->bg_free_blocks_count = n; gdp->bg_free_blocks_count = n;
if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
gdp->bg_free_blocks_count_hi = (__u32) n >> 16; if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
} else gdp->bg_free_blocks_count_hi = (__u32) n >> 16;
fs->group_desc[group].bg_free_blocks_count = n;
} }
/* /*
@ -311,17 +296,13 @@ void ext2fs_bg_free_blocks_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
*/ */
__u32 ext2fs_bg_free_inodes_count(ext2_filsys fs, dgrp_t group) __u32 ext2fs_bg_free_inodes_count(ext2_filsys fs, dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
return gdp->bg_free_inodes_count | gdp = ext4fs_group_desc(fs, fs->group_desc, group);
(fs->super->s_feature_incompat return gdp->bg_free_inodes_count |
& EXT4_FEATURE_INCOMPAT_64BIT ? (fs->super->s_feature_incompat
(__u32) gdp->bg_free_inodes_count_hi << 16 : 0); & EXT4_FEATURE_INCOMPAT_64BIT ?
} (__u32) gdp->bg_free_inodes_count_hi << 16 : 0);
return fs->group_desc[group].bg_free_inodes_count;
} }
/* /*
@ -329,14 +310,12 @@ __u32 ext2fs_bg_free_inodes_count(ext2_filsys fs, dgrp_t group)
*/ */
void ext2fs_bg_free_inodes_count_set(ext2_filsys fs, dgrp_t group, __u32 n) void ext2fs_bg_free_inodes_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
gdp->bg_free_inodes_count = n; gdp->bg_free_inodes_count = n;
if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
gdp->bg_free_inodes_count_hi = (__u32) n >> 16; gdp->bg_free_inodes_count_hi = (__u32) n >> 16;
} else
fs->group_desc[group].bg_free_inodes_count = n;
} }
/* /*
@ -344,17 +323,13 @@ void ext2fs_bg_free_inodes_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
*/ */
__u32 ext2fs_bg_used_dirs_count(ext2_filsys fs, dgrp_t group) __u32 ext2fs_bg_used_dirs_count(ext2_filsys fs, dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
return gdp->bg_used_dirs_count | gdp = ext4fs_group_desc(fs, fs->group_desc, group);
(fs->super->s_feature_incompat return gdp->bg_used_dirs_count |
& EXT4_FEATURE_INCOMPAT_64BIT ? (fs->super->s_feature_incompat
(__u32) gdp->bg_used_dirs_count_hi << 16 : 0); & EXT4_FEATURE_INCOMPAT_64BIT ?
} (__u32) gdp->bg_used_dirs_count_hi << 16 : 0);
return fs->group_desc[group].bg_used_dirs_count;
} }
/* /*
@ -362,14 +337,12 @@ __u32 ext2fs_bg_used_dirs_count(ext2_filsys fs, dgrp_t group)
*/ */
void ext2fs_bg_used_dirs_count_set(ext2_filsys fs, dgrp_t group, __u32 n) void ext2fs_bg_used_dirs_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
gdp->bg_used_dirs_count = n; gdp->bg_used_dirs_count = n;
if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
gdp->bg_used_dirs_count_hi = (__u32) n >> 16; gdp->bg_used_dirs_count_hi = (__u32) n >> 16;
} else
fs->group_desc[group].bg_used_dirs_count = n;
} }
/* /*
@ -377,17 +350,13 @@ void ext2fs_bg_used_dirs_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
*/ */
__u32 ext2fs_bg_itable_unused(ext2_filsys fs, dgrp_t group) __u32 ext2fs_bg_itable_unused(ext2_filsys fs, dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
return gdp->bg_itable_unused | gdp = ext4fs_group_desc(fs, fs->group_desc, group);
(fs->super->s_feature_incompat return gdp->bg_itable_unused |
& EXT4_FEATURE_INCOMPAT_64BIT ? (fs->super->s_feature_incompat
(__u32) gdp->bg_itable_unused_hi << 16 : 0); & EXT4_FEATURE_INCOMPAT_64BIT ?
} (__u32) gdp->bg_itable_unused_hi << 16 : 0);
return fs->group_desc[group].bg_itable_unused;
} }
/* /*
@ -395,14 +364,12 @@ __u32 ext2fs_bg_itable_unused(ext2_filsys fs, dgrp_t group)
*/ */
void ext2fs_bg_itable_unused_set(ext2_filsys fs, dgrp_t group, __u32 n) void ext2fs_bg_itable_unused_set(ext2_filsys fs, dgrp_t group, __u32 n)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
gdp->bg_itable_unused = n; gdp->bg_itable_unused = n;
if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
gdp->bg_itable_unused_hi = (__u32) n >> 16; gdp->bg_itable_unused_hi = (__u32) n >> 16;
} else
fs->group_desc[group].bg_itable_unused = n;
} }
/* /*
@ -410,14 +377,10 @@ void ext2fs_bg_itable_unused_set(ext2_filsys fs, dgrp_t group, __u32 n)
*/ */
__u16 ext2fs_bg_flags(ext2_filsys fs, dgrp_t group) __u16 ext2fs_bg_flags(ext2_filsys fs, dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
return gdp->bg_flags; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
} return gdp->bg_flags;
return fs->group_desc[group].bg_flags;
} }
/* /*
@ -425,15 +388,11 @@ __u16 ext2fs_bg_flags(ext2_filsys fs, dgrp_t group)
*/ */
void ext2fs_bg_flags_zap(ext2_filsys fs, dgrp_t group) void ext2fs_bg_flags_zap(ext2_filsys fs, dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
gdp->bg_flags = 0; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
return; gdp->bg_flags = 0;
} return;
fs->group_desc[group].bg_flags = 0;
} }
/* /*
@ -441,14 +400,10 @@ void ext2fs_bg_flags_zap(ext2_filsys fs, dgrp_t group)
*/ */
int ext2fs_bg_flags_test(ext2_filsys fs, dgrp_t group, __u16 bg_flag) int ext2fs_bg_flags_test(ext2_filsys fs, dgrp_t group, __u16 bg_flag)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
return gdp->bg_flags & bg_flag; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
} return gdp->bg_flags & bg_flag;
return fs->group_desc[group].bg_flags & bg_flag;
} }
/* /*
@ -456,15 +411,11 @@ int ext2fs_bg_flags_test(ext2_filsys fs, dgrp_t group, __u16 bg_flag)
*/ */
void ext2fs_bg_flags_set(ext2_filsys fs, dgrp_t group, __u16 bg_flags) void ext2fs_bg_flags_set(ext2_filsys fs, dgrp_t group, __u16 bg_flags)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
gdp->bg_flags |= bg_flags; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
return; gdp->bg_flags |= bg_flags;
} return;
fs->group_desc[group].bg_flags |= bg_flags;
} }
/* /*
@ -472,15 +423,11 @@ void ext2fs_bg_flags_set(ext2_filsys fs, dgrp_t group, __u16 bg_flags)
*/ */
void ext2fs_bg_flags_clear(ext2_filsys fs, dgrp_t group, __u16 bg_flags) void ext2fs_bg_flags_clear(ext2_filsys fs, dgrp_t group, __u16 bg_flags)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
gdp->bg_flags &= ~bg_flags; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
return; gdp->bg_flags &= ~bg_flags;
} return;
fs->group_desc[group].bg_flags &= ~bg_flags;
} }
/* /*
@ -488,14 +435,10 @@ void ext2fs_bg_flags_clear(ext2_filsys fs, dgrp_t group, __u16 bg_flags)
*/ */
__u16 ext2fs_bg_checksum(ext2_filsys fs, dgrp_t group) __u16 ext2fs_bg_checksum(ext2_filsys fs, dgrp_t group)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
return gdp->bg_checksum; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
} return gdp->bg_checksum;
return fs->group_desc[group].bg_checksum;
} }
/* /*
@ -503,15 +446,11 @@ __u16 ext2fs_bg_checksum(ext2_filsys fs, dgrp_t group)
*/ */
void ext2fs_bg_checksum_set(ext2_filsys fs, dgrp_t group, __u16 checksum) void ext2fs_bg_checksum_set(ext2_filsys fs, dgrp_t group, __u16 checksum)
{ {
if (fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) { struct ext4_group_desc *gdp;
struct ext4_group_desc *gdp;
gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
gdp->bg_checksum = checksum;
return;
}
fs->group_desc[group].bg_checksum = checksum; gdp = ext4fs_group_desc(fs, fs->group_desc, group);
gdp->bg_checksum = checksum;
return;
} }
/* /*

6
lib/ext2fs/ext2fs.h
View File

@ -196,6 +196,8 @@ typedef struct ext2_file *ext2_file_t;
*/ */
#define EXT2_MKJOURNAL_V1_SUPER 0x0000001 #define EXT2_MKJOURNAL_V1_SUPER 0x0000001
struct opaque_ext2_group_desc;
struct struct_ext2_filsys { struct struct_ext2_filsys {
errcode_t magic; errcode_t magic;
io_channel io; io_channel io;
@ -206,7 +208,7 @@ struct struct_ext2_filsys {
int fragsize; int fragsize;
dgrp_t group_desc_count; dgrp_t group_desc_count;
unsigned long desc_blocks; unsigned long desc_blocks;
struct ext2_group_desc * group_desc; struct opaque_ext2_group_desc * group_desc;
int inode_blocks_per_group; int inode_blocks_per_group;
ext2fs_inode_bitmap inode_map; ext2fs_inode_bitmap inode_map;
ext2fs_block_bitmap block_map; ext2fs_block_bitmap block_map;
@ -748,7 +750,7 @@ extern void ext2fs_free_blocks_count_add(struct ext2_super_block *super,
blk64_t blk); blk64_t blk);
/* Block group descriptor accessor functions */ /* Block group descriptor accessor functions */
extern struct ext2_group_desc *ext2fs_group_desc(ext2_filsys fs, extern struct ext2_group_desc *ext2fs_group_desc(ext2_filsys fs,
struct ext2_group_desc *gdp, struct opaque_ext2_group_desc *gdp,
dgrp_t group); dgrp_t group);
extern blk64_t ext2fs_block_bitmap_loc(ext2_filsys fs, dgrp_t group); extern blk64_t ext2fs_block_bitmap_loc(ext2_filsys fs, dgrp_t group);
extern void ext2fs_block_bitmap_loc_set(ext2_filsys fs, dgrp_t group, extern void ext2fs_block_bitmap_loc_set(ext2_filsys fs, dgrp_t group,