Changeset 3958e315 in mainline for uspace/srv

Timestamp:

2011-10-15T12:31:30Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

e3f7418

Parents:

03f4acf (diff), df3caec5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge from lp:mfs.

Location:

uspace/srv/fs/mfs

Files:

• mfs.c (modified) (1 diff)
• mfs_balloc.c (modified) (8 diffs)
• mfs_dentry.c (modified) (9 diffs)
• mfs_inode.c (modified) (12 diffs)
• mfs_ops.c (modified) (49 diffs)
• mfs_rw.c (modified) (13 diffs)
• mfs_utils.c (modified) (3 diffs)

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)