Changeset ad34feb in mainline

Timestamp:

2011-02-23T23:07:28Z (13 years ago)

Author:

Martin Sucha <sucha14@…>

Branches:

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

Children:

102d400

Parents:

a54af66

Message:

Implement reading of blocks from inode in libext2

Location:

uspace

Files:

• app/ext2info/ext2info.c (modified) (13 diffs)
• lib/ext2/libext2_filesystem.c (modified) (2 diffs)
• lib/ext2/libext2_filesystem.h (modified) (1 diff)
• lib/ext2/libext2_inode.c (modified) (4 diffs)
• lib/ext2/libext2_inode.h (modified) (3 diffs)

uspace/app/ext2info/ext2info.c

@@ -56 +56 @@
 static void print_block_groups(ext2_filesystem_t *);
 static void print_block_group(ext2_block_group_t *);
-static void print_inode_by_number(ext2_filesystem_t *, uint32_t);
+static void print_inode_by_number(ext2_filesystem_t *, uint32_t, bool, uint32_t);
 static void print_inode(ext2_filesystem_t *, ext2_inode_t *);
+static void print_inode_data(ext2_filesystem_t *, ext2_inode_t *, uint32_t);
 
 #define ARG_SUPERBLOCK 1
@@ -63 +64 @@
 #define ARG_INODE 4
 #define ARG_STRICT_CHECK 8
+#define ARG_INODE_DATA 16
 #define ARG_COMMON (ARG_SUPERBLOCK | ARG_BLOCK_GROUPS)
 #define ARG_ALL (ARG_COMMON | ARG_INODE)
@@ -77 +79 @@
         int arg_flags;
         uint32_t inode = 0;
+        uint32_t inode_data = 0;
         
         arg_flags = 0;
@@ -120 +123 @@
                 arg_flags |= ARG_INODE;
                 --argc; ++argv;
+                
+                if (str_cmp(*argv, "--inode-data") == 0) {
+                        --argc; ++argv;
+                        if (argc == 0) {
+                                printf(NAME ": Argument expected for --inode-data\n");
+                                return 2;
+                        }
+                        
+                        inode_data = strtol(*argv, &endptr, 10);
+                        if (*endptr != '\0') {
+                                printf(NAME ": Error, invalid argument for --inode-data.\n");
+                                syntax_print();
+                                return 1;
+                        }
+                        
+                        arg_flags |= ARG_INODE_DATA;
+                        --argc; ++argv;
+                }
         }
 
@@ -164 +185 @@
         
         if (arg_flags & ARG_INODE) {
-                print_inode_by_number(&filesystem, inode);
+                print_inode_by_number(&filesystem, inode, arg_flags & ARG_INODE_DATA,
+                    inode_data);
         }
 
@@ -175 +197 @@
 static void syntax_print(void)
 {
-        printf("syntax: ext2info --strict-check --superblock --block-groups --inode <i-number> <device_name>\n");
+        printf("syntax: ext2info [--strict-check] [--superblock] [--block-groups] "
+            "[--inode <i-number> [--inode-data <block-number>]] <device_name>\n");
 }
 
@@ -322 +345 @@
 }
 
-void print_inode_by_number(ext2_filesystem_t *fs, uint32_t inode)
+void print_inode_by_number(ext2_filesystem_t *fs, uint32_t inode, 
+    bool print_data, uint32_t data)
 {
         int rc;
@@ -336 +360 @@
         
         print_inode(fs, inode_ref->inode);
+        if (print_data) {
+                print_inode_data(fs, inode_ref->inode, data);
+        }
         
         rc = ext2_filesystem_put_inode_ref(inode_ref);
@@ -355 +382 @@
         const char *type;
         uint32_t block;
+        uint32_t total_blocks;
         int i;
         bool all_blocks = false;
@@ -365 +393 @@
         usage_count = ext2_inode_get_usage_count(inode);
         flags = ext2_inode_get_flags(inode);
+        total_blocks = ext2_inode_get_reserved_blocks(fs->superblock, inode);
         
         type = "Unknown";
@@ -390 +419 @@
         
         access = mode & EXT2_INODE_MODE_ACCESS_MASK;
+        
         
         printf("  Mode: %08x (Type: %s, Access bits: %04ho)\n", mode, type, access);
@@ -397 +427 @@
         printf("  Usage (link) count: %u\n", usage_count);
         printf("  Flags: %u\n", flags);
+        printf("  Total allocated blocks: %u\n", total_blocks);
         printf("  Block list: ");
         for (i = 0; i < 12; i++) {
@@ -406 +437 @@
                 printf("%u ", block);
         }
+        all_blocks = all_blocks || ext2_inode_get_indirect_block(inode, 0) == 0;
         if (!all_blocks) {
                 printf(" and more...");
         }
         printf("\n");
+}
+
+void print_inode_data(ext2_filesystem_t *fs, ext2_inode_t *inode, uint32_t data)
+{
+        int rc;
+        uint32_t data_block_index;
+        block_t *block;
+        size_t i;
+        unsigned char c;
+        
+        rc = ext2_filesystem_get_inode_data_block_index(fs, inode, data,
+            &data_block_index);
+        
+        if (rc != EOK) {
+                printf("Failed getting data block #%u\n", data);
+                return;
+        }
+        
+        printf("Data for inode contents block #%u is located in filesystem "
+            "block %u\n", data, data_block_index);
+        
+        printf("Data preview (only printable characters):\n");
+        
+        rc = block_get(&block, fs->device, data_block_index, 0);
+        if (rc != EOK) {
+                printf("Failed reading filesystem block %u\n", data_block_index);
+                return;
+        }
+        
+        for (i = 0; i < block->size; i++) {
+                c = ((unsigned char *)block->data)[i];
+                if (c >= 32 && c < 127) {
+                        putchar(c);
+                }
+                else {
+                        putchar('.');
+                }
+        }
+        
+        printf("\n");   
+        
+        rc = block_put(block);
+        if (rc != EOK) {
+                printf("Failed putting filesystem block\n");
+        }
+        
 }
 

uspace/lib/ext2/libext2_filesystem.c

@@ -41 +41 @@
 #include <libblock.h>
 #include <malloc.h>
+#include <assert.h>
 
 /**
@@ -255 +256 @@
 
 /**
+ * Find a filesystem block number where iblock-th data block
+ * of the given inode is located.
+ * 
+ * @return              EOK on success or negative error code on failure
+ */
+int ext2_filesystem_get_inode_data_block_index(ext2_filesystem_t *fs, ext2_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;
+        
+        if (iblock < EXT2_INODE_DIRECT_BLOCKS) {
+                current_block = ext2_inode_get_direct_block(inode, (uint32_t)iblock);
+                if (current_block == 0) {
+                        return EIO;
+                }
+                *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 = ext2_superblock_get_block_size(fs->superblock) / sizeof(uint32_t);
+        limits[0] = EXT2_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;
+        }
+        
+        block_offset_in_level = iblock - limits[level-1];
+        current_block = ext2_inode_get_indirect_block(inode, level-1);
+        offset_in_block = block_offset_in_level / blocks_per_level[level-1];
+        
+        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*)block->data)[offset_in_block];
+                
+                rc = block_put(block);
+                if (rc != EOK) {
+                        return rc;
+                }
+                
+                if (current_block == 0) {
+                        return EIO;
+                }
+                
+                level -= 1;
+                
+                if (level == 0) {
+                        break;
+                }
+                
+                offset_in_block = block_offset_in_level / blocks_per_level[level-1];
+                block_offset_in_level %= blocks_per_level[level-1];
+        }
+        
+        *fblock = current_block;
+        
+        return EOK;
+}
+
+/**
  * Finalize an instance of filesystem
  * 

uspace/lib/ext2/libext2_filesystem.h

@@ -60 +60 @@
     ext2_inode_ref_t **);
 extern int ext2_filesystem_put_inode_ref(ext2_inode_ref_t *);
+extern int ext2_filesystem_get_inode_data_block_index(ext2_filesystem_t *, ext2_inode_t*,
+    aoff64_t, uint32_t*);
 extern void ext2_filesystem_fini(ext2_filesystem_t *);
 

uspace/lib/ext2/libext2_inode.c

@@ -38 +38 @@
 #include "libext2_superblock.h"
 #include <byteorder.h>
+#include <assert.h>
 
 /**
@@ -142 +143 @@
 
 /**
+ * Get number of blocks allocated for contents of the file
+ * represented by this inode.
+ * 
+ * @param inode pointer to inode
+ */
+inline uint32_t ext2_inode_get_reserved_blocks(ext2_superblock_t *sb,
+    ext2_inode_t *inode)
+{
+        return ext2_inode_get_reserved_512_blocks(inode) /
+            (ext2_superblock_get_block_size(sb) / 512);
+}
+
+/**
  * Get inode flags
  * 
@@ -158 +172 @@
 inline uint32_t ext2_inode_get_direct_block(ext2_inode_t *inode, uint8_t idx)
 {
+        assert(idx < EXT2_INODE_DIRECT_BLOCKS);
         return uint32_t_le2host(inode->direct_blocks[idx]);
 }
@@ -165 +180 @@
  * 
  * @param inode pointer to inode
+ * @param idx Indirection level. Valid values are 0 <= idx < 3, where 0 is
+ *            singly-indirect block and 2 is triply-indirect-block
  */
-inline uint32_t ext2_inode_get_single_indirect_block(ext2_inode_t *inode)
+inline uint32_t ext2_inode_get_indirect_block(ext2_inode_t *inode, uint8_t idx)
 {
-        return uint32_t_le2host(inode->single_indirect_block);
+        assert(idx < 3);
+        return uint32_t_le2host(inode->indirect_blocks[idx]);
 }
-
-/**
- * Get double indirect block ID
- * 
- * @param inode pointer to inode
- */
-inline uint32_t ext2_inode_get_double_indirect_block(ext2_inode_t *inode)
-{
-        return uint32_t_le2host(inode->double_indirect_block);
-}
-
-/**
- * Get triple indirect block ID
- * 
- * @param inode pointer to inode
- */
-inline uint32_t ext2_inode_get_triple_indirect_block(ext2_inode_t *inode)
-{
-        return uint32_t_le2host(inode->triple_indirect_block);
-}
-
-
 
 /** @}

uspace/lib/ext2/libext2_inode.h

@@ -51 +51 @@
         uint8_t unused2[4];
         uint32_t direct_blocks[12]; // Direct block ids stored in this inode
-        uint32_t single_indirect_block;
-        uint32_t double_indirect_block;
-        uint32_t triple_indirect_block;
+        uint32_t indirect_blocks[3];
         uint32_t version;
         uint32_t file_acl;
@@ -75 +73 @@
 #define EXT2_INODE_MODE_ACCESS_MASK     0x0FFF
 #define EXT2_INODE_MODE_TYPE_MASK       0xF000
+#define EXT2_INODE_DIRECT_BLOCKS        12
 
 typedef struct ext2_inode_ref {
@@ -88 +87 @@
 inline uint16_t ext2_inode_get_usage_count(ext2_inode_t *);
 inline uint32_t ext2_inode_get_reserved_512_blocks(ext2_inode_t *);
+inline uint32_t ext2_inode_get_reserved_blocks(ext2_superblock_t *, 
+    ext2_inode_t *);
 inline uint32_t ext2_inode_get_flags(ext2_inode_t *);
 inline uint32_t ext2_inode_get_direct_block(ext2_inode_t *, uint8_t);
-inline uint32_t ext2_inode_get_single_indirect_block(ext2_inode_t *);
-inline uint32_t ext2_inode_get_double_indirect_block(ext2_inode_t *);
-inline uint32_t ext2_inode_get_triple_indirect_block(ext2_inode_t *);
+inline uint32_t ext2_inode_get_indirect_block(ext2_inode_t *, uint8_t level);