Changes in uspace/lib/ext4/libext4_filesystem.c [fc22069:d1538a1] in mainline

File:

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

uspace/lib/ext4/libext4_filesystem.c

@@ -39 +39 @@
 #include <errno.h>
 #include <malloc.h>
-#include <ipc/vfs.h>
-#include <align.h>
-#include <crypto.h>
 #include "libext4.h"
 
@@ -55 +52 @@
     enum cache_mode cmode)
 {
-        int rc;
-        ext4_superblock_t *temp_superblock = NULL;
-
         fs->device = service_id;
-
+        
         /* Initialize block library (4096 is size of communication channel) */
-        rc = block_init(fs->device, 4096);
+        int rc = block_init(EXCHANGE_SERIALIZE, fs->device, 4096);
         if (rc != EOK)
-                goto err;
-
+                return rc;
+        
         /* Read superblock from device to memory */
+        ext4_superblock_t *temp_superblock;
         rc = ext4_superblock_read_direct(fs->device, &temp_superblock);
-        if (rc != EOK)
-                goto err_1;
-
+        if (rc != EOK) {
+                block_fini(fs->device);
+                return rc;
+        }
+        
         /* Read block size from superblock and check */
         uint32_t block_size = ext4_superblock_get_block_size(temp_superblock);
         if (block_size > EXT4_MAX_BLOCK_SIZE) {
-                rc = ENOTSUP;
-                goto err_1;
-        }
-
+                block_fini(fs->device);
+                return ENOTSUP;
+        }
+        
         /* Initialize block caching by libblock */
         rc = block_cache_init(service_id, block_size, 0, cmode);
-        if (rc != EOK)
-                goto err_1;
-
+        if (rc != EOK) {
+                block_fini(fs->device);
+                return rc;
+        }
+        
         /* Compute limits for indirect block levels */
         uint32_t block_ids_per_block = block_size / sizeof(uint32_t);
@@ -92 +91 @@
                     fs->inode_blocks_per_level[i];
         }
-
+        
         /* Return loaded superblock */
         fs->superblock = temp_superblock;
-
+        
         uint16_t state = ext4_superblock_get_state(fs->superblock);
-
+        
         if (((state & EXT4_SUPERBLOCK_STATE_VALID_FS) !=
             EXT4_SUPERBLOCK_STATE_VALID_FS) ||
             ((state & EXT4_SUPERBLOCK_STATE_ERROR_FS) ==
             EXT4_SUPERBLOCK_STATE_ERROR_FS)) {
-                rc = ENOTSUP;
-                goto err_2;
-        }
-
+                block_cache_fini(fs->device);
+                block_fini(fs->device);
+                return ENOTSUP;
+        }
+        
         /* Mark system as mounted */
         ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_ERROR_FS);
         rc = ext4_superblock_write_direct(fs->device, fs->superblock);
-        if (rc != EOK)
-                goto err_2;
-
+        if (rc != EOK) {
+                block_cache_fini(fs->device);
+                block_fini(fs->device);
+                return rc;
+        }
+        
         uint16_t mnt_count = ext4_superblock_get_mount_count(fs->superblock);
         ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1);
-
+        
         return EOK;
-
-err_2:
-        block_cache_fini(fs->device);
-err_1:
-        block_fini(fs->device);
-err:
-        if (temp_superblock)
-                ext4_superblock_release(temp_superblock);
-        return rc;
 }
 
@@ -142 +136 @@
         /* Release memory space for superblock */
         free(fs->superblock);
-
+        
         /* Finish work with block library */
         block_cache_fini(fs->device);
@@ -253 +247 @@
 }
 
-/** Convert the absolute block number to group number
- *
- * @param sb    Pointer to the superblock
- * @param b     Absolute block number
- *
- * @return      Group number
- */
-uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *sb, uint64_t b)
-{
-        uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb);
-        uint32_t first_block = ext4_superblock_get_first_data_block(sb);
-
-        return (b - first_block) / blocks_per_group;
-}
-
 /** Initialize block bitmap in block group.
  *
@@ -277 +256 @@
 static int ext4_filesystem_init_block_bitmap(ext4_block_group_ref_t *bg_ref)
 {
-        uint64_t itb;
-        uint32_t sz;
-        uint32_t i;
-
         /* Load bitmap */
-        ext4_superblock_t *sb = bg_ref->fs->superblock;
-        uint64_t bitmap_block_addr = ext4_block_group_get_block_bitmap(
-            bg_ref->block_group, bg_ref->fs->superblock);
-        uint64_t bitmap_inode_addr = ext4_block_group_get_inode_bitmap(
+        uint32_t bitmap_block_addr = ext4_block_group_get_block_bitmap(
             bg_ref->block_group, bg_ref->fs->superblock);
         
@@ -297 +269 @@
         
         /* Initialize all bitmap bits to zero */
-        uint32_t block_size = ext4_superblock_get_block_size(sb);
+        uint32_t block_size = ext4_superblock_get_block_size(bg_ref->fs->superblock);
         memset(bitmap, 0, block_size);
         
-        /* Determine the number of reserved blocks in the group */
-        uint32_t reserved_cnt = ext4_filesystem_bg_get_backup_blocks(bg_ref);
-
+        /* Determine first block and first data block in group */
+        uint32_t first_idx = 0;
+        
+        uint32_t first_data = ext4_balloc_get_first_data_block_in_group(
+            bg_ref->fs->superblock, bg_ref);
+        uint32_t first_data_idx = ext4_filesystem_blockaddr2_index_in_group(
+            bg_ref->fs->superblock, first_data);
+        
         /* Set bits from to first block to first data block - 1 to one (allocated) */
-        for (uint32_t block = 0; block < reserved_cnt; ++block)
+        for (uint32_t block = first_idx; block < first_data_idx; ++block)
                 ext4_bitmap_set_bit(bitmap, block);
-
-        uint32_t bitmap_block_gid = ext4_filesystem_blockaddr2group(sb,
-            bitmap_block_addr);
-        if (bitmap_block_gid == bg_ref->index) {
-                ext4_bitmap_set_bit(bitmap,
-                    ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_block_addr));
-        }
-
-        uint32_t bitmap_inode_gid = ext4_filesystem_blockaddr2group(sb,
-            bitmap_inode_addr);
-        if (bitmap_inode_gid == bg_ref->index) {
-                ext4_bitmap_set_bit(bitmap,
-                    ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_inode_addr));
-        }
-
-        itb = ext4_block_group_get_inode_table_first_block(bg_ref->block_group,
-            sb);
-        sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref);
-
-        for (i = 0; i < sz; ++i, ++itb) {
-                uint32_t gid = ext4_filesystem_blockaddr2group(sb, itb);
-                if (gid == bg_ref->index) {
-                        ext4_bitmap_set_bit(bitmap,
-                            ext4_filesystem_blockaddr2_index_in_group(sb, itb));
-                }
-        }
-
+        
         bitmap_block->dirty = true;
         
@@ -469 +420 @@
         }
         
-        /* Initialize in-memory representation */
+        /* Inititialize in-memory representation */
         newref->block_group = newref->block->data + offset;
         newref->fs = fs;
@@ -534 +485 @@
         /* If checksum not supported, 0 will be returned */
         uint16_t crc = 0;
-
+        
         /* Compute the checksum only if the filesystem supports it */
         if (ext4_superblock_has_feature_read_only(sb,
@@ -547 +498 @@
                 
                 /* Initialization */
-                crc = crc16_ibm(~0, sb->uuid, sizeof(sb->uuid));
+                crc = crc16(~0, sb->uuid, sizeof(sb->uuid));
                 
                 /* Include index of block group */
-                crc = crc16_ibm(crc, (uint8_t *) &le_group, sizeof(le_group));
+                crc = crc16(crc, (uint8_t *) &le_group, sizeof(le_group));
                 
                 /* Compute crc from the first part (stop before checksum field) */
-                crc = crc16_ibm(crc, (uint8_t *) bg, offset);
+                crc = crc16(crc, (uint8_t *) bg, offset);
                 
                 /* Skip checksum */
@@ -562 +513 @@
                     EXT4_FEATURE_INCOMPAT_64BIT)) &&
                     (offset < ext4_superblock_get_desc_size(sb)))
-                        crc = crc16_ibm(crc, ((uint8_t *) bg) + offset,
+                        crc = crc16(crc, ((uint8_t *) bg) + offset,
                             ext4_superblock_get_desc_size(sb) - offset);
         }
@@ -569 +520 @@
 }
 
-/** Get the size of the block group's inode table
- *
- * @param sb     Pointer to the superblock
- * @param bg_ref Pointer to the block group reference
- *
- * @return       Size of the inode table in blocks.
- */
-uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb,
-    ext4_block_group_ref_t *bg_ref)
-{
-        uint32_t itable_size;
-        uint32_t block_group_count = ext4_superblock_get_block_group_count(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);
-
-        if (bg_ref->index < block_group_count - 1) {
-                itable_size = 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);
-                itable_size =
-                    (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) *
-                    inode_table_item_size;
-        }
-
-        return ROUND_UP(itable_size, block_size) / block_size;
-}
-
-/* Check if n is a power of p */
-static bool is_power_of(uint32_t n, unsigned p)
-{
-        if (p == 1 && n != p)
-                return false;
-
-        while (n != p) {
-                if (n < p)
-                        return false;
-                else if ((n % p) != 0)
-                        return false;
-
-                n /= p;
-        }
-
-        return true;
-}
-
-/** Get the number of blocks used by superblock + gdt + reserved gdt backups
- *
- * @param bg    Pointer to block group
- *
- * @return      Number of blocks
- */
-uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg)
-{
-        uint32_t const idx = bg->index;
-        uint32_t r = 0;
-        bool has_backups = false;
-        ext4_superblock_t *sb = bg->fs->superblock;
-
-        /* First step: determine if the block group contains the backups */
-
-        if (idx <= 1)
-                has_backups = true;
-        else {
-                if (ext4_superblock_has_feature_compatible(sb,
-                    EXT4_FEATURE_COMPAT_SPARSE_SUPER2)) {
-                        uint32_t g1, g2;
-
-                        ext4_superblock_get_backup_groups_sparse2(sb,
-                            &g1, &g2);
-
-                        if (idx == g1 || idx == g2)
-                                has_backups = true;
-                } else if (!ext4_superblock_has_feature_read_only(sb,
-                    EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
-                        /* Very old fs were all block groups have
-                         * superblock and block descriptors backups.
-                         */
-                        has_backups = true;
-                } else {
-                        if ((idx & 1) && (is_power_of(idx, 3) ||
-                            is_power_of(idx, 5) || is_power_of(idx, 7)))
-                                has_backups = true;
-                }
-        }
-
-        if (has_backups) {
-                uint32_t bg_count;
-                uint32_t bg_desc_sz;
-                uint32_t gdt_table; /* Size of the GDT in blocks */
-                uint32_t block_size = ext4_superblock_get_block_size(sb);
-
-                /* Now we know that this block group has backups,
-                 * we have to compute how many blocks are reserved
-                 * for them
-                 */
-
-                if (idx == 0 && block_size == 1024) {
-                        /* Special case for first group were the boot block
-                         * resides
-                         */
-                        r++;
-                }
-
-                /* This accounts for the superblock */
-                r++;
-
-                /* Add the number of blocks used for the GDT */
-                bg_count = ext4_superblock_get_block_group_count(sb);
-                bg_desc_sz = ext4_superblock_get_desc_size(sb);
-                gdt_table = ROUND_UP(bg_count * bg_desc_sz, block_size) /
-                    block_size;
-
-                r += gdt_table;
-
-                /* And now the number of reserved GDT blocks */
-                r += ext4_superblock_get_reserved_gdt_blocks(sb);
-        }
-
-        return r;
-}
-
 /** Put reference to block group.
  *
- * @param ref Pointer for reference to be put back
+ * @oaram ref Pointer for reference to be put back
  *
  * @return Error code
@@ -968 +796 @@
                 }
                 
-                rc = block_put(block);
-                if (rc != EOK)
-                        return rc;
-
+                block_put(block);
                 rc = ext4_balloc_free_block(inode_ref, fblock);
                 if (rc != EOK)
@@ -1015 +840 @@
                                 }
                                 
-                                rc = block_put(subblock);
-                                if (rc != EOK) {
-                                        block_put(block);
-                                        return rc;
-                                }
+                                block_put(subblock);
                         }
                         
@@ -1029 +850 @@
                 }
                 
-                rc = block_put(block);
-                if (rc != EOK)
-                        return rc;
-
+                block_put(block);
                 rc = ext4_balloc_free_block(inode_ref, fblock);
                 if (rc != EOK)