Index: uspace/srv/fs/minixfs/mfs.c
===================================================================
--- uspace/srv/fs/minixfs/mfs.c	(revision 8a49fed9a95067b90465e853600fc1a0f5dba7dd)
+++ uspace/srv/fs/minixfs/mfs.c	(revision 44c6091f62382c2177a14b25e0c5434994db2b82)
@@ -52,5 +52,5 @@
 	.name = NAME,
 	.concurrent_read_write = false,
-	.write_retains_size = false,	
+	.write_retains_size = false,
 };
 
@@ -70,5 +70,5 @@
  * phone for more serialized requests. Similarily, MinixFS can refuse to duplicate
  * the connection. VFS should then just make use of already existing phones and
- * route its requests through them. To avoid paying the fibril creation price 
+ * route its requests through them. To avoid paying the fibril creation price
  * upon each request, MinixFS might want to keep the connections open after the
  * request has been completed.
@@ -85,10 +85,10 @@
 		async_answer_0(iid, EOK);
 	}
-	
+
 	printf(NAME ": connection opened\n");
 	while (1) {
 		ipc_callid_t callid;
 		ipc_call_t call;
-	
+
 		callid = async_get_call(&call);
 		int method = IPC_GET_IMETHOD(call);
@@ -150,5 +150,5 @@
 	if (rc != EOK)
 		goto err;
-	
+
 	printf(NAME ": Accepting connections\n");
 	task_retval(0);
@@ -164,4 +164,4 @@
 /**
  * @}
- */ 
+ */
 
Index: uspace/srv/fs/minixfs/mfs_balloc.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_balloc.c	(revision 8a49fed9a95067b90465e853600fc1a0f5dba7dd)
+++ uspace/srv/fs/minixfs/mfs_balloc.c	(revision 44c6091f62382c2177a14b25e0c5434994db2b82)
@@ -37,5 +37,5 @@
 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
@@ -55,5 +55,5 @@
 		if (idx > sbi->nzones) {
 			printf(NAME ": Error! Trying to free beyond the" \
-					"bitmap max size\n");
+			       "bitmap max size\n");
 			return -1;
 		}
@@ -63,5 +63,5 @@
 		if (idx > sbi->ninodes) {
 			printf(NAME ": Error! Trying to free beyond the" \
-					"bitmap max size\n");
+			       "bitmap max size\n");
 			return -1;
 		}
@@ -124,5 +124,5 @@
 	for (i = *search / bits_per_block; i < nblocks; ++i) {
 		r = block_get(&b, inst->handle, i + start_block,
-				BLOCK_FLAGS_NONE);
+			      BLOCK_FLAGS_NONE);
 
 		on_error(r, goto out);
@@ -168,5 +168,5 @@
 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;
@@ -176,5 +176,5 @@
 
 	for (i = start_bit / sizeof(uint32_t);
-				i < bsize / sizeof(uint32_t); ++i) {
+	     i < bsize / sizeof(uint32_t); ++i) {
 		if (!(~b[i])) {
 			/*No free bit in this chunk*/
@@ -200,4 +200,4 @@
 /**
  * @}
- */ 
-
+ */
+
Index: uspace/srv/fs/minixfs/mfs_dentry.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_dentry.c	(revision 8a49fed9a95067b90465e853600fc1a0f5dba7dd)
+++ uspace/srv/fs/minixfs/mfs_dentry.c	(revision 44c6091f62382c2177a14b25e0c5434994db2b82)
@@ -36,5 +36,5 @@
 int
 read_directory_entry(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;
@@ -76,10 +76,10 @@
 	} 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);
@@ -202,4 +202,4 @@
 /**
  * @}
- */ 
-
+ */
+
Index: uspace/srv/fs/minixfs/mfs_inode.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_inode.c	(revision 8a49fed9a95067b90465e853600fc1a0f5dba7dd)
+++ uspace/srv/fs/minixfs/mfs_inode.c	(revision 44c6091f62382c2177a14b25e0c5434994db2b82)
@@ -50,5 +50,5 @@
 int
 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;
@@ -69,6 +69,5 @@
 
 static struct mfs_ino_info *
-mfs_read_inode_raw(const struct mfs_instance *instance, uint16_t inum)
-{
+mfs_read_inode_raw(const struct mfs_instance *instance, uint16_t inum) {
 	struct mfs_inode *ino = NULL;
 	struct mfs_ino_info *ino_i = NULL;
@@ -95,6 +94,6 @@
 
 	if (block_get(&b, instance->handle,
-			itable_off + inum / sbi->ino_per_block,
-			BLOCK_FLAGS_NONE) != EOK)
+		      itable_off + inum / sbi->ino_per_block,
+		      BLOCK_FLAGS_NONE) != EOK)
 		goto out_err;
 
@@ -128,6 +127,5 @@
 
 static struct mfs_ino_info *
-mfs2_read_inode_raw(const struct mfs_instance *instance, uint32_t inum)
-{
+mfs2_read_inode_raw(const struct mfs_instance *instance, uint32_t inum) {
 	struct mfs2_inode *ino = NULL;
 	struct mfs_ino_info *ino_i = NULL;
@@ -153,7 +151,7 @@
 	const int ino_off = inum % sbi->ino_per_block;
 
-	if (block_get(&b, instance->handle, 
-		itable_off + inum / sbi->ino_per_block,
-			BLOCK_FLAGS_NONE) != EOK)
+	if (block_get(&b, instance->handle,
+		      itable_off + inum / sbi->ino_per_block,
+		      BLOCK_FLAGS_NONE) != EOK)
 		goto out_err;
 
@@ -228,6 +226,6 @@
 
 	r = block_get(&b, mnode->instance->handle,
-				itable_off + inum / sbi->ino_per_block,
-				BLOCK_FLAGS_NONE);
+		      itable_off + inum / sbi->ino_per_block,
+		      BLOCK_FLAGS_NONE);
 
 	on_error(r, goto out);
@@ -268,8 +266,8 @@
 	const int ino_off = inum % sbi->ino_per_block;
 	const bool native = sbi->native;
-	
+
 	r = block_get(&b, mnode->instance->handle,
-				itable_off + inum / sbi->ino_per_block,
-				BLOCK_FLAGS_NONE);
+		      itable_off + inum / sbi->ino_per_block,
+		      BLOCK_FLAGS_NONE);
 
 	on_error(r, goto out);
@@ -282,5 +280,5 @@
 	ino2->i_uid = conv16(native, ino_i->i_uid);
 	ino2->i_gid = conv16(native, ino_i->i_gid);
-	ino2->i_size = conv32(native, ino_i->i_size);	
+	ino2->i_size = conv32(native, ino_i->i_size);
 	ino2->i_atime = conv32(native, ino_i->i_atime);
 	ino2->i_mtime = conv32(native, ino_i->i_mtime);
@@ -389,5 +387,5 @@
 		block_t *b;
 		r = block_get(&b, mnode->instance->handle, new_zone,
-						BLOCK_FLAGS_NOREAD);
+			      BLOCK_FLAGS_NOREAD);
 		on_error(r, return r);
 
@@ -397,5 +395,5 @@
 
 		r = write_map(mnode, (start_zone + i) * bs,
-				new_zone, &dummy);
+			      new_zone, &dummy);
 
 		on_error(r, return r);
@@ -413,4 +411,4 @@
 /**
  * @}
- */ 
-
+ */
+
Index: uspace/srv/fs/minixfs/mfs_ops.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_ops.c	(revision 8a49fed9a95067b90465e853600fc1a0f5dba7dd)
+++ uspace/srv/fs/minixfs/mfs_ops.c	(revision 44c6091f62382c2177a14b25e0c5434994db2b82)
@@ -38,7 +38,7 @@
 
 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);
@@ -85,5 +85,5 @@
 {
 	devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
-	enum cache_mode cmode;	
+	enum cache_mode cmode;
 	struct mfs_superblock *sb;
 	struct mfs3_superblock *sb3;
@@ -97,5 +97,5 @@
 	char *opts;
 	int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
-	
+
 	if (rc != EOK) {
 		mfsdebug("Can't accept async data write\n");
@@ -212,8 +212,8 @@
 		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;
 	}
 	sbi->itable_off = 2 + sbi->ibmap_blocks + sbi->zbmap_blocks;
- 
+
 	free(sb);
 
@@ -259,5 +259,5 @@
 	fs_node_t *fsnode;
 	uint32_t inum;
-	
+
 	mfsdebug("create_node()\n");
 
@@ -287,5 +287,5 @@
 		goto out_err_1;
 	}
-	
+
 	fsnode = malloc(sizeof(fs_node_t));
 	if (!fsnode) {
@@ -365,5 +365,5 @@
 			/*Hit!*/
 			mfs_node_core_get(rfn, mnode->instance,
-				d_info->d_inum);
+					  d_info->d_inum);
 			free(d_info);
 			goto found;
@@ -445,5 +445,5 @@
 
 static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
-			fs_index_t index)
+			     fs_index_t index)
 {
 	fs_node_t *node = NULL;
@@ -546,5 +546,5 @@
 
 	struct mfs_dentry_info *d_info;
-	
+
 	/* The first two dentries are always . and .. */
 	int i = 2;
@@ -586,5 +586,5 @@
 	fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
 	aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
-				IPC_GET_ARG4(*request));
+					       IPC_GET_ARG4(*request));
 	fs_node_t *fn;
 
@@ -643,5 +643,5 @@
 found:
 		async_data_read_finalize(callid, d_info->d_name,
-				str_size(d_info->d_name) + 1);
+					 str_size(d_info->d_name) + 1);
 		bytes = ((pos - spos) + 1);
 	} else {
@@ -673,5 +673,5 @@
 			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;
@@ -682,5 +682,5 @@
 
 		async_data_read_finalize(callid, b->data +
-				pos % sbi->block_size, bytes);
+					 pos % sbi->block_size, bytes);
 
 		rc = block_put(b);
@@ -695,5 +695,6 @@
 	async_answer_1(rid, rc, (sysarg_t)bytes);
 	return;
-out_error: ;
+out_error:
+	;
 	int tmp = mfs_node_put(fn);
 	async_answer_0(callid, tmp != EOK ? tmp : rc);
@@ -709,5 +710,5 @@
 	fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
 	aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
-						IPC_GET_ARG4(*request));
+					       IPC_GET_ARG4(*request));
 
 	fs_node_t *fn;
@@ -835,6 +836,6 @@
 	for (link = inst_list.next; link != &inst_list; link = link->next) {
 		instance_ptr = list_get_instance(link, struct mfs_instance,
-				link);
-		
+						 link);
+
 		if (instance_ptr->handle == handle) {
 			*instance = instance_ptr;
@@ -851,5 +852,5 @@
 
 static bool check_magic_number(uint16_t magic, bool *native,
-				mfs_version_t *version, bool *longfilenames)
+			       mfs_version_t *version, bool *longfilenames)
 {
 	bool rc = true;
@@ -893,4 +894,4 @@
 /**
  * @}
- */ 
-
+ */
+
Index: uspace/srv/fs/minixfs/mfs_rw.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_rw.c	(revision 8a49fed9a95067b90465e853600fc1a0f5dba7dd)
+++ uspace/srv/fs/minixfs/mfs_rw.c	(revision 44c6091f62382c2177a14b25e0c5434994db2b82)
@@ -36,5 +36,5 @@
 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
@@ -79,6 +79,6 @@
 
 int
-write_map(struct mfs_node *mnode, const uint32_t pos, uint32_t new_zone, 
-				uint32_t *old_zone)
+write_map(struct mfs_node *mnode, const uint32_t pos, uint32_t new_zone,
+	  uint32_t *old_zone)
 {
 	const struct mfs_sb_info *sbi = mnode->instance->sbi;
@@ -108,5 +108,5 @@
 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;
@@ -276,5 +276,5 @@
 	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);
@@ -301,5 +301,5 @@
 
 	block_put(b);
-	
+
 	return EOK;
 }
@@ -337,4 +337,4 @@
 /**
  * @}
- */ 
-
+ */
+
Index: uspace/srv/fs/minixfs/mfs_utils.c
===================================================================
--- uspace/srv/fs/minixfs/mfs_utils.c	(revision 8a49fed9a95067b90465e853600fc1a0f5dba7dd)
+++ uspace/srv/fs/minixfs/mfs_utils.c	(revision 44c6091f62382c2177a14b25e0c5434994db2b82)
@@ -61,4 +61,4 @@
 /**
  * @}
- */ 
+ */
 
Index: uspace/srv/fs/minixfs/mfs_utils.h
===================================================================
--- uspace/srv/fs/minixfs/mfs_utils.h	(revision 8a49fed9a95067b90465e853600fc1a0f5dba7dd)
+++ uspace/srv/fs/minixfs/mfs_utils.h	(revision 44c6091f62382c2177a14b25e0c5434994db2b82)
@@ -51,4 +51,4 @@
 /**
  * @}
- */ 
+ */