Changeset 0b07acd in mainline

Timestamp:

2011-03-08T21:21:38Z (13 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

6cda025

Parents:

4727a97a

Message:

Improve error detection

File:

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

uspace/app/mkminix/mkminix.c

@@ -88 +88 @@
 static void     help_cmd_mkminix(help_level_t level);
 static int      num_of_set_bits(uint32_t n);
-static void     init_superblock(struct mfs_sb_info *sb);
-static void     write_superblock(struct mfs_sb_info *sbi);
-static void     write_superblock3(struct mfs_sb_info *sbi);
-static void     init_bitmaps(struct mfs_sb_info *sb);
-static void     init_inode_table(struct mfs_sb_info *sb);
-static void     make_root_ino(struct mfs_sb_info *sb);
-static void     make_root_ino3(struct mfs_sb_info *sb);
+static int      init_superblock(struct mfs_sb_info *sb);
+static int      write_superblock(struct mfs_sb_info *sbi);
+static int      write_superblock3(struct mfs_sb_info *sbi);
+static int      init_bitmaps(struct mfs_sb_info *sb);
+static int      init_inode_table(struct mfs_sb_info *sb);
+static int      make_root_ino(struct mfs_sb_info *sb);
+static int      make_root_ino3(struct mfs_sb_info *sb);
 static void     mark_bmap(uint32_t *bmap, int idx, int v);
-static void     insert_dentries(struct mfs_sb_info *sb);
+static int      insert_dentries(struct mfs_sb_info *sb);
 
 static struct option const long_options[] = {
@@ -233 +233 @@
 
         /*Initialize superblock*/
-        init_superblock(&sb);
+        if (init_superblock(&sb) != EOK) {
+                printf(NAME ": Error. Superblock initialization failed\n");
+                return 2;
+        }
 
         /*Initialize bitmaps*/
-        init_bitmaps(&sb);
+        if (init_bitmaps(&sb) != EOK) {
+                printf(NAME ": Error. Bitmaps initialization failed\n");
+                return 2;
+        }
 
         /*Init inode table*/
-        init_inode_table(&sb);
+        if (init_inode_table(&sb) != EOK) {
+                printf(NAME ": Error. Inode table initialization failed\n");
+                return 2;
+        }
 
         /*Make the root inode*/
         if (sb.fs_version == 3)
-                make_root_ino3(&sb);            
+                rc = make_root_ino3(&sb);               
         else
-                make_root_ino(&sb);
+                rc = make_root_ino(&sb);
+
+        if (rc != EOK) {
+                printf(NAME ": Error. Root inode initialization failed\n");
+                return 2;
+        }
 
         /*Insert directory entries . and ..*/
-        insert_dentries(&sb);
+        if (insert_dentries(&sb) != EOK) {
+                printf(NAME ": Error. Root directory initialization failed\n");
+                return 2;
+        }
 
         return 0;
 }
 
-static void insert_dentries(struct mfs_sb_info *sb)
+static int insert_dentries(struct mfs_sb_info *sb)
 {
         void *root_block;
+        int rc;
         const long root_dblock = sb->first_data_zone * (sb->block_size / MFS_MIN_BLOCKSIZE);
 
         root_block = (void *) malloc(MFS_MIN_BLOCKSIZE);
+
+        if (!root_block)
+                return ENOMEM;
         
         if (sb->fs_version != 3) {
@@ -284 +305 @@
         }
 
-        block_write_direct(sb->handle, root_dblock, 1, root_block);
+        rc = block_write_direct(sb->handle, root_dblock, 1, root_block);
 
         free(root_block);
-}
-
-static void init_inode_table(struct mfs_sb_info *sb)
+        return rc;
+}
+
+static int init_inode_table(struct mfs_sb_info *sb)
 {
         unsigned int i;
         uint8_t *itable_buf;
+        int rc;
         long itable_pos = 2 + sb->zbmap_blocks + sb->ibmap_blocks;
 
         itable_buf = malloc(sb->block_size);
+
+        if (!itable_buf)
+                return ENOMEM;
+
         memset(itable_buf, 0x00, sb->block_size);
 
         const int chunks = sb->block_size / MFS_BLOCKSIZE;
 
-        for (i = 0; i < sb->itable_size; ++i, itable_pos += chunks)
-                block_write_direct(sb->handle, itable_pos, chunks, itable_buf);
+        for (i = 0; i < sb->itable_size; ++i, itable_pos += chunks) {
+                rc = block_write_direct(sb->handle, itable_pos, chunks, itable_buf);
+
+                if (rc != EOK)
+                        break;
+        }
 
         free(itable_buf);
-}
-
-static void make_root_ino(struct mfs_sb_info *sb)
+        return rc;
+}
+
+static int make_root_ino(struct mfs_sb_info *sb)
 {
         struct mfs_inode *ino_buf;
         const long itable_pos = 2 + sb->zbmap_blocks + sb->ibmap_blocks;
+        int rc;
 
         const time_t sec = time(NULL);
 
         ino_buf = (struct mfs_inode *) malloc(MFS_BLOCKSIZE);
+
+        if (!ino_buf)
+                return ENOMEM;
+
         memset(ino_buf, 0x00, MFS_BLOCKSIZE);
 
@@ -324 +361 @@
         ino_buf[MFS_ROOT_INO].i_dzone[0] = sb->first_data_zone;
 
-        block_write_direct(sb->handle, itable_pos, 1, ino_buf);
+        rc = block_write_direct(sb->handle, itable_pos, 1, ino_buf);
 
         free(ino_buf);
-}
-
-static void make_root_ino3(struct mfs_sb_info *sb)
+        return rc;
+}
+
+static int make_root_ino3(struct mfs_sb_info *sb)
 {
         struct mfs2_inode *ino_buf;
         const size_t bufsize = MFS_MIN_BLOCKSIZE;
         const long itable_pos = 2 + sb->zbmap_blocks + sb->ibmap_blocks;
+        int rc;
 
         const time_t sec = time(NULL);
 
         ino_buf = (struct mfs2_inode *) malloc(bufsize);
+
+        if (!ino_buf)
+                return ENOMEM;
+
         memset(ino_buf, 0x00, bufsize);
 
@@ -350 +393 @@
         ino_buf[MFS_ROOT_INO].i_dzone[0] = sb->first_data_zone;
 
-        block_write_direct(sb->handle, itable_pos * (sb->block_size / MFS_MIN_BLOCKSIZE), 1, ino_buf);
+        rc = block_write_direct(sb->handle, itable_pos * (sb->block_size / MFS_MIN_BLOCKSIZE), 1, ino_buf);
 
         free(ino_buf);
-}
-
-static void init_superblock(struct mfs_sb_info *sb)
+        return rc;
+}
+
+static int init_superblock(struct mfs_sb_info *sb)
 {
         aoff64_t inodes;
+        int rc;
 
         if (sb->longnames)
@@ -409 +454 @@
         sb->log2_zone_size = 0;
 
+        /*Check for errors*/
+        if (sb->first_data_zone >= sb->n_zones) {
+                printf(NAME ": Error! Insufficient disk space");
+                return ENOMEM;
+        }
+
         /*Superblock is now ready to be written on disk*/
         printf(NAME ": %d inodes\n", (uint32_t) sb->n_inodes);
@@ -419 +470 @@
 
         if (sb->fs_version == 3)
-                write_superblock3(sb);
+                rc = write_superblock3(sb);
         else
-                write_superblock(sb);
-}
-
-static void write_superblock(struct mfs_sb_info *sbi)
+                rc = write_superblock(sb);
+
+        return rc;
+}
+
+static int write_superblock(struct mfs_sb_info *sbi)
 {
         struct mfs_superblock *sb;
+        int rc;
 
         sb = (struct mfs_superblock *) malloc(MFS_SUPERBLOCK_SIZE);;
+
+        if (!sb)
+                return ENOMEM;
 
         sb->s_ninodes = (uint16_t) sbi->n_inodes;
@@ -441 +498 @@
         sb->s_state = MFS_VALID_FS;
 
-        block_write_direct(sbi->handle, MFS_SUPERBLOCK, 1, sb);
+        rc = block_write_direct(sbi->handle, MFS_SUPERBLOCK, 1, sb);
         free(sb);
-}
-
-static void write_superblock3(struct mfs_sb_info *sbi)
+
+        return rc;
+}
+
+static int write_superblock3(struct mfs_sb_info *sbi)
 {
         struct mfs3_superblock *sb;
+        int rc;
 
         sb = (struct mfs3_superblock *) malloc(MFS_SUPERBLOCK_SIZE);
+
+        if (!sb)
+                return ENOMEM;
 
         sb->s_ninodes = (uint32_t) sbi->n_inodes;
@@ -462 +525 @@
         sb->s_disk_version = 3;
 
-        block_write_direct(sbi->handle, MFS_SUPERBLOCK, 1, sb);
+        rc = block_write_direct(sbi->handle, MFS_SUPERBLOCK, 1, sb);
         free(sb);
-}
-
-static void init_bitmaps(struct mfs_sb_info *sb)
+
+        return rc;
+}
+
+static int init_bitmaps(struct mfs_sb_info *sb)
 {
         uint32_t *ibmap_buf, *zbmap_buf;
@@ -472 +537 @@
         int zbmap_nblocks = 1 + (sb->n_zones / 8) / sb->block_size;
         unsigned int i;
+        int rc;
 
         ibmap_buf = (uint32_t *) malloc(ibmap_nblocks * sb->block_size);
         zbmap_buf = (uint32_t *) malloc(zbmap_nblocks * sb->block_size);
 
+        if (!ibmap_buf || !zbmap_buf)
+                return ENOMEM;
+
         memset(ibmap_buf, 0xFF, ibmap_nblocks * sb->block_size);
         memset(zbmap_buf, 0xFF, zbmap_nblocks * sb->block_size);
@@ -488 +557 @@
         zbmap_nblocks *= sb->block_size / MFS_BLOCKSIZE;
 
-        block_write_direct(sb->handle, 2, ibmap_nblocks, ibmap_buf);
-        block_write_direct(sb->handle, 2 + ibmap_nblocks, zbmap_nblocks, zbmap_buf);
-
-        free(ibmap_buf);
-        free(zbmap_buf);
+        if ((rc = block_write_direct(sb->handle, 2, ibmap_nblocks, ibmap_buf)) != EOK)
+                return rc;
+        if ((rc = block_write_direct(sb->handle, 2 + ibmap_nblocks, zbmap_nblocks, zbmap_buf)) != EOK)
+                return rc;
+
+        return rc;
 }