Changeset 1a7756a in mainline

Timestamp:

2011-10-12T09:37:59Z (13 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

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

Children:

1ccc32f

Parents:

8958a26

Message:

support for reading more complex extents (tree with nonzero depth)

Location:

uspace/lib/ext4

Files:

• libext4_extent.c (modified) (1 diff)
• libext4_extent.h (modified) (2 diffs)
• libext4_filesystem.c (modified) (1 diff)
• libext4_inode.c (modified) (2 diffs)
• libext4_inode.h (modified) (1 diff)

uspace/lib/ext4/libext4_extent.c

@@ -56 +56 @@
 }
 
+uint32_t ext4_extent_index_get_first_block(ext4_extent_index_t *index)
+{
+        return uint32_t_le2host(index->first_block);
+}
+
+uint64_t ext4_extent_index_get_leaf(ext4_extent_index_t *index)
+{
+        return ((uint64_t)uint16_t_le2host(index->leaf_hi)) << 32 |
+                                ((uint64_t)uint32_t_le2host(index->leaf_lo));
+}
+
 uint16_t ext4_extent_header_get_magic(ext4_extent_header_t *header)
 {

uspace/lib/ext4/libext4_extent.h

@@ -49 +49 @@
  * It's used at all the levels except the bottom.
  */
-typedef struct ext4_extent_idx {
-        uint32_t block; // Index covers logical blocks from 'block'
+typedef struct ext4_extent_index {
+        uint32_t first_block; // Index covers logical blocks from 'block'
         uint32_t leaf_lo; /* Pointer to the physical block of the next
                                            * level. leaf or next index could be there */
         uint16_t leaf_hi;     /* high 16 bits of physical block */
         uint16_t padding;
-} ext4_extent_idx_t;
+} ext4_extent_index_t;
 
 /*
@@ -71 +71 @@
 #define EXT4_EXTENT_FIRST(header)       \
                 ((ext4_extent_t *) (((void *) (header)) + sizeof(ext4_extent_header_t)))
+#define EXT4_EXTENT_FIRST_INDEX(header) \
+                ((ext4_extent_index_t *) (((void *) (header)) + sizeof(ext4_extent_header_t)))
 
 extern uint32_t ext4_extent_get_first_block(ext4_extent_t *);
 extern uint16_t ext4_extent_get_block_count(ext4_extent_t *);
 extern uint64_t ext4_extent_get_start(ext4_extent_t *);
+
+extern uint32_t ext4_extent_index_get_first_block(ext4_extent_index_t *);
+extern uint64_t ext4_extent_index_get_leaf(ext4_extent_index_t *);
 
 extern uint16_t ext4_extent_header_get_magic(ext4_extent_header_t *);

uspace/lib/ext4/libext4_filesystem.c

@@ -304 +304 @@
         // TODO check "extents" feature in superblock ???
         if (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_EXTENTS)) {
-                current_block = ext4_inode_get_extent_block(inode, iblock);
+                current_block = ext4_inode_get_extent_block(inode, iblock, fs->device);
                 *fblock = current_block;
                 return EOK;

uspace/lib/ext4/libext4_inode.c

@@ -37 +37 @@
 
 #include <byteorder.h>
+#include <errno.h>
+#include <libblock.h>
 #include "libext4.h"
 
@@ -102 +104 @@
 }
 
-uint32_t ext4_inode_get_extent_block(ext4_inode_t *inode, uint64_t idx)
+uint32_t ext4_inode_get_extent_block(ext4_inode_t *inode, uint64_t idx, service_id_t service_id)
 {
         ext4_extent_header_t *header = ext4_inode_get_extent_header(inode);
+        ext4_extent_t *extent;
+        ext4_extent_index_t *extent_index;
 
-        if (ext4_extent_header_get_depth(header) == 0) {
+        uint32_t first_block;
+        uint16_t block_count;
+        uint64_t phys_block = 0;
+        uint64_t child;
 
-                ext4_extent_t *extent = EXT4_EXTENT_FIRST(header);
+        int rc;
+        block_t* block = NULL;
 
-                // TODO more effective searching?
+        while (ext4_extent_header_get_depth(header) != 0) {
+
+                extent_index = EXT4_EXTENT_FIRST_INDEX(header);
+
                 for (uint16_t i = 0; i < ext4_extent_header_get_entries_count(header); ++i) {
+                        if(idx >= ext4_extent_index_get_first_block(extent_index)) {
 
-                        uint32_t first = ext4_extent_get_first_block(extent);
-                        uint16_t count = ext4_extent_get_block_count(extent);
-                        uint64_t block = 0;
+                                child = ext4_extent_index_get_leaf(extent_index);
 
-                        if ((idx >= first) && (idx < first + count)) {
-                                block = ext4_extent_get_start(extent) + idx;
-                                block -= ext4_extent_get_first_block(extent);
-                                return block;
+                                if (block != NULL) {
+                                        block_put(block);
+                                }
+
+                                rc = block_get(&block, service_id, child, BLOCK_FLAGS_NONE);
+                                if (rc != EOK) {
+                                        return 0;
+                                }
+                                EXT4FS_DBG("get block");
+
+
+                                header = (ext4_extent_header_t *)block->data;
+                                break;
                         }
-                        // Go to the next extent
-                        ++extent;
                 }
         }
 
-        // TODO binary search for depth > 0
-        EXT4FS_DBG("NOT IMPLEMENTED !!!");
-        return 0;
+        extent = EXT4_EXTENT_FIRST(header);
 
+        for (uint16_t i = 0; i < ext4_extent_header_get_entries_count(header); ++i) {
+
+                first_block = ext4_extent_get_first_block(extent);
+                block_count = ext4_extent_get_block_count(extent);
+
+                if ((idx >= first_block) && (idx < first_block + block_count)) {
+                        phys_block = ext4_extent_get_start(extent) + idx;
+                        phys_block -= ext4_extent_get_first_block(extent);
+
+                        // Memory leak prevention
+                        if (block != NULL) {
+                                block_put(block);
+                        }
+                        return phys_block;
+                }
+                // Go to the next extent
+                ++extent;
+        }
+
+
+        EXT4FS_DBG("ERROR - reached function end");
+        return phys_block;
 }
 

uspace/lib/ext4/libext4_inode.h

@@ -168 +168 @@
 uint32_t ext4_inode_get_direct_block(ext4_inode_t *, uint8_t);
 uint32_t ext4_inode_get_indirect_block(ext4_inode_t *, uint8_t);
-uint32_t ext4_inode_get_extent_block(ext4_inode_t *, uint64_t);
+uint32_t ext4_inode_get_extent_block(ext4_inode_t *, uint64_t, service_id_t);
 /*
 uint32_t blocks[EXT4_INODE_BLOCKS]; // Pointers to blocks