Whamcloud - gitweb
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
tst_libext2fs: Avoid multiple definition of global variables
[tools/e2fsprogs.git] / lib / ext2fs / blknum.c
diff --git a/lib/ext2fs/blknum.c b/lib/ext2fs/blknum.c
index aced897..ec77a06 100644 (file)
--- a/lib/ext2fs/blknum.c
+++ b/lib/ext2fs/blknum.c
@@ -29,7 +29,7 @@ dgrp_t ext2fs_group_of_blk2(ext2_filsys fs, blk64_t blk)
 blk64_t ext2fs_group_first_block2(ext2_filsys fs, dgrp_t group)
 {
        return fs->super->s_first_data_block +
-               ((blk64_t)group * fs->super->s_blocks_per_group);
+               EXT2_GROUPS_TO_BLOCKS(fs->super, group);
 }
 
 /*
@@ -69,10 +69,9 @@ blk64_t ext2fs_inode_data_blocks2(ext2_filsys fs,
                                        struct ext2_inode *inode)
 {
        return (inode->i_blocks |
-               ((fs->super->s_feature_ro_compat &
-                 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) ?
+               (ext2fs_has_feature_huge_file(fs->super) ?
                 (__u64) inode->osd2.linux2.l_i_blocks_hi << 32 : 0)) -
-               (inode->i_file_acl ? fs->blocksize >> 9 : 0);
+               (inode->i_file_acl ? EXT2_CLUSTER_SIZE(fs->super) >> 9 : 0);
 }
 
 /*
@@ -82,18 +81,33 @@ blk64_t ext2fs_inode_i_blocks(ext2_filsys fs,
                                        struct ext2_inode *inode)
 {
        return (inode->i_blocks |
-               ((fs->super->s_feature_ro_compat &
-                 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) ?
+               (ext2fs_has_feature_huge_file(fs->super) ?
                 (__u64)inode->osd2.linux2.l_i_blocks_hi << 32 : 0));
 }
 
 /*
+ * Return the inode i_blocks in stat (512 byte) units
+ */
+blk64_t ext2fs_get_stat_i_blocks(ext2_filsys fs,
+                                struct ext2_inode *inode)
+{
+       blk64_t ret = inode->i_blocks;
+
+       if (ext2fs_has_feature_huge_file(fs->super)) {
+               ret += ((long long) inode->osd2.linux2.l_i_blocks_hi) << 32;
+               if (inode->i_flags & EXT4_HUGE_FILE_FL)
+                       ret *= (fs->blocksize / 512);
+       }
+       return ret;
+}
+
+/*
  * Return the fs block count
  */
 blk64_t ext2fs_blocks_count(struct ext2_super_block *super)
 {
        return super->s_blocks_count |
-               (super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT ?
+               (ext2fs_has_feature_64bit(super) ?
                (__u64) super->s_blocks_count_hi << 32 : 0);
 }
 
@@ -103,7 +117,7 @@ blk64_t ext2fs_blocks_count(struct ext2_super_block *super)
 void ext2fs_blocks_count_set(struct ext2_super_block *super, blk64_t blk)
 {
        super->s_blocks_count = blk;
-       if (super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (ext2fs_has_feature_64bit(super))
                super->s_blocks_count_hi = (__u64) blk >> 32;
 }
 
@@ -123,7 +137,7 @@ void ext2fs_blocks_count_add(struct ext2_super_block *super, blk64_t blk)
 blk64_t ext2fs_r_blocks_count(struct ext2_super_block *super)
 {
        return super->s_r_blocks_count |
-               (super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT ?
+               (ext2fs_has_feature_64bit(super) ?
                (__u64) super->s_r_blocks_count_hi << 32 : 0);
 }
 
@@ -133,7 +147,7 @@ blk64_t ext2fs_r_blocks_count(struct ext2_super_block *super)
 void ext2fs_r_blocks_count_set(struct ext2_super_block *super, blk64_t blk)
 {
        super->s_r_blocks_count = blk;
-       if (super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (ext2fs_has_feature_64bit(super))
                super->s_r_blocks_count_hi = (__u64) blk >> 32;
 }
 
@@ -153,7 +167,7 @@ void ext2fs_r_blocks_count_add(struct ext2_super_block *super, blk64_t blk)
 blk64_t ext2fs_free_blocks_count(struct ext2_super_block *super)
 {
        return super->s_free_blocks_count |
-               (super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT ?
+               (ext2fs_has_feature_64bit(super) ?
                (__u64) super->s_free_blocks_hi << 32 : 0);
 }
 
@@ -163,7 +177,7 @@ blk64_t ext2fs_free_blocks_count(struct ext2_super_block *super)
 void ext2fs_free_blocks_count_set(struct ext2_super_block *super, blk64_t blk)
 {
        super->s_free_blocks_count = blk;
-       if (super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (ext2fs_has_feature_64bit(super))
                super->s_free_blocks_hi = (__u64) blk >> 32;
 }
 
@@ -187,8 +201,9 @@ struct ext2_group_desc *ext2fs_group_desc(ext2_filsys fs,
                                          struct opaque_ext2_group_desc *gdp,
                                          dgrp_t group)
 {
-       return (struct ext2_group_desc *)((char *)gdp +
-                                         group * EXT2_DESC_SIZE(fs->super));
+       int desc_size = EXT2_DESC_SIZE(fs->super) & ~7;
+
+       return (struct ext2_group_desc *)((char *)gdp + group * desc_size);
 }
 
 /* Do the same but as an ext4 group desc for internal use here */
@@ -209,7 +224,7 @@ __u32 ext2fs_block_bitmap_checksum(ext2_filsys fs, dgrp_t group)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        csum = gdp->bg_block_bitmap_csum_lo;
-       if (fs->super->s_desc_size >= EXT4_BG_BLOCK_BITMAP_CSUM_HI_LOCATION)
+       if (EXT2_DESC_SIZE(fs->super) >= EXT4_BG_BLOCK_BITMAP_CSUM_HI_LOCATION)
                csum |= ((__u32)gdp->bg_block_bitmap_csum_hi << 16);
        return csum;
 }
@@ -223,8 +238,7 @@ blk64_t ext2fs_block_bitmap_loc(ext2_filsys fs, dgrp_t group)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        return gdp->bg_block_bitmap |
-               (fs->super->s_feature_incompat
-                & EXT4_FEATURE_INCOMPAT_64BIT ?
+               (ext2fs_has_feature_64bit(fs->super) ?
                 (__u64)gdp->bg_block_bitmap_hi << 32 : 0);
 }
 
@@ -237,7 +251,7 @@ void ext2fs_block_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        gdp->bg_block_bitmap = blk;
-       if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (ext2fs_has_feature_64bit(fs->super))
                gdp->bg_block_bitmap_hi = (__u64) blk >> 32;
 }
 
@@ -251,7 +265,7 @@ __u32 ext2fs_inode_bitmap_checksum(ext2_filsys fs, dgrp_t group)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        csum = gdp->bg_inode_bitmap_csum_lo;
-       if (fs->super->s_desc_size >= EXT4_BG_INODE_BITMAP_CSUM_HI_END)
+       if (EXT2_DESC_SIZE(fs->super) >= EXT4_BG_INODE_BITMAP_CSUM_HI_END)
                csum |= ((__u32)gdp->bg_inode_bitmap_csum_hi << 16);
        return csum;
 }
@@ -265,8 +279,7 @@ blk64_t ext2fs_inode_bitmap_loc(ext2_filsys fs, dgrp_t group)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        return gdp->bg_inode_bitmap |
-               (fs->super->s_feature_incompat
-                & EXT4_FEATURE_INCOMPAT_64BIT ?
+               (ext2fs_has_feature_64bit(fs->super) ?
                 (__u64) gdp->bg_inode_bitmap_hi << 32 : 0);
 }
 
@@ -279,7 +292,7 @@ void ext2fs_inode_bitmap_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        gdp->bg_inode_bitmap = blk;
-       if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (ext2fs_has_feature_64bit(fs->super))
                gdp->bg_inode_bitmap_hi = (__u64) blk >> 32;
 }
 
@@ -292,8 +305,7 @@ blk64_t ext2fs_inode_table_loc(ext2_filsys fs, dgrp_t group)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        return gdp->bg_inode_table |
-               (fs->super->s_feature_incompat
-                & EXT4_FEATURE_INCOMPAT_64BIT ?
+               (ext2fs_has_feature_64bit(fs->super) ?
                 (__u64) gdp->bg_inode_table_hi << 32 : 0);
 }
 
@@ -306,7 +318,7 @@ void ext2fs_inode_table_loc_set(ext2_filsys fs, dgrp_t group, blk64_t blk)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        gdp->bg_inode_table = blk;
-       if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (ext2fs_has_feature_64bit(fs->super))
                gdp->bg_inode_table_hi = (__u64) blk >> 32;
 }
 
@@ -319,8 +331,7 @@ __u32 ext2fs_bg_free_blocks_count(ext2_filsys fs, dgrp_t group)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        return gdp->bg_free_blocks_count |
-               (fs->super->s_feature_incompat
-                & EXT4_FEATURE_INCOMPAT_64BIT ?
+               (ext2fs_has_feature_64bit(fs->super) ?
                 (__u32) gdp->bg_free_blocks_count_hi << 16 : 0);
 }
 
@@ -334,7 +345,7 @@ void ext2fs_bg_free_blocks_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        gdp->bg_free_blocks_count = n;
 
-       if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (ext2fs_has_feature_64bit(fs->super))
                gdp->bg_free_blocks_count_hi = (__u32) n >> 16;
 }
 
@@ -347,8 +358,7 @@ __u32 ext2fs_bg_free_inodes_count(ext2_filsys fs, dgrp_t group)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        return gdp->bg_free_inodes_count |
-               (fs->super->s_feature_incompat
-                & EXT4_FEATURE_INCOMPAT_64BIT ?
+               (ext2fs_has_feature_64bit(fs->super) ?
                 (__u32) gdp->bg_free_inodes_count_hi << 16 : 0);
 }
 
@@ -361,7 +371,7 @@ void ext2fs_bg_free_inodes_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        gdp->bg_free_inodes_count = n;
-       if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (ext2fs_has_feature_64bit(fs->super))
                gdp->bg_free_inodes_count_hi = (__u32) n >> 16;
 }
 
@@ -374,8 +384,7 @@ __u32 ext2fs_bg_used_dirs_count(ext2_filsys fs, dgrp_t group)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        return gdp->bg_used_dirs_count |
-               (fs->super->s_feature_incompat
-                & EXT4_FEATURE_INCOMPAT_64BIT ?
+               (ext2fs_has_feature_64bit(fs->super) ?
                 (__u32) gdp->bg_used_dirs_count_hi << 16 : 0);
 }
 
@@ -388,7 +397,7 @@ void ext2fs_bg_used_dirs_count_set(ext2_filsys fs, dgrp_t group, __u32 n)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        gdp->bg_used_dirs_count = n;
-       if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (ext2fs_has_feature_64bit(fs->super))
                gdp->bg_used_dirs_count_hi = (__u32) n >> 16;
 }
 
@@ -401,8 +410,7 @@ __u32 ext2fs_bg_itable_unused(ext2_filsys fs, dgrp_t group)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        return gdp->bg_itable_unused |
-               (fs->super->s_feature_incompat
-                & EXT4_FEATURE_INCOMPAT_64BIT ?
+               (ext2fs_has_feature_64bit(fs->super) ?
                 (__u32) gdp->bg_itable_unused_hi << 16 : 0);
 }
 
@@ -415,7 +423,7 @@ void ext2fs_bg_itable_unused_set(ext2_filsys fs, dgrp_t group, __u32 n)
 
        gdp = ext4fs_group_desc(fs, fs->group_desc, group);
        gdp->bg_itable_unused = n;
-       if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (ext2fs_has_feature_64bit(fs->super))
                gdp->bg_itable_unused_hi = (__u32) n >> 16;
 }
 
@@ -507,7 +515,7 @@ blk64_t ext2fs_file_acl_block(ext2_filsys fs, const struct ext2_inode *inode)
 {
        blk64_t blk = inode->i_file_acl;
 
-       if (fs && fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (fs && ext2fs_has_feature_64bit(fs->super))
                blk |= ((__u64) inode->osd2.linux2.l_i_file_acl_high) << 32;
        return blk;
 }
@@ -519,7 +527,36 @@ void ext2fs_file_acl_block_set(ext2_filsys fs, struct ext2_inode *inode,
                               blk64_t blk)
 {
        inode->i_file_acl = blk;
-       if (fs && fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT)
+       if (fs && ext2fs_has_feature_64bit(fs->super))
                inode->osd2.linux2.l_i_file_acl_high = (__u64) blk >> 32;
 }
 
+/*
+ * Set the size of the inode
+ */
+errcode_t ext2fs_inode_size_set(ext2_filsys fs, struct ext2_inode *inode,
+                               ext2_off64_t size)
+{
+       if (size < 0)
+               return EINVAL;
+
+       /* Only regular files get to be larger than 4GB */
+       if (!LINUX_S_ISREG(inode->i_mode) && (size >> 32))
+               return EXT2_ET_FILE_TOO_BIG;
+
+       /* If we're writing a large file, set the large_file flag */
+       if (LINUX_S_ISREG(inode->i_mode) &&
+           ext2fs_needs_large_file_feature(size) &&
+           (!ext2fs_has_feature_large_file(fs->super) ||
+            fs->super->s_rev_level == EXT2_GOOD_OLD_REV)) {
+               ext2fs_set_feature_large_file(fs->super);
+               ext2fs_update_dynamic_rev(fs);
+               ext2fs_mark_super_dirty(fs);
+       }
+
+       inode->i_size = size & 0xffffffff;
+       inode->i_size_high = (size >> 32);
+
+       return 0;
+}
+
Mirror of git://git.kernel.org/pub/scm/fs/ext2/e2fsprogs.git