Changes in uspace/lib/ext4/libext4_balloc.c [24df0de6:d579acc] in mainline

File:

• uspace/lib/ext4/libext4_balloc.c (modified) (15 diffs)

uspace/lib/ext4/libext4_balloc.c

@@ -39 +39 @@
 #include "libext4.h"
 
+/** Compute number of block group from block address.
+ *
+ * @param sb         Superblock pointer.
+ * @param block_addr Absolute address of block.
+ *
+ * @return Block group index
+ *
+ */
+static uint32_t ext4_balloc_get_bgid_of_block(ext4_superblock_t *sb,
+    uint32_t block_addr)
+{
+        uint32_t blocks_per_group =
+            ext4_superblock_get_blocks_per_group(sb);
+        uint32_t first_block =
+            ext4_superblock_get_first_data_block(sb);
+        
+        /* First block == 0 or 1 */
+        if (first_block == 0)
+                return block_addr / blocks_per_group;
+        else
+                return (block_addr - 1) / blocks_per_group;
+}
+
 /** Free block.
  *
@@ -53 +76 @@
         
         /* Compute indexes */
-        uint32_t block_group = ext4_filesystem_blockaddr2group(sb, block_addr);
+        uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, block_addr);
         uint32_t index_in_group =
             ext4_filesystem_blockaddr2_index_in_group(sb, block_addr);
@@ -112 +135 @@
 }
 
-static int ext4_balloc_free_blocks_internal(ext4_inode_ref_t *inode_ref,
+/** Free continuous set of blocks.
+ *
+ * @param inode_ref Inode, where the blocks are allocated
+ * @param first     First block to release
+ * @param count     Number of blocks to release
+ *
+ */
+int ext4_balloc_free_blocks(ext4_inode_ref_t *inode_ref,
     uint32_t first, uint32_t count)
 {
         ext4_filesystem_t *fs = inode_ref->fs;
         ext4_superblock_t *sb = fs->superblock;
-
+        
         /* Compute indexes */
-        uint32_t block_group_first = ext4_filesystem_blockaddr2group(sb,
-            first);
-        uint32_t block_group_last = ext4_filesystem_blockaddr2group(sb,
-            first + count - 1);
-
+        uint32_t block_group_first =
+            ext4_balloc_get_bgid_of_block(sb, first);
+        uint32_t block_group_last =
+            ext4_balloc_get_bgid_of_block(sb, first + count - 1);
+        
         assert(block_group_first == block_group_last);
-
+        
         /* Load block group reference */
         ext4_block_group_ref_t *bg_ref;
@@ -131 +161 @@
         if (rc != EOK)
                 return rc;
-
+        
         uint32_t index_in_group_first =
             ext4_filesystem_blockaddr2_index_in_group(sb, first);
-
+        
         /* Load block with bitmap */
         uint32_t bitmap_block_addr =
             ext4_block_group_get_block_bitmap(bg_ref->block_group, sb);
-
+        
         block_t *bitmap_block;
         rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0);
@@ -145 +175 @@
                 return rc;
         }
-
+        
         /* Modify bitmap */
         ext4_bitmap_free_bits(bitmap_block->data, index_in_group_first, count);
         bitmap_block->dirty = true;
-
+        
         /* Release block with bitmap */
         rc = block_put(bitmap_block);
@@ -157 +187 @@
                 return rc;
         }
-
+        
         uint32_t block_size = ext4_superblock_get_block_size(sb);
-
+        
         /* Update superblock free blocks count */
         uint32_t sb_free_blocks =
@@ -165 +195 @@
         sb_free_blocks += count;
         ext4_superblock_set_free_blocks_count(sb, sb_free_blocks);
-
+        
         /* Update inode blocks count */
         uint64_t ino_blocks =
@@ -172 +202 @@
         ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
         inode_ref->dirty = true;
-
+        
         /* Update block group free blocks count */
         uint32_t free_blocks =
@@ -180 +210 @@
             sb, free_blocks);
         bg_ref->dirty = true;
-
+        
         /* Release block group reference */
         return ext4_filesystem_put_block_group_ref(bg_ref);
 }
 
-/** Free continuous set of blocks.
- *
- * @param inode_ref Inode, where the blocks are allocated
- * @param first     First block to release
- * @param count     Number of blocks to release
- *
- */
-int ext4_balloc_free_blocks(ext4_inode_ref_t *inode_ref,
-    uint32_t first, uint32_t count)
-{
-        int r;
-        uint32_t gid;
-        uint64_t limit;
-        ext4_filesystem_t *fs = inode_ref->fs;
-        ext4_superblock_t *sb = fs->superblock;
-
-        while (count) {
-                gid = ext4_filesystem_blockaddr2group(sb, first);
-                limit = ext4_filesystem_index_in_group2blockaddr(sb, 0,
-                    gid + 1);
-
-                if ((first + count) >= limit) {
-                        /* This extent spans over 2 or more block groups,
-                         * we'll break it into smaller parts.
-                         */
-                        uint32_t s = limit - first;
-
-                        r = ext4_balloc_free_blocks_internal(inode_ref,
-                            first, s);
-                        if (r != EOK)
-                                return r;
-
-                        first = limit;
-                        count -= s;
-                } else {
-                        return ext4_balloc_free_blocks_internal(inode_ref,
-                            first, count);
-                }
-        }
-
-        return EOK;
-}
-
 /** Compute first block for data in block group.
  *
@@ -240 +227 @@
     ext4_block_group_ref_t *bg_ref)
 {
-        uint32_t r;
-        uint64_t itable = ext4_block_group_get_inode_table_first_block(
-            bg_ref->block_group, sb);
-        uint32_t itable_sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref);
-
-        if (!ext4_superblock_has_feature_incompatible(sb,
-            EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
-                /* If we are not using FLEX_BG, the first data block
-                 * is always after the inode table.
-                 */
-                r = itable + itable_sz;
-                return ext4_filesystem_blockaddr2_index_in_group(sb, r);
-        }
-
-        uint64_t bbmap = ext4_block_group_get_block_bitmap(bg_ref->block_group,
-            sb);
-        uint64_t ibmap = ext4_block_group_get_inode_bitmap(bg_ref->block_group,
-            sb);
-
-        r = ext4_filesystem_index_in_group2blockaddr(sb, 0, bg_ref->index);
-        r += ext4_filesystem_bg_get_backup_blocks(bg_ref);
-
-        if (ext4_filesystem_blockaddr2group(sb, bbmap) != bg_ref->index)
-                bbmap = -1; /* Invalid */
-
-        if (ext4_filesystem_blockaddr2group(sb, ibmap) != bg_ref->index)
-                ibmap = -1;
-
-        while (1) {
-                if (r == bbmap || r == ibmap)
-                        r++;
-                else if (r >= itable && r < (itable + itable_sz))
-                        r = itable + itable_sz;
-                else
-                        break;
-        }
-
-        return r;
+        uint32_t block_group_count = ext4_superblock_get_block_group_count(sb);
+        uint32_t inode_table_first_block =
+            ext4_block_group_get_inode_table_first_block(bg_ref->block_group, sb);
+        uint16_t inode_table_item_size = ext4_superblock_get_inode_size(sb);
+        uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
+        uint32_t block_size = ext4_superblock_get_block_size(sb);
+        uint32_t inode_table_bytes;
+        
+        if (bg_ref->index < block_group_count - 1) {
+                inode_table_bytes = inodes_per_group * inode_table_item_size;
+        } else {
+                /* Last block group could be smaller */
+                uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb);
+                inode_table_bytes =
+                    (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) *
+                    inode_table_item_size;
+        }
+        
+        uint32_t inode_table_blocks = inode_table_bytes / block_size;
+        
+        if (inode_table_bytes % block_size)
+                inode_table_blocks++;
+        
+        return inode_table_first_block + inode_table_blocks;
 }
 
@@ -291 +264 @@
         *goal = 0;
         ext4_superblock_t *sb = inode_ref->fs->superblock;
-
+        
         uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode);
         uint32_t block_size = ext4_superblock_get_block_size(sb);
         uint32_t inode_block_count = inode_size / block_size;
-
+        
         if (inode_size % block_size != 0)
                 inode_block_count++;
-
+        
         /* If inode has some blocks, get last block address + 1 */
         if (inode_block_count > 0) {
@@ -305 +278 @@
                 if (rc != EOK)
                         return rc;
-
+                
                 if (goal != 0) {
                         (*goal)++;
                         return EOK;
                 }
+                
                 /* If goal == 0, sparse file -> continue */
         }
-
+        
         /* Identify block group of inode */
         uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
         uint32_t block_group = (inode_ref->index - 1) / inodes_per_group;
-
+        block_size = ext4_superblock_get_block_size(sb);
+        
         /* Load block group reference */
         ext4_block_group_ref_t *bg_ref;
@@ -323 +298 @@
         if (rc != EOK)
                 return rc;
-
-        *goal = ext4_balloc_get_first_data_block_in_group(sb, bg_ref);
-
+        
+        /* Compute indexes */
+        uint32_t block_group_count = ext4_superblock_get_block_group_count(sb);
+        uint32_t inode_table_first_block =
+            ext4_block_group_get_inode_table_first_block(bg_ref->block_group, sb);
+        uint16_t inode_table_item_size = ext4_superblock_get_inode_size(sb);
+        uint32_t inode_table_bytes;
+        
+        /* Check for last block group */
+        if (block_group < block_group_count - 1) {
+                inode_table_bytes = inodes_per_group * inode_table_item_size;
+        } else {
+                /* Last block group could be smaller */
+                uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb);
+                inode_table_bytes =
+                    (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) *
+                    inode_table_item_size;
+        }
+        
+        uint32_t inode_table_blocks = inode_table_bytes / block_size;
+        
+        if (inode_table_bytes % block_size)
+                inode_table_blocks++;
+        
+        *goal = inode_table_first_block + inode_table_blocks;
+        
         return ext4_filesystem_put_block_group_ref(bg_ref);
 }
@@ -355 +353 @@
         
         /* Load block group number for goal and relative index */
-        uint32_t block_group = ext4_filesystem_blockaddr2group(sb, goal);
+        uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, goal);
         uint32_t index_in_group =
             ext4_filesystem_blockaddr2_index_in_group(sb, goal);
@@ -628 +626 @@
         
         /* Compute indexes */
-        uint32_t block_group = ext4_filesystem_blockaddr2group(sb, fblock);
+        uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, fblock);
         uint32_t index_in_group =
             ext4_filesystem_blockaddr2_index_in_group(sb, fblock);