Changeset d241aae in mainline

Timestamp:

2011-02-15T19:24:38Z (13 years ago)

Author:

Martin Sucha <sucha14@…>

Branches:

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

Children:

ce13577

Parents:

1d6f507

Message:

Add support for reading ext2 block group descriptors

Location:

uspace

Files:

• app/ext2info/ext2info.c (modified) (5 diffs)
• lib/ext2/Makefile (modified) (1 diff)
• lib/ext2/libext2.h (modified) (1 diff)
• lib/ext2/libext2_block_group.c (added)
• lib/ext2/libext2_block_group.h (added)
• lib/ext2/libext2_filesystem.c (modified) (2 diffs)
• lib/ext2/libext2_filesystem.h (modified) (2 diffs)
• lib/ext2/libext2_superblock.c (modified) (1 diff)

uspace/app/ext2info/ext2info.c

@@ -53 +53 @@
 
 static void syntax_print(void);
-static void print_superblock(ext2_superblock_t *sb);
+static void print_superblock(ext2_superblock_t *);
+static void print_block_groups(ext2_filesystem_t *);
+static void print_block_group(ext2_block_group_t *);
 
 int main(int argc, char **argv)
@@ -62 +64 @@
         devmap_handle_t handle;
         ext2_filesystem_t filesystem;
+        bool strict_check;
         
         if (argc < 2) {
@@ -68 +71 @@
                 return 1;
         }
+        
+        strict_check = false;
+        if (str_cmp(*argv, "--strict-check") == 0) {
+                --argc; ++argv;
+                strict_check = true;
+        }
 
         --argc; ++argv;
@@ -94 +103 @@
         if (rc != EOK) {
                 printf(NAME ": Filesystem did not pass sanity check.\n");
-                return 3;
+                if (strict_check) {
+                        return 3;
+                }
         }
         
         print_superblock(filesystem.superblock);
+        print_block_groups(&filesystem);
 
         ext2_filesystem_fini(&filesystem);
@@ -200 +212 @@
 }
 
+void print_block_groups(ext2_filesystem_t *filesystem) {
+        uint32_t block_group_count;
+        uint32_t i;
+        ext2_block_group_ref_t *block_group_ref;
+        int rc;
+        
+        printf("Block groups:\n");
+        
+        block_group_count = ext2_superblock_get_block_group_count(
+            filesystem->superblock);
+        
+        for (i = 0; i < block_group_count; i++) {
+                printf("  Block group %u\n", i);
+                rc = ext2_filesystem_get_block_group_ref(filesystem, i, &block_group_ref);
+                if (rc != EOK) {
+                        printf("    Failed reading block group\n");
+                        continue;
+                }
+                
+                print_block_group(block_group_ref->block_group);
+                
+                rc = ext2_filesystem_put_block_group_ref(block_group_ref);
+                if (rc != EOK) {
+                        printf("    Failed freeing block group\n");
+                }
+        }
+        
+}
+
+void print_block_group(ext2_block_group_t *bg) {
+        uint32_t block_bitmap_block;
+        uint32_t inode_bitmap_block;
+        uint32_t inode_table_first_block;
+        uint16_t free_block_count;
+        uint16_t free_inode_count;
+        uint16_t directory_inode_count;
+        
+        block_bitmap_block = ext2_block_group_get_block_bitmap_block(bg);
+        inode_bitmap_block = ext2_block_group_get_inode_bitmap_block(bg);
+        inode_table_first_block = ext2_block_group_get_inode_table_first_block(bg);
+        free_block_count = ext2_block_group_get_free_block_count(bg);
+        free_inode_count = ext2_block_group_get_free_inode_count(bg);
+        directory_inode_count = ext2_block_group_get_directory_inode_count(bg);
+        
+        printf("    Block bitmap block: %u\n", block_bitmap_block);
+        printf("    Inode bitmap block: %u\n", inode_bitmap_block);
+        printf("    Inode table's first block: %u\n", inode_table_first_block);
+        printf("    Free blocks: %u\n", free_block_count);
+        printf("    Free inodes: %u\n", free_inode_count);
+        printf("    Directory inodes: %u\n", directory_inode_count);
+}
+
 /**
  * @}

uspace/lib/ext2/Makefile

@@ -36 +36 @@
 SOURCES = \
         libext2_filesystem.c \
-        libext2_superblock.c
+        libext2_superblock.c \
+        libext2_block_group.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/lib/ext2/libext2.h

@@ -38 +38 @@
 
 #include "libext2_superblock.h"
+#include "libext2_block_group.h"
 #include "libext2_filesystem.h"
 

uspace/lib/ext2/libext2_filesystem.c

@@ -34 +34 @@
  */
 
-#include "libext2.h"
+#include "libext2_filesystem.h"
+#include "libext2_superblock.h"
+#include "libext2_block_group.h"
 #include <errno.h>
 #include <libblock.h>
@@ -105 +107 @@
 
 /**
+ * Get a reference to block descriptor
+ * 
+ * @param fs Pointer to filesystem information
+ * @param bgid Index of block group to find
+ * @param ref Pointer where to store pointer to block group reference
+ * 
+ * @return              EOK on success or negative error code on failure
+ */
+int ext2_filesystem_get_block_group_ref(ext2_filesystem_t *fs, uint32_t bgid,
+    ext2_block_group_ref_t **ref)
+{
+        int rc;
+        aoff64_t block_id;
+        uint32_t descriptors_per_block;
+        size_t offset;
+        ext2_block_group_ref_t *newref;
+        
+        newref = malloc(sizeof(ext2_block_group_ref_t));
+        if (newref == NULL) {
+                return ENOMEM;
+        }
+        
+        descriptors_per_block = ext2_superblock_get_block_size(fs->superblock)
+            / EXT2_BLOCK_GROUP_DESCRIPTOR_SIZE;
+        
+        // Block group descriptor table starts at the next block after superblock
+        block_id = ext2_superblock_get_first_block(fs->superblock) + 1;
+        
+        // Find the block containing the descriptor we are looking for
+        block_id += bgid / descriptors_per_block;
+        offset = (bgid % descriptors_per_block) * EXT2_BLOCK_GROUP_DESCRIPTOR_SIZE;
+        
+        rc = block_get(&newref->block, fs->device, block_id, 0);
+        if (rc != EOK) {
+                free(newref);
+                return rc;
+        }
+        
+        newref->block_group = newref->block->data + offset;
+        
+        *ref = newref;
+        
+        return EOK;
+}
+
+/**
+ * Free a reference to block group
+ * 
+ * @param ref Pointer to block group reference to free
+ * 
+ * @return              EOK on success or negative error code on failure
+ */
+int ext2_filesystem_put_block_group_ref(ext2_block_group_ref_t *ref)
+{
+        int rc;
+        
+        rc = block_put(ref->block);
+        free(ref);
+        
+        return rc;
+}
+
+/**
  * Finalize an instance of filesystem
  * 

uspace/lib/ext2/libext2_filesystem.h

@@ -39 +39 @@
 #include <libblock.h>
 #include "libext2_superblock.h"
+#include "libext2_block_group.h"
 
 typedef struct ext2_filesystem {
@@ -52 +53 @@
 extern int ext2_filesystem_init(ext2_filesystem_t *, devmap_handle_t);
 extern int ext2_filesystem_check_sanity(ext2_filesystem_t *);
+extern int ext2_filesystem_get_block_group_ref(ext2_filesystem_t *, uint32_t, 
+    ext2_block_group_ref_t **);
+extern int ext2_filesystem_put_block_group_ref(ext2_block_group_ref_t *);
 extern void ext2_filesystem_fini(ext2_filesystem_t *);
 

uspace/lib/ext2/libext2_superblock.c

@@ -260 +260 @@
  * Compute count of block groups present in the filesystem
  * 
+ * Note: This function works only for correct filesystem,
+ *       i.e. it assumes that total block count > 0 and
+ *       blocks per group > 0
+ * 
+ * Example:
+ *   If there are 3 blocks per group, the result should be as follows:
+ *   Total blocks       Result
+ *   1                          1
+ *   2                          1
+ *   3                          1
+ *   4                          2
+ * 
+ * 
  * @param sb pointer to superblock
  */
 inline uint32_t ext2_superblock_get_block_group_count(ext2_superblock_t *sb)
 {
-        return ext2_superblock_get_total_block_count(sb) / 
-            ext2_superblock_get_blocks_per_group(sb);
+        /* We add one to the result because e.g. 2/3 = 0, while to store
+         *  2 blocks in 3-block group we need one (1) block group
+         * 
+         * We subtract one first because of special case that to store e.g.
+         *  3 blocks in a 3-block group we need only one group
+         *  (and 3/3 yields one - this is one more that we want as we
+         *   already add one at the end)
+         */ 
+        return ((ext2_superblock_get_total_block_count(sb)-1) / 
+            ext2_superblock_get_blocks_per_group(sb))+1;
 }