Index: uspace/srv/fs/ext4fs/ext4fs_ops.c
===================================================================
--- uspace/srv/fs/ext4fs/ext4fs_ops.c	(revision 73196d2ca1a19338ec43803b9692091edf70cd79)
+++ uspace/srv/fs/ext4fs/ext4fs_ops.c	(revision 5614c7f6561afd2055f18837ce0e83b7dd23363e)
@@ -169,6 +169,4 @@
 int ext4fs_instance_get(service_id_t service_id, ext4fs_instance_t **inst)
 {
-	ext4fs_instance_t *tmp;
-
 	fibril_mutex_lock(&instance_list_mutex);
 
@@ -178,4 +176,5 @@
 	}
 
+	ext4fs_instance_t *tmp;
 	list_foreach(instance_list, link) {
 		tmp = list_get_instance(link, ext4fs_instance_t, link);
@@ -201,10 +200,8 @@
 int ext4fs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
 {
+	int rc;
+
 	ext4fs_node_t *eparent = EXT4FS_NODE(pfn);
-	ext4_filesystem_t *fs;
-	ext4_directory_iterator_t it;
-	int rc;
-
-	fs = eparent->instance->filesystem;
+	ext4_filesystem_t *fs = eparent->instance->filesystem;
 
 	if (!ext4_inode_is_type(fs->superblock, eparent->inode_ref->inode,
@@ -213,4 +210,5 @@
 	}
 
+	ext4_directory_iterator_t it;
 	rc = ext4_directory_iterator_init(&it, fs, eparent->inode_ref, 0);
 	if (rc != EOK) {
@@ -239,7 +237,7 @@
 int ext4fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
 {
-	ext4fs_instance_t *inst = NULL;
-	int rc;
-
+	int rc;
+
+	ext4fs_instance_t *inst;
 	rc = ext4fs_instance_get(service_id, &inst);
 	if (rc != EOK) {
@@ -255,8 +253,4 @@
 {
 	int rc;
-	fs_node_t *node = NULL;
-	ext4fs_node_t *enode = NULL;
-
-	ext4_inode_ref_t *inode_ref = NULL;
 
 	fibril_mutex_lock(&open_nodes_lock);
@@ -267,6 +261,7 @@
 		[OPEN_NODES_INODE_KEY] = index,
 	};
+
 	link_t *already_open = hash_table_find(&open_nodes, key);
-
+	ext4fs_node_t *enode = NULL;
 	if (already_open) {
 		enode = hash_table_get_instance(already_open, ext4fs_node_t, link);
@@ -284,16 +279,17 @@
 	}
 
-	node = malloc(sizeof(fs_node_t));
-	if (node == NULL) {
+	fs_node_t *fs_node = malloc(sizeof(fs_node_t));
+	if (fs_node == NULL) {
 		free(enode);
 		fibril_mutex_unlock(&open_nodes_lock);
 		return ENOMEM;
 	}
-	fs_node_initialize(node);
-
+	fs_node_initialize(fs_node);
+
+	ext4_inode_ref_t *inode_ref;
 	rc = ext4_filesystem_get_inode_ref(inst->filesystem, index, &inode_ref);
 	if (rc != EOK) {
 		free(enode);
-		free(node);
+		free(fs_node);
 		fibril_mutex_unlock(&open_nodes_lock);
 		return rc;
@@ -303,9 +299,9 @@
 	enode->instance = inst;
 	enode->references = 1;
-	enode->fs_node = node;
+	enode->fs_node = fs_node;
 	link_initialize(&enode->link);
 
-	node->data = enode;
-	*rfn = node;
+	fs_node->data = enode;
+	*rfn = fs_node;
 
 	hash_table_insert(&open_nodes, key, &enode->link);
@@ -351,8 +347,8 @@
 {
 	int rc;
+
+	fibril_mutex_lock(&open_nodes_lock);
+
 	ext4fs_node_t *enode = EXT4FS_NODE(fn);
-
-	fibril_mutex_lock(&open_nodes_lock);
-
 	assert(enode->references > 0);
 	enode->references--;
@@ -412,5 +408,4 @@
 	}
 
-
 	// TODO set real deletion time
 //	time_t now = time(NULL);
@@ -511,12 +506,8 @@
 int ext4fs_has_children(bool *has_children, fs_node_t *fn)
 {
+	int rc;
+
 	ext4fs_node_t *enode = EXT4FS_NODE(fn);
-	ext4_directory_iterator_t it;
-	ext4_filesystem_t *fs;
-	int rc;
-	bool found = false;
-	size_t name_size;
-
-	fs = enode->instance->filesystem;
+	ext4_filesystem_t *fs = enode->instance->filesystem;
 
 	if (!ext4_inode_is_type(fs->superblock, enode->inode_ref->inode,
@@ -526,4 +517,5 @@
 	}
 
+	ext4_directory_iterator_t it;
 	rc = ext4_directory_iterator_init(&it, fs, enode->inode_ref, 0);
 	if (rc != EOK) {
@@ -532,7 +524,8 @@
 
 	/* Find a non-empty directory entry */
+	bool found = false;
 	while (it.current != NULL) {
 		if (it.current->inode != 0) {
-			name_size = ext4_directory_entry_ll_get_name_length(fs->superblock,
+			uint16_t name_size = ext4_directory_entry_ll_get_name_length(fs->superblock,
 				it.current);
 			if (!ext4fs_is_dots(it.current->name, name_size)) {
@@ -570,7 +563,6 @@
 {
 	ext4fs_node_t *enode = EXT4FS_NODE(fn);
-	aoff64_t size = ext4_inode_get_size(
-			enode->instance->filesystem->superblock, enode->inode_ref->inode);
-	return size;
+	ext4_superblock_t *sb = enode->instance->filesystem->superblock;
+	return ext4_inode_get_size(sb, enode->inode_ref->inode);
 }
 
@@ -597,7 +589,7 @@
 {
 	ext4fs_node_t *enode = EXT4FS_NODE(fn);
-	bool is_dir = ext4_inode_is_type(enode->instance->filesystem->superblock,
-	    enode->inode_ref->inode, EXT4_INODE_MODE_DIRECTORY);
-	return is_dir;
+	ext4_superblock_t *sb = enode->instance->filesystem->superblock;
+	return ext4_inode_is_type(
+			sb, enode->inode_ref->inode, EXT4_INODE_MODE_DIRECTORY);
 }
 
@@ -606,7 +598,7 @@
 {
 	ext4fs_node_t *enode = EXT4FS_NODE(fn);
-	bool is_file = ext4_inode_is_type(enode->instance->filesystem->superblock,
-	    enode->inode_ref->inode, EXT4_INODE_MODE_FILE);
-	return is_file;
+	ext4_superblock_t *sb = enode->instance->filesystem->superblock;
+	return ext4_inode_is_type(
+			sb, enode->inode_ref->inode, EXT4_INODE_MODE_FILE);
 }
 
@@ -649,9 +641,7 @@
 {
 	int rc;
+
+	/* Allocate libext4 filesystem structure */
 	ext4_filesystem_t *fs;
-	ext4fs_instance_t *inst;
-	bool read_only;
-
-	/* Allocate libext4 filesystem structure */
 	fs = (ext4_filesystem_t *) malloc(sizeof(ext4_filesystem_t));
 	if (fs == NULL) {
@@ -660,4 +650,5 @@
 
 	/* Allocate instance structure */
+	ext4fs_instance_t *inst;
 	inst = (ext4fs_instance_t *) malloc(sizeof(ext4fs_instance_t));
 	if (inst == NULL) {
@@ -684,4 +675,5 @@
 
 	/* Check flags */
+	bool read_only;
 	rc = ext4_filesystem_check_features(fs, &read_only);
 	if (rc != EOK) {
@@ -726,8 +718,7 @@
 {
 	int rc;
+
 	ext4fs_instance_t *inst;
-
 	rc = ext4fs_instance_get(service_id, &inst);
-
 	if (rc != EOK) {
 		return rc;
@@ -755,6 +746,4 @@
 		aoff64_t pos, size_t *rbytes)
 {
-	ext4fs_instance_t *inst;
-	ext4_inode_ref_t *inode_ref;
 	int rc;
 
@@ -769,4 +758,5 @@
 	}
 
+	ext4fs_instance_t *inst;
 	rc = ext4fs_instance_get(service_id, &inst);
 	if (rc != EOK) {
@@ -775,4 +765,5 @@
 	}
 
+	ext4_inode_ref_t *inode_ref;
 	rc = ext4_filesystem_get_inode_ref(inst->filesystem, index, &inode_ref);
 	if (rc != EOK) {
@@ -816,11 +807,7 @@
     ext4fs_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
 {
+	int rc;
+
 	ext4_directory_iterator_t it;
-	aoff64_t next;
-	uint8_t *buf;
-	size_t name_size;
-	int rc;
-	bool found = false;
-
 	rc = ext4_directory_iterator_init(&it, inst->filesystem, inode_ref, pos);
 	if (rc != EOK) {
@@ -833,4 +820,5 @@
 	 * as these are not used in HelenOS
 	 */
+	bool found = false;
 	while (it.current != NULL) {
 
@@ -839,5 +827,5 @@
 		}
 
-		name_size = ext4_directory_entry_ll_get_name_length(
+		uint16_t name_size = ext4_directory_entry_ll_get_name_length(
 		    inst->filesystem->superblock, it.current);
 
@@ -851,5 +839,5 @@
 		 * and add the \0 at the end
 		 */
-		buf = malloc(name_size+1);
+		uint8_t *buf = malloc(name_size+1);
 		if (buf == NULL) {
 			ext4_directory_iterator_fini(&it);
@@ -873,4 +861,5 @@
 	}
 
+	uint64_t next;
 	if (found) {
 		rc = ext4_directory_iterator_next(&it);
@@ -899,15 +888,7 @@
 {
 	int rc;
-	uint32_t block_size;
-	aoff64_t file_block;
-	uint64_t file_size;
-	uint32_t fs_block;
-	size_t offset_in_block;
-	size_t bytes;
-	block_t *block;
-	uint8_t *buffer;
-
-	file_size = ext4_inode_get_size(inst->filesystem->superblock,
-		inode_ref->inode);
+
+	ext4_superblock_t *sb = inst->filesystem->superblock;
+	uint64_t file_size = ext4_inode_get_size(sb, inode_ref->inode);
 
 	if (pos >= file_size) {
@@ -919,8 +900,8 @@
 
 	/* For now, we only read data from one block at a time */
-	block_size = ext4_superblock_get_block_size(inst->filesystem->superblock);
-	file_block = pos / block_size;
-	offset_in_block = pos % block_size;
-	bytes = min(block_size - offset_in_block, size);
+	uint32_t block_size = ext4_superblock_get_block_size(sb);
+	aoff64_t file_block = pos / block_size;
+	uint32_t offset_in_block = pos % block_size;
+	uint32_t bytes = min(block_size - offset_in_block, size);
 
 	/* Handle end of file */
@@ -930,4 +911,5 @@
 
 	/* Get the real block number */
+	uint32_t fs_block;
 	rc = ext4_filesystem_get_inode_data_block_index(inst->filesystem,
 		inode_ref->inode, file_block, &fs_block);
@@ -942,4 +924,5 @@
 	 * file and we need to return a buffer of zeros
 	 */
+	uint8_t *buffer;
 	if (fs_block == 0) {
 		buffer = malloc(bytes);
@@ -960,4 +943,5 @@
 
 	/* Usual case - we need to read a block from device */
+	block_t *block;
 	rc = block_get(&block, inst->service_id, fs_block, BLOCK_FLAGS_NONE);
 	if (rc != EOK) {
@@ -982,21 +966,14 @@
 {
 	int rc;
-	int flags = BLOCK_FLAGS_NONE;
+
 	fs_node_t *fn;
-	ext4fs_node_t *enode;
-	ext4_filesystem_t *fs;
-	ext4_inode_ref_t *inode_ref;
+	rc = ext4fs_node_get(&fn, service_id, index);
+	if (rc != EOK) {
+		EXT4FS_DBG("node get error");
+		return rc;
+	}
+
 	ipc_callid_t callid;
-	size_t len, bytes, block_size;
-	block_t *write_block;
-	uint32_t fblock, iblock;
-	uint32_t old_inode_size;
-
-	rc = ext4fs_node_get(&fn, service_id, index);
-	if (rc != EOK) {
-		EXT4FS_DBG("node get error");
-		return rc;
-	}
-
+	size_t len;
 	if (!async_data_write_receive(&callid, &len)) {
 		rc = EINVAL;
@@ -1008,19 +985,21 @@
 
 
-	enode = EXT4FS_NODE(fn);
-	inode_ref = enode->inode_ref;
-	fs = enode->instance->filesystem;
-
-	block_size = ext4_superblock_get_block_size(fs->superblock);
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
+	ext4_filesystem_t *fs = enode->instance->filesystem;
+
+	uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
 
 	// Prevent writing to more than one block
-	bytes = min(len, block_size - (pos % block_size));
-
+	uint32_t bytes = min(len, block_size - (pos % block_size));
+
+	int flags = BLOCK_FLAGS_NONE;
 	if (bytes == block_size) {
 		flags = BLOCK_FLAGS_NOREAD;
 	}
 
-	iblock =  pos / block_size;
-
+	uint32_t iblock =  pos / block_size;
+	uint32_t fblock;
+
+	ext4_inode_ref_t *inode_ref = enode->inode_ref;
 	rc = ext4_filesystem_get_inode_data_block_index(fs, inode_ref->inode, iblock, &fblock);
 	if (rc != EOK) {
@@ -1048,4 +1027,5 @@
 	}
 
+	block_t *write_block;
 	rc = block_get(&write_block, service_id, fblock, flags);
 	if (rc != EOK) {
@@ -1075,5 +1055,5 @@
 	}
 
-	old_inode_size = ext4_inode_get_size(fs->superblock, inode_ref->inode);
+	uint32_t old_inode_size = ext4_inode_get_size(fs->superblock, inode_ref->inode);
 	if (pos + bytes > old_inode_size) {
 		ext4_inode_set_size(inode_ref->inode, pos + bytes);
@@ -1092,6 +1072,6 @@
 {
 	int rc;
+
 	fs_node_t *fn;
-
 	rc = ext4fs_node_get(&fn, service_id, index);
 	if (rc != EOK) {
@@ -1119,6 +1099,6 @@
 {
 	int rc;
+
 	fs_node_t *fn;
-
 	rc = ext4fs_node_get(&fn, service_id, index);
 	if (rc != EOK) {
@@ -1134,7 +1114,6 @@
 {
 	int rc;
+
 	fs_node_t *fn;
-	ext4fs_node_t *enode;
-
 	rc = ext4fs_node_get(&fn, service_id, index);
 	if (rc != EOK) {
@@ -1142,5 +1121,5 @@
 	}
 
-	enode = EXT4FS_NODE(fn);
+	ext4fs_node_t *enode = EXT4FS_NODE(fn);
 	enode->inode_ref->dirty = true;