Changeset 9b9d37bb in mainline for uspace/lib/ext4/libext4_filesystem.c

Timestamp:

2011-10-06T09:48:53Z (13 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

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

Children:

1114173

Parents:

3712434

Message:

mounting + list of mounted directory (ported from ext2) - many TODO remaining

File:

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

uspace/lib/ext4/libext4_filesystem.c

@@ -36 +36 @@
  */
 
+#include <byteorder.h>
 #include <errno.h>
 #include <malloc.h>
@@ -144 +145 @@
     ext4_block_group_ref_t **ref)
 {
+        EXT4FS_DBG("");
+
         int rc;
         aoff64_t block_id;
@@ -161 +164 @@
         block_id = ext4_superblock_get_first_data_block(fs->superblock) + 1;
 
+        EXT4FS_DBG("block_size = \%d", ext4_superblock_get_block_size(fs->superblock));
+        EXT4FS_DBG("descriptors_per_block = \%d", descriptors_per_block);
+        EXT4FS_DBG("bgid = \%d", bgid);
+        EXT4FS_DBG("first_data_block: \%d", (uint32_t)block_id);
+
         /* Find the block containing the descriptor we are looking for */
         block_id += bgid / descriptors_per_block;
         offset = (bgid % descriptors_per_block) * EXT4_BLOCK_GROUP_DESCRIPTOR_SIZE;
 
+        EXT4FS_DBG("updated block_id: \%d", (uint32_t)block_id);
+
         rc = block_get(&newref->block, fs->device, block_id, 0);
         if (rc != EOK) {
+
+                EXT4FS_DBG("block_get error: \%d", rc);
+
                 free(newref);
                 return rc;
         }
 
+        EXT4FS_DBG("block read");
+
         newref->block_group = newref->block->data + offset;
 
         *ref = newref;
+
+        EXT4FS_DBG("finished");
 
         return EOK;
@@ -184 +201 @@
     ext4_inode_ref_t **ref)
 {
+        EXT4FS_DBG("");
+
         int rc;
         aoff64_t block_id;
@@ -202 +221 @@
         }
 
+        EXT4FS_DBG("allocated");
+
         inodes_per_group = ext4_superblock_get_inodes_per_group(fs->superblock);
+
+        EXT4FS_DBG("inodes_per_group_loaded");
 
         /* inode numbers are 1-based, but it is simpler to work with 0-based
@@ -211 +234 @@
         offset_in_group = index % inodes_per_group;
 
+        EXT4FS_DBG("index: \%d", index);
+        EXT4FS_DBG("inodes_per_group: \%d", inodes_per_group);
+        EXT4FS_DBG("bg_id: \%d", block_group);
+
         rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
         if (rc != EOK) {
@@ -216 +243 @@
                 return rc;
         }
+
+        EXT4FS_DBG("block_group_ref loaded");
 
         inode_table_start = ext4_block_group_get_inode_table_first_block(
             bg_ref->block_group);
 
+        EXT4FS_DBG("inode_table block loaded");
+
         inode_size = ext4_superblock_get_inode_size(fs->superblock);
         block_size = ext4_superblock_get_block_size(fs->superblock);
@@ -228 +259 @@
         offset_in_block = byte_offset_in_group % block_size;
 
+        EXT4FS_DBG("superblock info loaded");
+
         rc = block_get(&newref->block, fs->device, block_id, 0);
         if (rc != EOK) {
@@ -233 +266 @@
                 return rc;
         }
+
+        EXT4FS_DBG("block got");
 
         newref->inode = newref->block->data + offset_in_block;
@@ -242 +277 @@
         *ref = newref;
 
+        EXT4FS_DBG("finished");
+
+        return EOK;
+}
+
+int ext4_filesystem_put_inode_ref(ext4_inode_ref_t *ref)
+{
+        int rc;
+
+        rc = block_put(ref->block);
+        free(ref);
+
+        return rc;
+}
+
+int ext4_filesystem_get_inode_data_block_index(ext4_filesystem_t *fs, ext4_inode_t* inode,
+    aoff64_t iblock, uint32_t* fblock)
+{
+        int rc;
+        aoff64_t limits[4];
+        uint32_t block_ids_per_block;
+        aoff64_t blocks_per_level[4];
+        uint32_t offset_in_block;
+        uint32_t current_block;
+        aoff64_t block_offset_in_level;
+        int i;
+        int level;
+        block_t *block;
+
+        /* Handle simple case when we are dealing with direct reference */
+        if (iblock < EXT4_INODE_DIRECT_BLOCKS) {
+                current_block = ext4_inode_get_direct_block(inode, (uint32_t)iblock);
+                *fblock = current_block;
+                return EOK;
+        }
+
+        /* Compute limits for indirect block levels
+         * TODO: compute this once when loading filesystem and store in ext2_filesystem_t
+         */
+        block_ids_per_block = ext4_superblock_get_block_size(fs->superblock) / sizeof(uint32_t);
+        limits[0] = EXT4_INODE_DIRECT_BLOCKS;
+        blocks_per_level[0] = 1;
+        for (i = 1; i < 4; i++) {
+                blocks_per_level[i]  = blocks_per_level[i-1] *
+                    block_ids_per_block;
+                limits[i] = limits[i-1] + blocks_per_level[i];
+        }
+
+        /* Determine the indirection level needed to get the desired block */
+        level = -1;
+        for (i = 1; i < 4; i++) {
+                if (iblock < limits[i]) {
+                        level = i;
+                        break;
+                }
+        }
+
+        if (level == -1) {
+                return EIO;
+        }
+
+        /* Compute offsets for the topmost level */
+        block_offset_in_level = iblock - limits[level-1];
+        current_block = ext4_inode_get_indirect_block(inode, level-1);
+        offset_in_block = block_offset_in_level / blocks_per_level[level-1];
+
+        /* Navigate through other levels, until we find the block number
+         * or find null reference meaning we are dealing with sparse file
+         */
+        while (level > 0) {
+                rc = block_get(&block, fs->device, current_block, 0);
+                if (rc != EOK) {
+                        return rc;
+                }
+
+                assert(offset_in_block < block_ids_per_block);
+                current_block = uint32_t_le2host(((uint32_t*)block->data)[offset_in_block]);
+
+                rc = block_put(block);
+                if (rc != EOK) {
+                        return rc;
+                }
+
+                if (current_block == 0) {
+                        /* This is a sparse file */
+                        *fblock = 0;
+                        return EOK;
+                }
+
+                level -= 1;
+
+                /* If we are on the last level, break here as
+                 * there is no next level to visit
+                 */
+                if (level == 0) {
+                        break;
+                }
+
+                /* Visit the next level */
+                block_offset_in_level %= blocks_per_level[level];
+                offset_in_block = block_offset_in_level / blocks_per_level[level-1];
+        }
+
+        *fblock = current_block;
+
         return EOK;
 }