Changeset f66d903 in mainline

Timestamp:

2011-03-15T20:20:07Z (13 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

953a823

Parents:

245eb02d

Message:

Fix MinixFS V3 initialization

File:

• uspace/app/mkminix/mkminix.c (modified) (16 diffs)

uspace/app/mkminix/mkminix.c

@@ -58 +58 @@
 #define UPPER(n, size)                  (((n) / (size)) + (((n) % (size)) != 0))
 #define NEXT_DENTRY(p, dirsize)         (p += dirsize)
-#define FIRST_ZONE(bs)                  (1 + (bs) / MFS_MIN_BLOCKSIZE)
-#define CONVERT_1K_OFF(off, bs)         ((off) * ((bs) / MFS_MIN_BLOCKSIZE))
 
 typedef enum {
@@ -97 +95 @@
 static int      insert_dentries(const struct mfs_sb_info *sb);
 
-static inline int write_1k_block(aoff64_t off, size_t size, const void *data);
+static inline int write_block(aoff64_t off, size_t size, const void *data);
 
 static devmap_handle_t handle;
+static int shift;
 
 static struct option const long_options[] = {
@@ -193 +192 @@
         }
 
+        if (sb.block_size == MFS_MIN_BLOCKSIZE)
+                shift = 1;
+        else if (sb.block_size == MFS_MAX_BLOCKSIZE)
+                shift = 3;
+        else
+                shift = 2;
+
         argv += optind;
 
@@ -208 +214 @@
         }
 
-        rc = block_init(handle, MFS_MIN_BLOCKSIZE);
+        rc = block_init(handle, 2048);
         if (rc != EOK)  {
                 printf(NAME ": Error initializing libblock.\n");
@@ -280 +286 @@
         void *root_block;
         int rc;
-        const long root_dblock = CONVERT_1K_OFF(sb->first_data_zone, sb->block_size);
-
-        root_block = (void *) malloc(MFS_MIN_BLOCKSIZE);
-        memset(root_block, 0x00, MFS_MIN_BLOCKSIZE);
+        const long root_dblock = sb->first_data_zone;
+
+        root_block = (void *) malloc(sb->block_size);
+        memset(root_block, 0x00, sb->block_size);
 
         if (!root_block)
@@ -312 +318 @@
         }
 
-        rc = write_1k_block(root_dblock, 1, root_block);
+        rc = write_block(root_dblock, 1, root_block);
 
         free(root_block);
@@ -323 +329 @@
         uint8_t *itable_buf;
         int rc;
-        long itable_off;
-        unsigned long itable_size;
-
-        itable_off = sb->zbmap_blocks + sb->ibmap_blocks;
-
-        /*Convert to 1K offset*/
-        itable_off = CONVERT_1K_OFF(itable_off, sb->block_size) +
-                                        FIRST_ZONE(sb->block_size);
-        itable_size = CONVERT_1K_OFF(sb->itable_size, sb->block_size);
-
-        itable_buf = malloc(MFS_MIN_BLOCKSIZE);
+
+        long itable_off = sb->zbmap_blocks + sb->ibmap_blocks + 2;
+        unsigned long itable_size = sb->itable_size;
+
+        itable_buf = malloc(sb->block_size);
 
         if (!itable_buf)
                 return ENOMEM;
 
-        memset(itable_buf, 0x00, MFS_MIN_BLOCKSIZE);
+        memset(itable_buf, 0x00, sb->block_size);
 
         for (i = 0; i < itable_size; ++i, ++itable_off) {
-                rc = write_1k_block(itable_off, 1, itable_buf);
+                rc = write_block(itable_off, 1, itable_buf);
 
                 if (rc != EOK)
@@ -354 +354 @@
 {
         struct mfs_inode *ino_buf;
-        long itable_off;
-        int rc;
-
-        itable_off = FIRST_ZONE(MFS_BLOCKSIZE);
-        itable_off += sb->zbmap_blocks + sb->ibmap_blocks;
+        int rc;
+
+        const long itable_off = sb->zbmap_blocks + sb->ibmap_blocks + 2;
 
         const time_t sec = time(NULL);
@@ -377 +375 @@
         ino_buf[MFS_ROOT_INO].i_dzone[0] = sb->first_data_zone;
 
-        rc = write_1k_block(itable_off, 1, ino_buf);
+        rc = write_block(itable_off, 1, ino_buf);
 
         free(ino_buf);
@@ -386 +384 @@
 {
         struct mfs2_inode *ino_buf;
-        long itable_off;
         int rc;
 
         /*Compute offset of the first inode table block*/
-        itable_off = sb->zbmap_blocks + sb->ibmap_blocks;
-
-        /*Convert to 1K block offset*/
-        itable_off = CONVERT_1K_OFF(itable_off, sb->block_size) +
-                                        FIRST_ZONE(sb->block_size);
+        const long itable_off = sb->zbmap_blocks + sb->ibmap_blocks + 2;
 
         const time_t sec = time(NULL);
 
-        ino_buf = (struct mfs2_inode *) malloc(MFS_MIN_BLOCKSIZE);
+        ino_buf = (struct mfs2_inode *) malloc(sb->block_size);
 
         if (!ino_buf)
                 return ENOMEM;
 
-        memset(ino_buf, 0x00, MFS_MIN_BLOCKSIZE);
+        memset(ino_buf, 0x00, sb->block_size);
 
         ino_buf[MFS_ROOT_INO].i_mode = S_IFDIR;
@@ -415 +408 @@
         ino_buf[MFS_ROOT_INO].i_dzone[0] = sb->first_data_zone;
 
-        rc = write_1k_block(itable_off, 1, ino_buf);
+        rc = write_block(itable_off, 1, ino_buf);
 
         free(ino_buf);
@@ -520 +513 @@
         sb->s_state = MFS_VALID_FS;
 
-        rc = write_1k_block(MFS_SUPERBLOCK, 1, sb);
+        rc = write_block(MFS_SUPERBLOCK, 1, sb);
         free(sb);
 
@@ -547 +540 @@
         sb->s_disk_version = 3;
 
-        rc = write_1k_block(MFS_SUPERBLOCK, 1, sb);
+        rc = block_write_direct(handle, MFS_SUPERBLOCK << 1, 1 << 1, sb); 
         free(sb);
 
@@ -557 +550 @@
         uint32_t *ibmap_buf, *zbmap_buf;
         uint8_t *ibmap_buf8, *zbmap_buf8;
-        unsigned int ibmap_nblocks = sb->ibmap_blocks;
-        unsigned int zbmap_nblocks = sb->zbmap_blocks;
+        const unsigned int ibmap_nblocks = sb->ibmap_blocks;
+        const unsigned int zbmap_nblocks = sb->zbmap_blocks;
         unsigned int i;
         int rc;
@@ -578 +571 @@
 
         /*Convert to 1K block offsets*/
-        ibmap_nblocks = CONVERT_1K_OFF(ibmap_nblocks, sb->block_size);
-        zbmap_nblocks = CONVERT_1K_OFF(zbmap_nblocks, sb->block_size);
 
         ibmap_buf8 = (uint8_t *) ibmap_buf;
         zbmap_buf8 = (uint8_t *) zbmap_buf;
 
-        int start_block = FIRST_ZONE(sb->block_size);
+        int start_block = 2;
 
         for (i = 0; i < ibmap_nblocks; ++i) {
-                if ((rc = write_1k_block(start_block + i,
-                                1, (ibmap_buf8 + i * MFS_BLOCKSIZE))) != EOK)
+                if ((rc = write_block(start_block + i,
+                                1, (ibmap_buf8 + i * sb->block_size))) != EOK)
                         return rc;
         }
 
-        start_block = FIRST_ZONE(sb->block_size) + ibmap_nblocks;
+        start_block = 2 + ibmap_nblocks;
 
         for (i = 0; i < zbmap_nblocks; ++i) {
-                if ((rc = write_1k_block(start_block + i,
-                                1, (zbmap_buf8 + i * MFS_BLOCKSIZE))) != EOK)
+                if ((rc = write_block(start_block + i,
+                                1, (zbmap_buf8 + i * sb->block_size))) != EOK)
                         return rc;
         }
@@ -614 +605 @@
 }
 
-static inline int write_1k_block(aoff64_t off, size_t size, const void *data)
-{
-        return block_write_direct(handle, off * 2, size * 2, data);     
+static inline int write_block(aoff64_t off, size_t size, const void *data)
+{
+        if (shift == 3) {
+                int rc;
+                aoff64_t tmp_off = off << 1;
+                uint8_t *data_ptr = (uint8_t *) data;
+
+                rc = block_write_direct(handle, tmp_off << 2, size << 2, data_ptr);
+
+                if (rc != EOK)
+                        return rc;
+
+                data_ptr += 2048;
+                tmp_off++;
+
+                return block_write_direct(handle, tmp_off << 2, size << 2, data_ptr);
+        }
+        return block_write_direct(handle, off << shift, size << shift, data);   
 }