Changeset ff381a7 in mainline for uspace/lib/ext4/libext4_balloc.c

Timestamp:

2015-11-02T20:54:19Z (8 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

d8513177

Parents:

3feeab2 (diff), 5265eea4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

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.
  *
@@ -76 +53 @@
         
         /* Compute indexes */
-        uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, block_addr);
+        uint32_t block_group = ext4_filesystem_blockaddr2group(sb, block_addr);
         uint32_t index_in_group =
             ext4_filesystem_blockaddr2_index_in_group(sb, block_addr);
@@ -135 +112 @@
 }
 
-/** 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,
+static int ext4_balloc_free_blocks_internal(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_balloc_get_bgid_of_block(sb, first);
-        uint32_t block_group_last =
-            ext4_balloc_get_bgid_of_block(sb, first + count - 1);
-        
+        uint32_t block_group_first = ext4_filesystem_blockaddr2group(sb,
+            first);
+        uint32_t block_group_last = ext4_filesystem_blockaddr2group(sb,
+            first + count - 1);
+
         assert(block_group_first == block_group_last);
-        
+
         /* Load block group reference */
         ext4_block_group_ref_t *bg_ref;
@@ -161 +131 @@
         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);
@@ -175 +145 @@
                 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);
@@ -187 +157 @@
                 return rc;
         }
-        
+
         uint32_t block_size = ext4_superblock_get_block_size(sb);
-        
+
         /* Update superblock free blocks count */
         uint32_t sb_free_blocks =
@@ -195 +165 @@
         sb_free_blocks += count;
         ext4_superblock_set_free_blocks_count(sb, sb_free_blocks);
-        
+
         /* Update inode blocks count */
         uint64_t ino_blocks =
@@ -202 +172 @@
         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 =
@@ -210 +180 @@
             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.
  *
@@ -227 +240 @@
     ext4_block_group_ref_t *bg_ref)
 {
-        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;
+        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;
 }
 
@@ -264 +291 @@
         *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) {
@@ -278 +305 @@
                 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;
@@ -298 +323 @@
         if (rc != EOK)
                 return rc;
-        
-        /* 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;
-        
+
+        *goal = ext4_balloc_get_first_data_block_in_group(sb, bg_ref);
+
         return ext4_filesystem_put_block_group_ref(bg_ref);
 }
@@ -353 +355 @@
         
         /* Load block group number for goal and relative index */
-        uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, goal);
+        uint32_t block_group = ext4_filesystem_blockaddr2group(sb, goal);
         uint32_t index_in_group =
             ext4_filesystem_blockaddr2_index_in_group(sb, goal);
@@ -626 +628 @@
         
         /* Compute indexes */
-        uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, fblock);
+        uint32_t block_group = ext4_filesystem_blockaddr2group(sb, fblock);
         uint32_t index_in_group =
             ext4_filesystem_blockaddr2_index_in_group(sb, fblock);