Changes in / [03f4acf:3958e315] in mainline

Location:

uspace

Files:

• app/mkmfs/mkmfs.c (modified) (31 diffs)
• srv/fs/mfs/mfs.c (modified) (1 diff)
• srv/fs/mfs/mfs_balloc.c (modified) (8 diffs)
• srv/fs/mfs/mfs_dentry.c (modified) (9 diffs)
• srv/fs/mfs/mfs_inode.c (modified) (12 diffs)
• srv/fs/mfs/mfs_ops.c (modified) (49 diffs)
• srv/fs/mfs/mfs_rw.c (modified) (13 diffs)
• srv/fs/mfs/mfs_utils.c (modified) (3 diffs)

uspace/app/mkmfs/mkmfs.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2010 Jiri Svoboda
  * Copyright (c) 2011 Maurizio Lombardi
  * All rights reserved.
@@ -56 +55 @@
 #define USED    1
 
-#define UPPER(n, size)                  (((n) / (size)) + (((n) % (size)) != 0))
-#define NEXT_DENTRY(p, dirsize)         (p += (dirsize))
+#define UPPER(n, size)          (((n) / (size)) + (((n) % (size)) != 0))
+#define NEXT_DENTRY(p, dirsize) (p += (dirsize))
 
 typedef enum {
@@ -64 +63 @@
 } help_level_t;
 
-/*Generic MFS superblock*/
+/* Generic MFS superblock */
 struct mfs_sb_info {
         uint64_t n_inodes;
@@ -84 +83 @@
 
 static void     help_cmd_mkmfs(help_level_t level);
-static int      num_of_set_bits(uint32_t n);
+static bool     is_power_of_two(uint32_t n);
 static int      init_superblock(struct mfs_sb_info *sb);
 static int      write_superblock(const struct mfs_sb_info *sbi);
@@ -118 +117 @@
         struct mfs_sb_info sb;
 
-        /*Default is MinixFS V3*/
+        /* Default is MinixFS V3 */
         sb.magic = MFS_MAGIC_V3;
         sb.fs_version = 3;
 
-        /*Default block size is 4Kb*/
+        /* Default block size is 4Kb */
         sb.block_size = MFS_MAX_BLOCKSIZE;
         sb.dirsize = MFS3_DIRSIZE;
@@ -136 +135 @@
 
         for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
-                c = getopt_long(argc, argv, "lh12b:i:", long_options, &opt_ind);
+                c = getopt_long(argc, argv, "lh12b:i:",
+                    long_options, &opt_ind);
                 switch (c) {
                 case 'h':
@@ -169 +169 @@
 
         if (sb.block_size < MFS_MIN_BLOCKSIZE || 
-                        sb.block_size > MFS_MAX_BLOCKSIZE) {
+            sb.block_size > MFS_MAX_BLOCKSIZE) {
                 printf(NAME ":Error! Invalid block size.\n");
                 exit(0);
-        } else if (num_of_set_bits(sb.block_size) != 1) {
-                /*Block size must be a power of 2.*/
+        } else if (!is_power_of_two(sb.block_size)) {
+                /* Block size must be a power of 2. */
                 printf(NAME ":Error! Invalid block size.\n");
                 exit(0);
         } else if (sb.block_size > MFS_BLOCKSIZE && 
-                        sb.fs_version != 3) {
-                printf(NAME ":Error! Block size > 1024 is supported by V3 filesystem only.\n");
+            sb.fs_version != 3) {
+                printf(NAME ":Error! Block size > 1024 is "
+                    "supported by V3 filesystem only.\n");
                 exit(0);
         } else if (sb.fs_version == 3 && sb.longnames) {
-                printf(NAME ":Error! Long filenames are supported by V1/V2 filesystem only.\n");
+                printf(NAME ":Error! Long filenames are supported "
+                    "by V1/V2 filesystem only.\n");
                 exit(0);
         }
@@ -221 +223 @@
         rc = block_get_nblocks(service_id, &sb.dev_nblocks);
         if (rc != EOK) {
-                printf(NAME ": Warning, failed to obtain block device size.\n");
+                printf(NAME ": Warning, failed to obtain "
+                    "block device size.\n");
         } else {
                 printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
-                                sb.dev_nblocks);
+                    sb.dev_nblocks);
         }
 
@@ -232 +235 @@
         }
 
-        /*Minimum block size is 1 Kb*/
+        /* Minimum block size is 1 Kb */
         sb.dev_nblocks /= 2;
 
         printf(NAME ": Creating Minix file system on device\n");
-
-        /*Initialize superblock*/
+        printf(NAME ": Writing superblock\n");
+
+        /* Initialize superblock */
         if (init_superblock(&sb) != EOK) {
                 printf(NAME ": Error. Superblock initialization failed\n");
@@ -243 +247 @@
         }
 
-        /*Initialize bitmaps*/
+        printf(NAME ": Initializing bitmaps\n");
+
+        /* Initialize bitmaps */
         if (init_bitmaps(&sb) != EOK) {
                 printf(NAME ": Error. Bitmaps initialization failed\n");
@@ -249 +255 @@
         }
 
-        /*Init inode table*/
+        printf(NAME ": Initializing the inode table\n");
+
+        /* Init inode table */
         if (init_inode_table(&sb) != EOK) {
                 printf(NAME ": Error. Inode table initialization failed\n");
@@ -255 +263 @@
         }
 
-        /*Make the root inode*/
+        printf(NAME ": Creating the root directory inode\n");
+
+        /* Make the root inode */
         if (sb.fs_version == 1)
                 rc = make_root_ino(&sb);
@@ -266 +276 @@
         }
 
-        /*Insert directory entries . and ..*/
+        /* Insert directory entries . and .. */
         if (insert_dentries(&sb) != EOK) {
                 printf(NAME ": Error. Root directory initialization failed\n");
@@ -299 +309 @@
 
         if (sb->fs_version != 3) {
-                /*Directory entries for V1/V2 filesystem*/
+                /* Directory entries for V1/V2 filesystem */
                 struct mfs_dentry *dentry = root_block;
 
@@ -306 +316 @@
 
                 dentry = (struct mfs_dentry *) NEXT_DENTRY(dentry_ptr,
-                                sb->dirsize);
+                    sb->dirsize);
 
                 dentry->d_inum = MFS_ROOT_INO;
                 memcpy(dentry->d_name, "..\0", 3);
         } else {
-                /*Directory entries for V3 filesystem*/
+                /* Directory entries for V3 filesystem */
                 struct mfs3_dentry *dentry = root_block;
 
@@ -318 +328 @@
 
                 dentry = (struct mfs3_dentry *) NEXT_DENTRY(dentry_ptr,
-                                sb->dirsize);
+                    sb->dirsize);
 
                 dentry->d_inum = MFS_ROOT_INO;
@@ -389 +399 @@
         ino_buf[MFS_ROOT_INO - 1].i_gid = 0;
         ino_buf[MFS_ROOT_INO - 1].i_size = (sb->longnames ? MFSL_DIRSIZE :
-        MFS_DIRSIZE) * 2;
+            MFS_DIRSIZE) * 2;
         ino_buf[MFS_ROOT_INO - 1].i_mtime = sec;
         ino_buf[MFS_ROOT_INO - 1].i_nlinks = 2;
@@ -411 +421 @@
         int rc;
 
-        /*Compute offset of the first inode table block*/
+        /* Compute offset of the first inode table block */
         const long itable_off = sb->zbmap_blocks + sb->ibmap_blocks + 2;
 
@@ -454 +464 @@
 
         if (sb->longnames)
-                sb->magic = sb->fs_version == 1 ? MFS_MAGIC_V1L : MFS_MAGIC_V2L;
-
-        /*Compute the number of zones on disk*/
+                sb->magic = sb->fs_version == 1 ? MFS_MAGIC_V1L :
+                    MFS_MAGIC_V2L;
+
+        /* Compute the number of zones on disk */
 
         if (sb->fs_version == 1) {
-                /*Valid only for MFS V1*/
+                /* Valid only for MFS V1 */
                 sb->n_zones = sb->dev_nblocks > UINT16_MAX ? 
-                                UINT16_MAX : sb->dev_nblocks;
+                    UINT16_MAX : sb->dev_nblocks;
                 ind = MFS_BLOCKSIZE / sizeof(uint16_t);
                 ind2 = ind * ind;
-                sb->max_file_size = (V1_NR_DIRECT_ZONES + ind + ind2) * MFS_BLOCKSIZE;
+                sb->max_file_size = (V1_NR_DIRECT_ZONES + ind + ind2) *
+                    MFS_BLOCKSIZE;
         } else {
                 /*Valid for MFS V2/V3*/
@@ -472 +484 @@
                 else
                         ptrsize = sizeof(uint32_t);
+
                 ind = sb->block_size / ptrsize;
                 ind2 = ind * ind;
@@ -477 +490 @@
                 sb->max_file_size = zones * sb->block_size;
                 sb->n_zones = sb->dev_nblocks > UINT32_MAX ?
-                                UINT32_MAX : sb->dev_nblocks;
+                    UINT32_MAX : sb->dev_nblocks;
 
                 if (sb->fs_version == 3) {
@@ -487 +500 @@
         }
 
-        /*Round up the number of inodes to fill block size*/
+        /* Round up the number of inodes to fill block size */
         if (sb->n_inodes == 0)
                 inodes = sb->dev_nblocks / 3;
@@ -494 +507 @@
 
         if (inodes % sb->ino_per_block)
-                inodes = ((inodes / sb->ino_per_block) + 1) * sb->ino_per_block;
+                inodes = ((inodes / sb->ino_per_block) + 1) *
+                    sb->ino_per_block;
 
         if (sb->fs_version < 3)
@@ -501 +515 @@
                 sb->n_inodes = inodes > UINT32_MAX ? UINT32_MAX : inodes;
 
-        /*Compute inode bitmap size in blocks*/
+        /* Compute inode bitmap size in blocks */
         sb->ibmap_blocks = UPPER(sb->n_inodes, sb->block_size * 8);
 
-        /*Compute inode table size*/
+        /* Compute inode table size */
         sb->itable_size = sb->n_inodes / sb->ino_per_block;
 
-        /*Compute zone bitmap size in blocks*/
+        /* Compute zone bitmap size in blocks */
         sb->zbmap_blocks = UPPER(sb->n_zones, sb->block_size * 8);
 
-        /*Compute first data zone position*/
+        /* Compute first data zone position */
         sb->first_data_zone = 2 + sb->itable_size + 
-                        sb->zbmap_blocks + sb->ibmap_blocks;
-
-        /*Set log2 of zone to block ratio to zero*/
+            sb->zbmap_blocks + sb->ibmap_blocks;
+
+        /* Set log2 of zone to block ratio to zero */
         sb->log2_zone_size = 0;
 
-        /*Check for errors*/
+        /* Check for errors */
         if (sb->first_data_zone >= sb->n_zones) {
                 printf(NAME ": Error! Insufficient disk space");
@@ -523 +537 @@
         }
 
-        /*Superblock is now ready to be written on disk*/
+        /* Superblock is now ready to be written on disk */
         printf(NAME ": %d block size\n", sb->block_size);
         printf(NAME ": %d inodes\n", (uint32_t) sb->n_inodes);
@@ -530 +544 @@
         printf(NAME ": inode bitmap blocks = %ld\n", sb->ibmap_blocks);
         printf(NAME ": zone bitmap blocks = %ld\n", sb->zbmap_blocks);
-        printf(NAME ": first data zone = %d\n", (uint32_t) sb->first_data_zone);
+        printf(NAME ": first data zone = %d\n", (uint32_t)sb->first_data_zone);
         printf(NAME ": max file size = %u\n", sb->max_file_size);
         printf(NAME ": long fnames = %s\n", sb->longnames ? "Yes" : "No");
@@ -645 +659 @@
         for (i = 0; i < ibmap_nblocks; ++i) {
                 if ((rc = write_block(start_block + i,
-                                1, (ibmap_buf8 + i * sb->block_size))) != EOK)
+                    1, (ibmap_buf8 + i * sb->block_size))) != EOK)
                         return rc;
         }
@@ -653 +667 @@
         for (i = 0; i < zbmap_nblocks; ++i) {
                 if ((rc = write_block(start_block + i,
-                                1, (zbmap_buf8 + i * sb->block_size))) != EOK)
+                    1, (zbmap_buf8 + i * sb->block_size))) != EOK)
                         return rc;
         }
@@ -692 +706 @@
                 uint8_t *data_ptr = (uint8_t *) data;
 
-                rc = block_write_direct(service_id, tmp_off << 2, size << 2, data_ptr);
+                rc = block_write_direct(service_id, tmp_off << 2,
+                    size << 2, data_ptr);
 
                 if (rc != EOK)
@@ -700 +715 @@
                 tmp_off++;
 
-                return block_write_direct(service_id, tmp_off << 2, size << 2, data_ptr);
-        }
-        return block_write_direct(service_id, off << shift, size << shift, data);
+                return block_write_direct(service_id, tmp_off << 2,
+                    size << 2, data_ptr);
+        }
+        return block_write_direct(service_id, off << shift,
+            size << shift, data);
 }
 
@@ -711 +728 @@
         } else {
                 printf("Usage: [options] device\n"
-                                "-1         Make a Minix version 1 filesystem\n"
-                                "-2         Make a Minix version 2 filesystem\n"
-                                "-b ##      Specify the block size in bytes (V3 only),\n"
-                                "           valid block size values are 1024, 2048 and 4096 bytes per block\n"
-                                "-i ##      Specify the number of inodes for the filesystem\n"
-                                "-l         Use 30-char long filenames (V1/V2 only)\n");
-        }
-}
-
-static int num_of_set_bits(uint32_t n)
-{
-        n = n - ((n >> 1) & 0x55555555);
-        n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
-        return (((n + (n >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
+                    "-1         Make a Minix version 1 filesystem\n"
+                    "-2         Make a Minix version 2 filesystem\n"
+                    "-b ##      Specify the block size in bytes (V3 only),\n"
+                    "           valid block size values are 1024, 2048 and"
+                                " 4096 bytes per block\n"
+                    "-i ##      Specify the number of inodes"
+                                " for the filesystem\n"
+                    "-l         Use 30-char long filenames (V1/V2 only)\n");
+        }
+}
+
+/** Check if a given number is a power of two.
+ *
+ * @param n     The number to check.
+ *
+ * @return      true if it is a power of two, false otherwise.
+ */
+static bool is_power_of_two(uint32_t n)
+{
+        if (n == 0)
+                return false;
+
+        return (n & (n - 1)) == 0;
 }
 

uspace/srv/fs/mfs/mfs.c

@@ -74 +74 @@
 
         async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
-                                SERVICE_VFS, 0, 0);
+            SERVICE_VFS, 0, 0);
 
         if (!vfs_sess) {

uspace/srv/fs/mfs/mfs_balloc.c

@@ -36 +36 @@
 static int
 find_free_bit_and_set(bitchunk_t *b, const int bsize,
-                      const bool native, unsigned start_bit);
+    const bool native, unsigned start_bit);
 
 static int
@@ -129 +129 @@
                 if (idx > sbi->nzones) {
                         printf(NAME ": Error! Trying to free beyond the" \
-                               "bitmap max size\n");
+                            "bitmap max size\n");
                         return -1;
                 }
         } else {
-                /*bid == BMAP_INODE*/
+                /* bid == BMAP_INODE */
                 search = &sbi->isearch;
                 start_block = 2;
                 if (idx > sbi->ninodes) {
                         printf(NAME ": Error! Trying to free beyond the" \
-                               "bitmap max size\n");
+                            "bitmap max size\n");
                         return -1;
                 }
         }
 
-        /*Compute the bitmap block*/
+        /* Compute the bitmap block */
         uint32_t block = idx / (sbi->block_size * 8) + start_block;
 
@@ -150 +150 @@
                 goto out_err;
 
-        /*Compute the bit index in the block*/
+        /* Compute the bit index in the block */
         idx %= (sbi->block_size * 8);
         bitchunk_t *ptr = b->data;
@@ -220 +220 @@
 
                 freebit = find_free_bit_and_set(b->data, sbi->block_size,
-                                                sbi->native, tmp);
+                    sbi->native, tmp);
                 if (freebit == -1) {
-                        /*No free bit in this block*/
+                        /* No free bit in this block */
                         r = block_put(b);
                         if (r != EOK)
@@ -229 +229 @@
                 }
 
-                /*Free bit found in this block, compute the real index*/
+                /* Free bit found in this block, compute the real index */
                 *idx = freebit + bits_per_block * i;
                 if (*idx > limit) {
-                        /*Index is beyond the limit, it is invalid*/
+                        /* Index is beyond the limit, it is invalid */
                         r = block_put(b);
                         if (r != EOK)
@@ -246 +246 @@
 
         if (*search > 0) {
-                /*Repeat the search from the first bitmap block*/
+                /* Repeat the search from the first bitmap block */
                 *search = 0;
                 goto retry;
         }
 
-        /*Free bit not found, return error*/
+        /* Free bit not found, return error */
         return ENOSPC;
 
@@ -260 +260 @@
 static int
 find_free_bit_and_set(bitchunk_t *b, const int bsize,
-                      const bool native, unsigned start_bit)
+    const bool native, unsigned start_bit)
 {
         int r = -1;
@@ -268 +268 @@
 
         for (i = start_bit / chunk_bits;
-             i < bsize / sizeof(bitchunk_t); ++i) {
+            i < bsize / sizeof(bitchunk_t); ++i) {
+
                 if (!(~b[i])) {
-                        /*No free bit in this chunk*/
+                        /* No free bit in this chunk */
                         continue;
                 }

uspace/srv/fs/mfs/mfs_dentry.c

@@ -44 +44 @@
 int
 mfs_read_dentry(struct mfs_node *mnode,
-                     struct mfs_dentry_info *d_info, unsigned index)
+    struct mfs_dentry_info *d_info, unsigned index)
 {
         const struct mfs_instance *inst = mnode->instance;
@@ -57 +57 @@
 
         if (block == 0) {
-                /*End of the dentries list*/
+                /* End of the dentries list */
                 r = EOK;
                 goto out_err;
@@ -79 +79 @@
         } else {
                 const int namelen = longnames ? MFS_L_MAX_NAME_LEN :
-                                    MFS_MAX_NAME_LEN;
+                    MFS_MAX_NAME_LEN;
 
                 struct mfs_dentry *d;
 
                 d = b->data + dentry_off * (longnames ? MFSL_DIRSIZE :
-                                            MFS_DIRSIZE);
+                    MFS_DIRSIZE);
                 d_info->d_inum = conv16(sbi->native, d->d_inum);
                 memcpy(d_info->d_name, d->d_name, namelen);
@@ -101 +101 @@
 /**Write a directory entry on disk.
  *
- * @param d_info        Pointer to the directory entry structure to write on disk.
- *
- * @return              EOK on success or a negative error code.
+ * @param d_info Pointer to the directory entry structure to write on disk.
+ *
+ * @return       EOK on success or a negative error code.
  */
 int
@@ -178 +178 @@
 
                 if (name_len == d_name_len &&
-                                !bcmp(d_info.d_name, d_name, name_len)) {
+                    !bcmp(d_info.d_name, d_name, name_len)) {
+
                         d_info.d_inum = 0;
                         r = mfs_write_dentry(&d_info);
@@ -197 +198 @@
  */
 int
-mfs_insert_dentry(struct mfs_node *mnode, const char *d_name, fs_index_t d_inum)
+mfs_insert_dentry(struct mfs_node *mnode, const char *d_name,
+    fs_index_t d_inum)
 {
         int r;
@@ -209 +211 @@
                 return ENAMETOOLONG;
 
-        /*Search for an empty dentry*/
+        /* Search for an empty dentry */
         unsigned i;
         for (i = 0; i < mnode->ino_i->i_size / sbi->dirsize; ++i) {
@@ -217 +219 @@
 
                 if (d_info.d_inum == 0) {
-                        /*This entry is not used*/
+                        /* This entry is not used */
                         empty_dentry_found = true;
                         break;
@@ -231 +233 @@
 
                 if (b == 0) {
-                        /*Increase the inode size*/
+                        /* Increase the inode size */
 
                         uint32_t dummy;

uspace/srv/fs/mfs/mfs_inode.c

@@ -42 +42 @@
 static int
 mfs_read_inode_raw(const struct mfs_instance *instance,
-                struct mfs_ino_info **ino_ptr, uint16_t inum);
+    struct mfs_ino_info **ino_ptr, uint16_t inum);
 
 static int
 mfs2_read_inode_raw(const struct mfs_instance *instance,
-                struct mfs_ino_info **ino_ptr, uint32_t inum);
+    struct mfs_ino_info **ino_ptr, uint32_t inum);
 
 /**Read a MINIX inode from disk
@@ -59 +59 @@
 int
 mfs_get_inode(struct mfs_instance *inst, struct mfs_ino_info **ino_i,
-          fs_index_t index)
+    fs_index_t index)
 {
         struct mfs_sb_info *sbi = inst->sbi;
@@ -65 +65 @@
 
         if (sbi->fs_version == MFS_VERSION_V1) {
-                /*Read a MFS V1 inode*/
+                /* Read a MFS V1 inode */
                 r = mfs_read_inode_raw(inst, ino_i, index);
         } else {
-                /*Read a MFS V2/V3 inode*/
+                /* Read a MFS V2/V3 inode */
                 r = mfs2_read_inode_raw(inst, ino_i, index);
         }
@@ -77 +77 @@
 static int
 mfs_read_inode_raw(const struct mfs_instance *instance,
-                struct mfs_ino_info **ino_ptr, uint16_t inum) {
+    struct mfs_ino_info **ino_ptr, uint16_t inum)
+{
         struct mfs_inode *ino;
         struct mfs_ino_info *ino_i = NULL;
@@ -86 +87 @@
         sbi = instance->sbi;
 
-        /*inode 0 does not exist*/
+        /* inode 0 does not exist */
         inum -= 1;
 
@@ -101 +102 @@
 
         r = block_get(&b, instance->service_id,
-                      itable_off + inum / sbi->ino_per_block,
-                      BLOCK_FLAGS_NONE);
+            itable_off + inum / sbi->ino_per_block,
+            BLOCK_FLAGS_NONE);
+
         if (r != EOK)
                 goto out_err;
@@ -134 +136 @@
 static int
 mfs2_read_inode_raw(const struct mfs_instance *instance,
-                struct mfs_ino_info **ino_ptr, uint32_t inum) {
+    struct mfs_ino_info **ino_ptr, uint32_t inum)
+{
         struct mfs2_inode *ino;
         struct mfs_ino_info *ino_i = NULL;
@@ -150 +153 @@
         sbi = instance->sbi;
 
-        /*inode 0 does not exist*/
+        /* inode 0 does not exist */
         inum -= 1;
 
@@ -157 +160 @@
 
         r = block_get(&b, instance->service_id,
-                      itable_off + inum / sbi->ino_per_block,
-                      BLOCK_FLAGS_NONE);
+            itable_off + inum / sbi->ino_per_block,
+            BLOCK_FLAGS_NONE);
+
         if (r != EOK)
                 goto out_err;
@@ -322 +326 @@
 
         if (size_shrink == 0) {
-                /*File is empty*/
+                /* Nothing to be done */
                 return EOK;
         }
@@ -333 +337 @@
         ino_i->dirty = true;
 
-        /*Compute the number of zones to free*/
+        /* Compute the number of zones to free */
         unsigned zones_to_free;
 
@@ -354 +358 @@
 
                 if (old_zone == 0)
-                        continue; /*Sparse block*/
+                        continue; /* Sparse block */
 
                 r = mfs_free_zone(mnode->instance, old_zone);

uspace/srv/fs/mfs/mfs_ops.c

@@ -43 +43 @@
 
 static bool check_magic_number(uint16_t magic, bool *native,
-                               mfs_version_t *version, bool *longfilenames);
+    mfs_version_t *version, bool *longfilenames);
 static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
-                             fs_index_t index);
-
+    fs_index_t index);
 static int mfs_node_put(fs_node_t *fsnode);
 static int mfs_node_open(fs_node_t *fsnode);
@@ -64 +63 @@
 static hash_index_t open_nodes_hash(unsigned long key[]);
 static int open_nodes_compare(unsigned long key[], hash_count_t keys,
-                link_t *item);
+    link_t *item);
 static void open_nodes_remove_cb(link_t *link);
-
 static int mfs_node_get(fs_node_t **rfn, service_id_t service_id,
-                        fs_index_t index);
-static int
-mfs_instance_get(service_id_t service_id, struct mfs_instance **instance);
-
+    fs_index_t index);
+static int mfs_instance_get(service_id_t service_id,
+    struct mfs_instance **instance);
+static int mfs_check_sanity(struct mfs_sb_info *sbi);
+static bool is_power_of_two(uint32_t n);
 
 static hash_table_t open_nodes;
@@ -96 +95 @@
 
 /* Hash table interface for open nodes hash table */
-static hash_index_t open_nodes_hash(unsigned long key[])
+static hash_index_t
+open_nodes_hash(unsigned long key[])
 {
         /* TODO: This is very simple and probably can be improved */
@@ -102 +102 @@
 }
 
-static int open_nodes_compare(unsigned long key[], hash_count_t keys,
-                link_t *item)
+static int
+open_nodes_compare(unsigned long key[], hash_count_t keys,
+    link_t *item)
 {
         struct mfs_node *mnode = hash_table_get_instance(item, struct mfs_node, link);
@@ -118 +119 @@
 }
 
-static void open_nodes_remove_cb(link_t *link)
+static void
+open_nodes_remove_cb(link_t *link)
 {
         /* We don't use remove callback for this hash table */
@@ -129 +131 @@
 };
 
-int mfs_global_init(void)
+int
+mfs_global_init(void)
 {
         if (!hash_table_create(&open_nodes, OPEN_NODES_BUCKETS,
-                        OPEN_NODES_KEYS, &open_nodes_ops)) {
+            OPEN_NODES_KEYS, &open_nodes_ops)) {
                 return ENOMEM;
         }
@@ -140 +143 @@
 static int
 mfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
-                aoff64_t *size, unsigned *linkcnt)
+    aoff64_t *size, unsigned *linkcnt)
 {
         enum cache_mode cmode;
@@ -163 +166 @@
                 return rc;
 
-        /*Allocate space for generic MFS superblock*/
+        /* Allocate space for generic MFS superblock */
         sbi = malloc(sizeof(*sbi));
         if (!sbi) {
@@ -170 +173 @@
         }
 
-        /*Allocate space for filesystem instance*/
+        /* Allocate space for filesystem instance */
         instance = malloc(sizeof(*instance));
         if (!instance) {
@@ -191 +194 @@
 
         if (check_magic_number(sb->s_magic, &native, &version, &longnames)) {
-                /*This is a V1 or V2 Minix filesystem*/
+                /* This is a V1 or V2 Minix filesystem */
                 magic = sb->s_magic;
         } else if (check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
-                /*This is a V3 Minix filesystem*/
+                /* This is a V3 Minix filesystem */
                 magic = sb3->s_magic;
         } else {
-                /*Not recognized*/
+                /* Not recognized */
                 mfsdebug("magic number not recognized\n");
                 rc = ENOTSUP;
@@ -205 +208 @@
         mfsdebug("magic number recognized = %04x\n", magic);
 
-        /*Fill superblock info structure*/
+        /* Fill superblock info structure */
 
         sbi->fs_version = version;
@@ -243 +246 @@
                 sbi->dirsize = longnames ? MFSL_DIRSIZE : MFS_DIRSIZE;
                 sbi->max_name_len = longnames ? MFS_L_MAX_NAME_LEN :
-                                    MFS_MAX_NAME_LEN;
+                    MFS_MAX_NAME_LEN;
         }
 
@@ -259 +262 @@
 
         sbi->itable_off = 2 + sbi->ibmap_blocks + sbi->zbmap_blocks;
+        if ((rc = mfs_check_sanity(sbi)) != EOK) {
+                fprintf(stderr, "Filesystem corrupted, invalid superblock");
+                goto out_error;
+        }
 
         rc = block_cache_init(service_id, sbi->block_size, 0, cmode);
@@ -267 +274 @@
         }
 
-        /*Initialize the instance structure and remember it*/
+        /* Initialize the instance structure and remember it */
         instance->service_id = service_id;
         instance->sbi = sbi;
@@ -273 +280 @@
         rc = fs_instance_create(service_id, instance);
         if (rc != EOK) {
-                free(instance);
-                free(sbi);
                 block_cache_fini(service_id);
-                block_fini(service_id);
                 mfsdebug("fs instance creation failed\n");
-                return rc;
+                goto out_error;
         }
 
@@ -331 +335 @@
 }
 
-service_id_t mfs_service_get(fs_node_t *fsnode)
+service_id_t
+mfs_service_get(fs_node_t *fsnode)
 {
         struct mfs_node *node = fsnode->data;
@@ -337 +342 @@
 }
 
-static int mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
+static int
+mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
 {
         int r;
@@ -351 +357 @@
                 return r;
 
-        /*Alloc a new inode*/
+        /* Alloc a new inode */
         r = mfs_alloc_inode(inst, &inum);
         if (r != EOK)
@@ -378 +384 @@
         if (flags & L_DIRECTORY) {
                 ino_i->i_mode = S_IFDIR;
-                ino_i->i_nlinks = 2; /*This accounts for the '.' dentry*/
+                ino_i->i_nlinks = 2; /* This accounts for the '.' dentry */
         } else {
                 ino_i->i_mode = S_IFREG;
@@ -431 +437 @@
 }
 
-static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
+static int
+mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
 {
         struct mfs_node *mnode = pfn->data;
@@ -453 +460 @@
 
                 if (!d_info.d_inum) {
-                        /*This entry is not used*/
+                        /* This entry is not used */
                         continue;
                 }
@@ -460 +467 @@
 
                 if (comp_size == dentry_name_size &&
-                        !bcmp(component, d_info.d_name, dentry_name_size)) {
-                        /*Hit!*/
+                    !bcmp(component, d_info.d_name, dentry_name_size)) {
+                        /* Hit! */
                         mfs_node_core_get(rfn, mnode->instance,
-                                          d_info.d_inum);
+                            d_info.d_inum);
                         goto found;
                 }
@@ -472 +479 @@
 }
 
-static aoff64_t mfs_size_get(fs_node_t *node)
+static aoff64_t
+mfs_size_get(fs_node_t *node)
 {
         const struct mfs_node *mnode = node->data;
@@ -480 +488 @@
 static int
 mfs_node_get(fs_node_t **rfn, service_id_t service_id,
-                        fs_index_t index)
+    fs_index_t index)
 {
         int rc;
@@ -524 +532 @@
 }
 
-static int mfs_node_open(fs_node_t *fsnode)
+static int
+mfs_node_open(fs_node_t *fsnode)
 {
         /*
@@ -533 +542 @@
 }
 
-static fs_index_t mfs_index_get(fs_node_t *fsnode)
+static fs_index_t
+mfs_index_get(fs_node_t *fsnode)
 {
         struct mfs_node *mnode = fsnode->data;
@@ -539 +549 @@
 }
 
-static unsigned mfs_lnkcnt_get(fs_node_t *fsnode)
+static unsigned
+mfs_lnkcnt_get(fs_node_t *fsnode)
 {
         struct mfs_node *mnode = fsnode->data;
@@ -554 +565 @@
 }
 
-static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
-                             fs_index_t index)
+static int
+mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
+    fs_index_t index)
 {
         fs_node_t *node = NULL;
@@ -627 +639 @@
 }
 
-static bool mfs_is_directory(fs_node_t *fsnode)
+static bool
+mfs_is_directory(fs_node_t *fsnode)
 {
         const struct mfs_node *node = fsnode->data;
@@ -633 +646 @@
 }
 
-static bool mfs_is_file(fs_node_t *fsnode)
+static bool
+mfs_is_file(fs_node_t *fsnode)
 {
         struct mfs_node *node = fsnode->data;
@@ -639 +653 @@
 }
 
-static int mfs_root_get(fs_node_t **rfn, service_id_t service_id)
+static int
+mfs_root_get(fs_node_t **rfn, service_id_t service_id)
 {
         int rc = mfs_node_get(rfn, service_id, MFS_ROOT_INO);
@@ -645 +660 @@
 }
 
-static int mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+static int
+mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
 {
         struct mfs_node *parent = pfn->data;
@@ -720 +736 @@
 }
 
-static int mfs_has_children(bool *has_children, fs_node_t *fsnode)
+static int
+mfs_has_children(bool *has_children, fs_node_t *fsnode)
 {
         struct mfs_node *mnode = fsnode->data;
@@ -741 +758 @@
 
                 if (d_info.d_inum) {
-                        /*A valid entry has been found*/
+                        /* A valid entry has been found */
                         *has_children = true;
                         break;
@@ -753 +770 @@
 static int
 mfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
-                size_t *rbytes)
+    size_t *rbytes)
 {
         int rc;
@@ -783 +800 @@
 
                 if (pos < 2) {
-                        /*Skip the first two dentries ('.' and '..')*/
+                        /* Skip the first two dentries ('.' and '..') */
                         pos = 2;
                 }
@@ -793 +810 @@
 
                         if (d_info.d_inum) {
-                                /*Dentry found!*/
+                                /* Dentry found! */
                                 goto found;
                         }
@@ -809 +826 @@
 
                 if (pos >= (size_t) ino_i->i_size) {
-                        /*Trying to read beyond the end of file*/
+                        /* Trying to read beyond the end of file */
                         bytes = 0;
                         (void) async_data_read_finalize(callid, NULL, 0);
@@ -826 +843 @@
 
                 if (zone == 0) {
-                        /*sparse file*/
+                        /* sparse file */
                         uint8_t *buf = malloc(sbi->block_size);
                         if (!buf) {
@@ -834 +851 @@
                         memset(buf, 0, sizeof(sbi->block_size));
                         async_data_read_finalize(callid,
-                                                 buf + pos % sbi->block_size, bytes);
+                            buf + pos % sbi->block_size, bytes);
                         free(buf);
                         goto out_success;
@@ -844 +861 @@
 
                 async_data_read_finalize(callid, b->data +
-                                         pos % sbi->block_size, bytes);
+                    pos % sbi->block_size, bytes);
 
                 rc = block_put(b);
@@ -865 +882 @@
 static int
 mfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
-                size_t *wbytes, aoff64_t *nsize)
+    size_t *wbytes, aoff64_t *nsize)
 {
         fs_node_t *fn;
@@ -900 +917 @@
 
         if (block == 0) {
-                /*Writing in a sparse block*/
                 uint32_t dummy;
 
@@ -958 +974 @@
                 return ENOENT;
 
-        /*Destroy the inode*/
+        /* Destroy the inode */
         return mfs_destroy_node(fn);
 }
@@ -977 +993 @@
         assert(!has_children);
 
-        /*Free the entire inode content*/
+        /* Free the entire inode content */
         r = mfs_inode_shrink(mnode, mnode->ino_i->i_size);
         if (r != EOK)
                 goto out;
 
-        /*Mark the inode as free in the bitmap*/
+        /* Mark the inode as free in the bitmap */
         r = mfs_free_inode(mnode->instance, mnode->ino_i->index);
 
@@ -1021 +1037 @@
 
         rc = fs_instance_get(service_id, &data);
-        if (rc == EOK) {
+        if (rc == EOK)
                 *instance = (struct mfs_instance *) data;
-        } else {
+        else {
                 mfsdebug("instance not found\n");
         }
@@ -1030 +1046 @@
 }
 
-static bool check_magic_number(uint16_t magic, bool *native,
-                               mfs_version_t *version, bool *longfilenames)
+static bool
+check_magic_number(uint16_t magic, bool *native,
+                mfs_version_t *version, bool *longfilenames)
 {
         bool rc = true;
@@ -1059 +1076 @@
 }
 
+/** Filesystem sanity check
+ *
+ * @param Pointer to the MFS superblock.
+ *
+ * @return EOK on success, ENOTSUP otherwise.
+ */
+static int
+mfs_check_sanity(struct mfs_sb_info *sbi)
+{
+        if (!is_power_of_two(sbi->block_size) ||
+            sbi->block_size < MFS_MIN_BLOCKSIZE ||
+            sbi->block_size > MFS_MAX_BLOCKSIZE)
+                return ENOTSUP;
+        else if (sbi->ibmap_blocks == 0 || sbi->zbmap_blocks == 0)
+                return ENOTSUP;
+        else if (sbi->ninodes == 0 || sbi->nzones == 0)
+                return ENOTSUP;
+        else if (sbi->firstdatazone == 0)
+                return ENOTSUP;
+
+        return EOK;
+}
+
 static int
 mfs_close(service_id_t service_id, fs_index_t index)
@@ -1079 +1119 @@
 
         return mfs_node_put(fn);
+}
+
+/** Check if a given number is a power of two.
+ *
+ * @param n     The number to check.
+ *
+ * @return      true if it is a power of two, false otherwise.
+ */
+static bool
+is_power_of_two(uint32_t n)
+{
+        if (n == 0)
+                return false;
+
+        return (n & (n - 1)) == 0;
 }
 

uspace/srv/fs/mfs/mfs_rw.c

@@ -36 +36 @@
 static int
 rw_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock,
-              bool write_mode, uint32_t w_block);
+    bool write_mode, uint32_t w_block);
 
 static int
@@ -68 +68 @@
         const int block_size = sbi->block_size;
 
-        /*Compute relative block number in file*/
+        /* Compute relative block number in file */
         int rblock = pos / block_size;
 
         if (ROUND_UP(mnode->ino_i->i_size, sbi->block_size) < pos) {
-                /*Trying to read beyond the end of file*/
+                /* Trying to read beyond the end of file */
                 r = EOK;
                 *b = 0;
@@ -85 +85 @@
 int
 mfs_write_map(struct mfs_node *mnode, const uint32_t pos, uint32_t new_zone,
-          uint32_t *old_zone)
+    uint32_t *old_zone)
 {
         const struct mfs_sb_info *sbi = mnode->instance->sbi;
 
         if (pos >= sbi->max_file_size) {
-                /*Can't write beyond the maximum file size*/
+                /* Can't write beyond the maximum file size */
                 return EINVAL;
         }
 
-        /*Compute the relative block number in file*/
+        /* Compute the relative block number in file */
         int rblock = pos / sbi->block_size;
 
@@ -102 +102 @@
 static int
 rw_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock,
-              bool write_mode, uint32_t w_block)
+    bool write_mode, uint32_t w_block)
 {
         int r, nr_direct;
@@ -123 +123 @@
         }
 
-        /*Check if the wanted block is in the direct zones*/
+        /* Check if the wanted block is in the direct zones */
         if (rblock < nr_direct) {
                 *b = ino_i->i_dzone[rblock];
@@ -136 +136 @@
 
         if (rblock < ptrs_per_block) {
-                /*The wanted block is in the single indirect zone chain*/
+                /* The wanted block is in the single indirect zone chain */
                 if (ino_i->i_izone[0] == 0) {
                         if (write_mode && !deleting) {
@@ -168 +168 @@
         rblock -= ptrs_per_block;
 
-        /*The wanted block is in the double indirect zone chain*/
-
-        /*read the first indirect zone of the chain*/
+        /* The wanted block is in the double indirect zone chain */
+
+        /* Read the first indirect zone of the chain */
         if (ino_i->i_izone[1] == 0) {
                 if (write_mode && !deleting) {
@@ -181 +181 @@
                         ino_i->dirty = true;
                 } else {
-                        /*Sparse block*/
+                        /* Sparse block */
                         *b = 0;
                         return EOK;
@@ -192 +192 @@
 
         /*
-         *Compute the position of the second indirect
-         *zone pointer in the chain.
+         * Compute the position of the second indirect
+         * zone pointer in the chain.
          */
         uint32_t ind2_off = rblock / ptrs_per_block;
 
-        /*read the second indirect zone of the chain*/
+        /* read the second indirect zone of the chain */
         if (ind_zone[ind2_off] == 0) {
                 if (write_mode && !deleting) {
@@ -208 +208 @@
                         write_ind_zone(inst, ino_i->i_izone[1], ind_zone);
                 } else {
-                        /*Sparse block*/
+                        /* Sparse block */
                         r = EOK;
                         *b = 0;
@@ -264 +264 @@
 
         if (rblock < nr_direct) {
-                /*free the single indirect zone*/
+                /* Free the single indirect zone */
                 if (ino_i->i_izone[0]) {
                         r = mfs_free_zone(inst, ino_i->i_izone[0]);
@@ -282 +282 @@
                 ++fzone_to_free;
 
-        /*free the entire double indirect zone*/
+        /* Free the entire double indirect zone */
         uint32_t *dbl_zone;
 
         if (ino_i->i_izone[1] == 0) {
-                /*Nothing to be done*/
+                /* Nothing to be done */
                 return EOK;
         }
@@ -350 +350 @@
         block_t *b;
         const int max_ind_zone_ptrs = (MFS_MAX_BLOCKSIZE / sizeof(uint16_t)) *
-                                      sizeof(uint32_t);
+            sizeof(uint32_t);
 
         *ind_zone = malloc(max_ind_zone_ptrs);

uspace/srv/fs/mfs/mfs_utils.c

@@ -34 +34 @@
 #include "mfs.h"
 
-uint16_t conv16(bool native, uint16_t n)
+uint16_t
+conv16(bool native, uint16_t n)
 {
         if (native)
@@ -42 +43 @@
 }
 
-uint32_t conv32(bool native, uint32_t n)
+uint32_t
+conv32(bool native, uint32_t n)
 {
         if (native)
@@ -50 +52 @@
 }
 
-uint64_t conv64(bool native, uint64_t n)
+uint64_t
+conv64(bool native, uint64_t n)
 {
         if (native)