Changeset fde8a27 in mainline

Timestamp:

2011-03-28T19:17:31Z (13 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

1f1cc9d

Parents:

ef76d72

Message:

Fix bug when reading inodes that causes on-disk structures corruption if the
endianness is not native.

Location:

uspace/srv/fs/minixfs

Files:

• mfs.h (modified) (1 diff)
• mfs_read.c (modified) (4 diffs)
• mfs_utils.c (modified) (2 diffs)
• mfs_utils.h (modified) (1 diff)

uspace/srv/fs/minixfs/mfs.h

@@ -57 +57 @@
 
 GLOBAL fs_reg_t mfs_reg;
+
+typedef enum {
+        BMAP_ZONE,
+        BMAP_INODE
+} bmap_id_t;
 
 typedef enum {

uspace/srv/fs/minixfs/mfs_read.c

@@ -72 +72 @@
 static int read_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock)
 {
-        block_t *bi1, *bi2;
         int r, nr_direct;
         int ptrs_per_block;
+        uint32_t *bi1 = NULL;
+        uint32_t *bi2 = NULL;
 
         assert(mnode);
@@ -110 +111 @@
                 }
 
-                r = read_ind_block(bi2, mnode->instance, ino_i->i_izone[0]);
+                bi1 = (uint32_t *) malloc(sbi->block_size);
+                r = read_ind_block(bi1, mnode->instance, ino_i->i_izone[0],
+                                        fs_version);
 
-                if (r != EOK)
-                        goto out;
+                if (fs_version == MFS_VERSION_V1)
+                        *b = ((uint16_t *) bi1)[rblock];
+                else
+                        *b = bi1[rblock];
 
-                *b = fs_version == MFS_VERSION_V1 ? 
-                                ((uint16_t *) bi1->data)[rblock] :
-                                ((uint32_t *) bi1->data)[rblock];
-                goto out_block;
+                goto out;
         }
 
@@ -130 +132 @@
                 goto out;
         }
-        r = read_ind_block(bi1, mnode->instance, ino_i->i_izone[1]);
+
+        bi1 = (uint32_t *) malloc(sbi->block_size);
+        bi2 = (uint32_t *) malloc(sbi->block_size);
+
+        r = read_ind_block(bi1, mnode->instance, ino_i->i_izone[1],
+                                fs_version);
 
         if (r != EOK)
@@ -144 +151 @@
         if (fs_version == MFS_VERSION_V1) {
                 r = read_ind_block(bi2, mnode->instance,
-                        ((uint16_t *) bi1->data)[di_block]);
+                        ((uint16_t *) bi1)[di_block], fs_version);
 
                 if (r != EOK)
-                        goto out_block;
+                        goto out;
 
-                *b = ((uint16_t *) bi2->data)[rblock % ptrs_per_block];
+                *b = ((uint16_t *) bi2)[rblock % ptrs_per_block];
         } else {
                 r = read_ind_block(bi2, mnode->instance,
-                        ((uint32_t *) bi1->data)[di_block]);
+                        ((uint32_t *) bi1)[di_block], fs_version);
 
                 if (r != EOK)
-                        goto out_block;
+                        goto out;
 
-                *b = ((uint32_t *) bi2->data)[rblock % ptrs_per_block];
+                *b = bi2[rblock % ptrs_per_block];
         }
         r = EOK;
-        block_put(bi2);
 
-out_block:
-        block_put(bi1);
 out:
+        if (bi1)
+                free(bi1);
+        if (bi2)
+                free(bi2);
         return r;
 }

uspace/srv/fs/minixfs/mfs_utils.c

@@ -65 +65 @@
  *content to the native endian format.
  */
-int read_ind_block(block_t *b, struct mfs_instance *inst, uint32_t block)
+int
+read_ind_block(void *data, struct mfs_instance *inst,
+                        uint32_t block, mfs_version_t version)
 {
         int rc;
         unsigned i;
+        block_t *b;
+        uint32_t *ptr32;
+        uint16_t *ptr16;
 
         assert(inst);
@@ -79 +84 @@
 
         if (rc != EOK)
-                return rc;
+                goto out;
 
-        if (sbi->fs_version == MFS_VERSION_V1) {
-                uint16_t *pt16 = b->data;
+        if (version == MFS_VERSION_V1) {
+                uint16_t *p = b->data;
+                ptr16 = data;
+                for (i = 0; i < sbi->block_size / sizeof(uint16_t); ++i)
+                        ptr16[i] = conv16(sbi->native, p[i]);
+        } else {
+                uint32_t *p = b->data;
+                ptr32 = data;
+                for (i = 0; i < sbi->block_size / sizeof(uint32_t); ++i)
+                        ptr32[i] = conv32(sbi->native, p[i]);
 
-                for (i = 0; i < MFS_BLOCKSIZE / sizeof(uint16_t); ++i)
-                        pt16[i] = conv16(sbi->native, pt16[i]);
-        } else {
-                uint32_t *pt32 = b->data;
-
-                for (i = 0; i < sbi->block_size / sizeof(uint32_t); ++i)
-                        pt32[i] = conv32(sbi->native, pt32[i]);
         }
 
-        return EOK;
+        rc = EOK;
+
+out:
+        block_put(b);
+        return rc;
 }
 

uspace/srv/fs/minixfs/mfs_utils.h

@@ -36 +36 @@
 #include <sys/types.h>
 #include <bool.h>
+#include "mfs.h"
 
-uint16_t conv16(bool native, uint16_t n);
-uint32_t conv32(bool native, uint32_t n);
-uint64_t conv64(bool native, uint64_t n);
-int read_ind_block(block_t *b, struct mfs_instance *inst, uint32_t block);
+extern uint16_t
+conv16(bool native, uint16_t n);
+
+extern uint32_t
+conv32(bool native, uint32_t n);
+
+extern uint64_t
+conv64(bool native, uint64_t n);
+
+extern int
+read_ind_block(void *data, struct mfs_instance *inst,
+                uint32_t block, mfs_version_t version);
 
 #endif