Index: uspace/lib/ext4/libext4_filesystem.c
===================================================================
--- uspace/lib/ext4/libext4_filesystem.c	(revision 840e227e23022d5e168d594dff6b207772e7ec31)
+++ uspace/lib/ext4/libext4_filesystem.c	(revision 06d85e53f2ba96bd2ea9eae7bc274870ba1e1a85)
@@ -53,5 +53,5 @@
 	fs->device = service_id;
 
-	// Initialize block library (4096 is size of communication channel)
+	/* Initialize block library (4096 is size of communication channel) */
 	rc = block_init(EXCHANGE_SERIALIZE, fs->device, 4096);
 	if (rc != EOK) {
@@ -60,5 +60,5 @@
 	}
 
-	// Read superblock from device to memory
+	/* Read superblock from device to memory */
 	ext4_superblock_t *temp_superblock;
 	rc = ext4_superblock_read_direct(fs->device, &temp_superblock);
@@ -69,5 +69,5 @@
 	}
 
-	// Read block size from superblock and check
+	/* Read block size from superblock and check */
 	uint32_t block_size = ext4_superblock_get_block_size(temp_superblock);
 	if (block_size > EXT4_MAX_BLOCK_SIZE) {
@@ -77,5 +77,5 @@
 	}
 
-	// Initialize block caching by libblock
+	/* Initialize block caching by libblock */
 	rc = block_cache_init(service_id, block_size, 0, CACHE_MODE_WT);
 	if (rc != EOK) {
@@ -85,5 +85,5 @@
 	}
 
-	// Compute limits for indirect block levels
+	/* Compute limits for indirect block levels */
 	uint32_t block_ids_per_block = block_size / sizeof(uint32_t);
 	fs->inode_block_limits[0] = EXT4_INODE_DIRECT_BLOCK_COUNT;
@@ -96,5 +96,5 @@
 	}
 
-	// Return loaded superblock
+	/* Return loaded superblock */
 	fs->superblock = temp_superblock;
 
@@ -108,5 +108,5 @@
 	}
 
-	// Mark system as mounted
+	/* Mark system as mounted */
 	ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_ERROR_FS);
 	rc = ext4_superblock_write_direct(fs->device, fs->superblock);
@@ -131,12 +131,12 @@
 	int rc = EOK;
 
-	// Write the superblock to the device
+	/* Write the superblock to the device */
 	ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_VALID_FS);
 	rc = ext4_superblock_write_direct(fs->device, fs->superblock);
 
-	// Release memory space for superblock
+	/* Release memory space for superblock */
 	free(fs->superblock);
 
-	// Finish work with block library
+	/* Finish work with block library */
 	block_fini(fs->device);
 
@@ -155,5 +155,5 @@
 	int rc;
 
-	// Check superblock
+	/* Check superblock */
 	rc = ext4_superblock_check_sanity(fs->superblock);
 	if (rc != EOK) {
@@ -176,5 +176,5 @@
 int ext4_filesystem_check_features(ext4_filesystem_t *fs, bool *read_only)
 {
-	// Feature flags are present only in higher revisions
+	/* Feature flags are present only in higher revisions */
 	if (ext4_superblock_get_rev_level(fs->superblock) == 0) {
 		*read_only = false;
@@ -182,6 +182,7 @@
 	}
 
-	// Check incompatible features - if filesystem has some,
-	// volume can't be mounted
+	/* Check incompatible features - if filesystem has some,
+	 * volume can't be mounted
+	 */
 	uint32_t incompatible_features;
 	incompatible_features = ext4_superblock_get_features_incompatible(fs->superblock);
@@ -191,6 +192,7 @@
 	}
 
-	// Check read-only features, if filesystem has some,
-	// volume can be mount only in read-only mode
+	/* Check read-only features, if filesystem has some,
+	 * volume can be mount only in read-only mode
+	 */
 	uint32_t compatible_read_only;
 	compatible_read_only = ext4_superblock_get_features_read_only(fs->superblock);
@@ -216,5 +218,5 @@
 	int rc;
 
-	// Allocate memory for new structure
+	/* Allocate memory for new structure */
 	ext4_block_group_ref_t *newref = malloc(sizeof(ext4_block_group_ref_t));
 	if (newref == NULL) {
@@ -222,16 +224,16 @@
 	}
 
-	// Compute number of descriptors, that fits in one data block
+	/* Compute number of descriptors, that fits in one data block */
 	uint32_t descriptors_per_block = ext4_superblock_get_block_size(fs->superblock)
 	    / ext4_superblock_get_desc_size(fs->superblock);
 
-	// Block group descriptor table starts at the next block after superblock
+	/* Block group descriptor table starts at the next block after superblock */
 	aoff64_t block_id = ext4_superblock_get_first_data_block(fs->superblock) + 1;
 
-	// Find the block containing the descriptor we are looking for
+	/* Find the block containing the descriptor we are looking for */
 	block_id += bgid / descriptors_per_block;
 	uint32_t offset = (bgid % descriptors_per_block) * ext4_superblock_get_desc_size(fs->superblock);
 
-	// Load block with descriptors
+	/* Load block with descriptors */
 	rc = block_get(&newref->block, fs->device, block_id, 0);
 	if (rc != EOK) {
@@ -240,5 +242,5 @@
 	}
 
-	// Inititialize in-memory representation
+	/* Inititialize in-memory representation */
 	newref->block_group = newref->block->data + offset;
 	newref->fs = fs;
@@ -263,8 +265,8 @@
                             ext4_block_group_t *bg)
 {
-	// If checksum not supported, 0 will be returned
+	/* If checksum not supported, 0 will be returned */
 	uint16_t crc = 0;
 
-	// Compute the checksum only if the filesystem supports it
+	/* Compute the checksum only if the filesystem supports it */
 	if (ext4_superblock_has_feature_read_only(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
 
@@ -274,20 +276,20 @@
 		uint32_t offset = (uint32_t)(checksum - base);
 
-		// Convert block group index to little endian
+		/* Convert block group index to little endian */
 		uint32_t le_group = host2uint32_t_le(bgid);
 
-		// Initialization
+		/* Initialization */
 		crc = crc16(~0, sb->uuid, sizeof(sb->uuid));
 
-		// Include index of block group
+		/* Include index of block group */
 		crc = crc16(crc, (uint8_t *)&le_group, sizeof(le_group));
 
-		// Compute crc from the first part (stop before checksum field)
+		/* Compute crc from the first part (stop before checksum field) */
 		crc = crc16(crc, (uint8_t *)bg, offset);
 
-		// Skip checksum
+		/* Skip checksum */
 		offset += sizeof(bg->checksum);
 
-		// Checksum of the rest of block group descriptor
+		/* Checksum of the rest of block group descriptor */
 		if ((ext4_superblock_has_feature_incompatible(sb, EXT4_FEATURE_INCOMPAT_64BIT)) &&
 			offset < ext4_superblock_get_desc_size(sb)) {
@@ -310,17 +312,17 @@
 	int rc;
 
-	// Check if reference modified
+	/* Check if reference modified */
 	if (ref->dirty) {
 
-		// Compute new checksum of block group
+		/* Compute new checksum of block group */
 		uint16_t checksum = ext4_filesystem_bg_checksum(
 				ref->fs->superblock, ref->index, ref->block_group);
 		ext4_block_group_set_checksum(ref->block_group, checksum);
 
-		// Mark block dirty for writing changes to physical device
+		/* Mark block dirty for writing changes to physical device */
 		ref->block->dirty = true;
 	}
 
-	// Put back block, that contains block group descriptor
+	/* Put back block, that contains block group descriptor */
 	rc = block_put(ref->block);
 	free(ref);
@@ -341,5 +343,5 @@
 	int rc;
 
-	// Allocate memory for new structure
+	/* Allocate memory for new structure */
 	ext4_inode_ref_t *newref = malloc(sizeof(ext4_inode_ref_t));
 	if (newref == NULL) {
@@ -347,10 +349,9 @@
 	}
 
-	// Compute number of i-nodes, that fits in one data block
+	/* Compute number of i-nodes, that fits in one data block */
 	uint32_t inodes_per_group =
 			ext4_superblock_get_inodes_per_group(fs->superblock);
 
-	/*
-	 * inode numbers are 1-based, but it is simpler to work with 0-based
+	/* Inode numbers are 1-based, but it is simpler to work with 0-based
 	 * when computing indices
 	 */
@@ -359,5 +360,5 @@
 	uint32_t offset_in_group = index % inodes_per_group;
 
-	// Load block group, where i-node is located
+	/* Load block group, where i-node is located */
 	ext4_block_group_ref_t *bg_ref;
 	rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
@@ -367,9 +368,9 @@
 	}
 
-	// Load block address, where i-node table is located
+	/* Load block address, where i-node table is located */
 	uint32_t inode_table_start = ext4_block_group_get_inode_table_first_block(
 	    bg_ref->block_group, fs->superblock);
 
-	// Put back block group reference (not needed more)
+	/* Put back block group reference (not needed more) */
 	rc = ext4_filesystem_put_block_group_ref(bg_ref);
 	if (rc != EOK) {
@@ -378,10 +379,10 @@
 	}
 
-	// Compute position of i-node in the block group
+	/* Compute position of i-node in the block group */
 	uint16_t inode_size = ext4_superblock_get_inode_size(fs->superblock);
 	uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
 	uint32_t byte_offset_in_group = offset_in_group * inode_size;
 
-	// Compute block address
+	/* Compute block address */
 	aoff64_t block_id = inode_table_start + (byte_offset_in_group / block_size);
 	rc = block_get(&newref->block, fs->device, block_id, 0);
@@ -391,9 +392,9 @@
 	}
 
-	// Compute position of i-node in the data block
+	/* Compute position of i-node in the data block */
 	uint32_t offset_in_block = byte_offset_in_group % block_size;
 	newref->inode = newref->block->data + offset_in_block;
 
-	// We need to store the original value of index in the reference
+	/* We need to store the original value of index in the reference */
 	newref->index = index + 1;
 	newref->fs = fs;
@@ -414,12 +415,12 @@
 	int rc;
 
-	// Check if reference modified
+	/* Check if reference modified */
 	if (ref->dirty) {
 
-		// Mark block dirty for writing changes to physical device
+		/* Mark block dirty for writing changes to physical device */
 		ref->block->dirty = true;
 	}
 
-	// Put back block, that contains i-node
+	/* Put back block, that contains i-node */
 	rc = block_put(ref->block);
 	free(ref);
@@ -440,5 +441,5 @@
 	int rc;
 
-	// Check if newly allocated i-node will be a directory
+	/* Check if newly allocated i-node will be a directory */
 	bool is_dir = false;
 	if (flags & L_DIRECTORY) {
@@ -446,5 +447,5 @@
 	}
 
-	// Allocate inode by allocation algorithm
+	/* Allocate inode by allocation algorithm */
 	uint32_t index;
 	rc = ext4_ialloc_alloc_inode(fs, &index, is_dir);
@@ -453,5 +454,5 @@
 	}
 
-	// Load i-node from on-disk i-node table
+	/* Load i-node from on-disk i-node table */
 	rc = ext4_filesystem_get_inode_ref(fs, index, inode_ref);
 	if (rc != EOK) {
@@ -460,10 +461,10 @@
 	}
 
-	// Initialize i-node
+	/* Initialize i-node */
 	ext4_inode_t *inode = (*inode_ref)->inode;
 
 	if (is_dir) {
 		ext4_inode_set_mode(fs->superblock, inode, EXT4_INODE_MODE_DIRECTORY);
-		ext4_inode_set_links_count(inode, 1); // '.' entry
+		ext4_inode_set_links_count(inode, 1); /* '.' entry */
 	} else {
 		ext4_inode_set_mode(fs->superblock, inode, EXT4_INODE_MODE_FILE);
@@ -482,10 +483,10 @@
 	ext4_inode_set_generation(inode, 0);
 
-	// Reset blocks array
+	/* Reset blocks array */
 	for (uint32_t i = 0; i < EXT4_INODE_BLOCKS; i++) {
 		inode->blocks[i] = 0;
 	}
 
-	// Initialize extents if needed
+	/* Initialize extents if needed */
 	if (ext4_superblock_has_feature_incompatible(
 			fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS)) {
@@ -493,5 +494,5 @@
 		ext4_inode_set_flag(inode, EXT4_INODE_FLAG_EXTENTS);
 
-		// Initialize extent root header
+		/* Initialize extent root header */
 		ext4_extent_header_t *header = ext4_inode_get_extent_header(inode);
 		ext4_extent_header_set_depth(header, 0);
@@ -522,16 +523,16 @@
 	ext4_filesystem_t *fs = inode_ref->fs;
 
-	// For extents must be data block destroyed by other way
+	/* For extents must be data block destroyed by other way */
 	if (ext4_superblock_has_feature_incompatible(
 			fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS) &&
 				ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS)) {
 
-		// Data structures are released during truncate operation...
+		/* Data structures are released during truncate operation... */
 		goto finish;
 	}
 
-	// Release all indirect (no data) blocks
-
-	// 1) Single indirect
+	/* Release all indirect (no data) blocks */
+
+	/* 1) Single indirect */
 	uint32_t fblock = ext4_inode_get_indirect_block(inode_ref->inode, 0);
 	if (fblock != 0) {
@@ -548,5 +549,5 @@
 	uint32_t count = block_size / sizeof(uint32_t);
 
-	// 2) Double indirect
+	/* 2) Double indirect */
 	fblock = ext4_inode_get_indirect_block(inode_ref->inode, 1);
 	if (fblock != 0) {
@@ -579,5 +580,5 @@
 
 
-	// 3) Tripple indirect
+	/* 3) Tripple indirect */
 	block_t *subblock;
 	fblock = ext4_inode_get_indirect_block(inode_ref->inode, 2);
@@ -637,8 +638,8 @@
 finish:
 
-	// Mark inode dirty for writing to the physical device
+	/* Mark inode dirty for writing to the physical device */
 	inode_ref->dirty = true;
 
-	// Free inode by allocator
+	/* Free inode by allocator */
 	if (ext4_inode_is_type(fs->superblock, inode_ref->inode,
 			EXT4_INODE_MODE_DIRECTORY)) {
@@ -667,10 +668,10 @@
 	ext4_superblock_t *sb = inode_ref->fs->superblock;
 
-	// Check flags, if i-node can be truncated
+	/* Check flags, if i-node can be truncated */
 	if (! ext4_inode_can_truncate(sb, inode_ref->inode)) {
 		return EINVAL;
 	}
 
-	// If sizes are equal, nothing has to be done.
+	/* If sizes are equal, nothing has to be done. */
 	aoff64_t old_size = ext4_inode_get_size(sb, inode_ref->inode);
 	if (old_size == new_size) {
@@ -678,10 +679,10 @@
 	}
 
-	// It's not suppported to make the larger file by truncate operation
+	/* It's not suppported to make the larger file by truncate operation */
 	if (old_size < new_size) {
 		return EINVAL;
 	}
 
-	// Compute how many blocks will be released
+	/* Compute how many blocks will be released */
 	aoff64_t size_diff = old_size - new_size;
 	uint32_t block_size  = ext4_superblock_get_block_size(sb);
@@ -700,5 +701,5 @@
 				ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS)) {
 
-		// Extents require special operation
+		/* Extents require special operation */
 
 		rc = ext4_extent_release_blocks_from(inode_ref,
@@ -709,7 +710,7 @@
 	} else {
 
-		// Release data blocks from the end of file
-
-		// Starting from 1 because of logical blocks are numbered from 0
+		/* Release data blocks from the end of file */
+
+		/* Starting from 1 because of logical blocks are numbered from 0 */
 		for (uint32_t i = 1; i <= diff_blocks_count; ++i) {
 			rc = ext4_filesystem_release_inode_block(inode_ref, old_blocks_count - i);
@@ -720,5 +721,5 @@
 	}
 
-	// Update i-node
+	/* Update i-node */
 	ext4_inode_set_size(inode_ref->inode, new_size);
 	inode_ref->dirty = true;
@@ -741,5 +742,5 @@
 	ext4_filesystem_t *fs = inode_ref->fs;
 
-	// For empty file is situation simple
+	/* For empty file is situation simple */
 	if (ext4_inode_get_size(fs->superblock, inode_ref->inode) == 0) {
 		*fblock = 0;
@@ -749,5 +750,5 @@
 	uint32_t current_block;
 
-	// Handle i-node using extents
+	/* Handle i-node using extents */
 	if (ext4_superblock_has_feature_incompatible(fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS) &&
 			ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS)) {
@@ -766,5 +767,5 @@
 	ext4_inode_t *inode = inode_ref->inode;
 
-	// Direct block are read directly from array in i-node structure
+	/* Direct block are read directly from array in i-node structure */
 	if (iblock < EXT4_INODE_DIRECT_BLOCK_COUNT) {
 		current_block = ext4_inode_get_direct_block(inode, (uint32_t)iblock);
@@ -773,5 +774,5 @@
 	}
 
-	// Determine indirection level of the target block
+	/* Determine indirection level of the target block */
 	int level = -1;
 	for (int i = 1; i < 4; i++) {
@@ -786,10 +787,10 @@
 	}
 
-	// Compute offsets for the topmost level
+	/* Compute offsets for the topmost level */
 	aoff64_t block_offset_in_level = iblock - fs->inode_block_limits[level-1];
 	current_block = ext4_inode_get_indirect_block(inode, level-1);
 	uint32_t offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1];
 
-	// Sparse file
+	/* Sparse file */
 	if (current_block == 0) {
 		*fblock = 0;
@@ -804,5 +805,5 @@
 	while (level > 0) {
 
-		// Load indirect block
+		/* Load indirect block */
 		rc = block_get(&block, fs->device, current_block, 0);
 		if (rc != EOK) {
@@ -810,8 +811,8 @@
 		}
 
-		// Read block address from indirect block
+		/* Read block address from indirect block */
 		current_block = uint32_t_le2host(((uint32_t*)block->data)[offset_in_block]);
 
-		// Put back indirect block untouched
+		/* Put back indirect block untouched */
 		rc = block_put(block);
 		if (rc != EOK) {
@@ -819,5 +820,5 @@
 		}
 
-		// Check for sparse file
+		/* Check for sparse file */
 		if (current_block == 0) {
 			*fblock = 0;
@@ -825,13 +826,13 @@
 		}
 
-		// Jump to the next level
+		/* Jump to the next level */
 		level -= 1;
 
-		// Termination condition - we have address of data block loaded
+		/* Termination condition - we have address of data block loaded */
 		if (level == 0) {
 			break;
 		}
 
-		// Visit the next level
+		/* Visit the next level */
 		block_offset_in_level %= fs->inode_blocks_per_level[level];
 		offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1];
@@ -857,12 +858,12 @@
 	ext4_filesystem_t *fs = inode_ref->fs;
 
-	// Handle inode using extents
+	/* Handle inode using extents */
 	if (ext4_superblock_has_feature_compatible(fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS) &&
 			ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS)) {
-		// not reachable !!!
+		/* not reachable !!! */
 		return ENOTSUP;
 	}
 
-	// Handle simple case when we are dealing with direct reference
+	/* Handle simple case when we are dealing with direct reference */
 	if (iblock < EXT4_INODE_DIRECT_BLOCK_COUNT) {
 		ext4_inode_set_direct_block(inode_ref->inode, (uint32_t)iblock, fblock);
@@ -871,5 +872,5 @@
 	}
 
-	// Determine the indirection level needed to get the desired block
+	/* Determine the indirection level needed to get the desired block */
 	int level = -1;
 	for (int i = 1; i < 4; i++) {
@@ -886,5 +887,5 @@
 	uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
 
-	// Compute offsets for the topmost level
+	/* Compute offsets for the topmost level */
 	aoff64_t block_offset_in_level = iblock - fs->inode_block_limits[level-1];
 	uint32_t current_block = ext4_inode_get_indirect_block(inode_ref->inode, level-1);
@@ -894,8 +895,8 @@
 	block_t *block, *new_block;
 
-	// Is needed to allocate indirect block on the i-node level
+	/* Is needed to allocate indirect block on the i-node level */
 	if (current_block == 0) {
 
-		// Allocate new indirect block
+		/* Allocate new indirect block */
 		rc = ext4_balloc_alloc_block(inode_ref, &new_block_addr);
 		if (rc != EOK) {
@@ -903,9 +904,9 @@
 		}
 
-		// Update i-node
+		/* Update i-node */
 		ext4_inode_set_indirect_block(inode_ref->inode, level - 1, new_block_addr);
 		inode_ref->dirty = true;
 
-		// Load newly allocated block
+		/* Load newly allocated block */
 		rc = block_get(&new_block, fs->device, new_block_addr, BLOCK_FLAGS_NOREAD);
 		if (rc != EOK) {
@@ -914,9 +915,9 @@
 		}
 
-		// Initialize new block
+		/* Initialize new block */
 		memset(new_block->data, 0, block_size);
 		new_block->dirty = true;
 
-		// Put back the allocated block
+		/* Put back the allocated block */
 		rc = block_put(new_block);
 		if (rc != EOK) {
@@ -941,5 +942,5 @@
 		if ((level > 1) && (current_block == 0)) {
 
-			// Allocate new block
+			/* Allocate new block */
 			rc = ext4_balloc_alloc_block(inode_ref, &new_block_addr);
 			if (rc != EOK) {
@@ -948,5 +949,5 @@
 			}
 
-			// Load newly allocated block
+			/* Load newly allocated block */
 			rc = block_get(&new_block, fs->device, new_block_addr, BLOCK_FLAGS_NOREAD);
 			if (rc != EOK) {
@@ -955,5 +956,5 @@
 			}
 
-			// Initialize allocated block
+			/* Initialize allocated block */
 			memset(new_block->data, 0, block_size);
 			new_block->dirty = true;
@@ -965,5 +966,5 @@
 			}
 
-			// Write block address to the parent
+			/* Write block address to the parent */
 			((uint32_t*)block->data)[offset_in_block] = host2uint32_t_le(new_block_addr);
 			block->dirty = true;
@@ -971,5 +972,5 @@
 		}
 
-		// Will be finished, write the fblock address
+		/* Will be finished, write the fblock address */
 		if (level == 1) {
 			((uint32_t*)block->data)[offset_in_block] = host2uint32_t_le(fblock);
@@ -1014,5 +1015,5 @@
 	ext4_filesystem_t *fs = inode_ref->fs;
 
-	// EXTENTS are handled otherwise = there is not support in this function
+	/* EXTENTS are handled otherwise = there is not support in this function */
 	assert(! (ext4_superblock_has_feature_incompatible(fs->superblock,
 			EXT4_FEATURE_INCOMPAT_EXTENTS) &&
@@ -1021,8 +1022,8 @@
 	ext4_inode_t *inode = inode_ref->inode;
 
-	// Handle simple case when we are dealing with direct reference
+	/* Handle simple case when we are dealing with direct reference */
 	if (iblock < EXT4_INODE_DIRECT_BLOCK_COUNT) {
 		fblock = ext4_inode_get_direct_block(inode, iblock);
-		// Sparse file
+		/* Sparse file */
 		if (fblock == 0) {
 			return EOK;
@@ -1034,5 +1035,5 @@
 
 
-	// Determine the indirection level needed to get the desired block
+	/* Determine the indirection level needed to get the desired block */
 	int level = -1;
 	for (int i = 1; i < 4; i++) {
@@ -1047,5 +1048,5 @@
 	}
 
-	// Compute offsets for the topmost level
+	/* Compute offsets for the topmost level */
 	aoff64_t block_offset_in_level = iblock - fs->inode_block_limits[level-1];
 	uint32_t current_block = ext4_inode_get_indirect_block(inode, level-1);
@@ -1064,5 +1065,5 @@
 		current_block = uint32_t_le2host(((uint32_t*)block->data)[offset_in_block]);
 
-		// Set zero if physical data block address found
+		/* Set zero if physical data block address found */
 		if (level == 1) {
 			((uint32_t*)block->data)[offset_in_block] = host2uint32_t_le(0);
@@ -1095,5 +1096,5 @@
 	}
 
-	// Physical block is not referenced, it can be released
+	/* Physical block is not referenced, it can be released */
 
 	return ext4_balloc_free_block(inode_ref, fblock);
@@ -1113,5 +1114,5 @@
 	int rc;
 
-	// Handle extents separately
+	/* Handle extents separately */
 	if (ext4_superblock_has_feature_incompatible(
 			inode_ref->fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS) &&
@@ -1124,17 +1125,17 @@
 	ext4_superblock_t *sb = inode_ref->fs->superblock;
 
-	// Compute next block index and allocate data block
+	/* Compute next block index and allocate data block */
 	uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode);
 	uint32_t block_size = ext4_superblock_get_block_size(sb);
 
-	// Align size i-node size
+	/* Align size i-node size */
 	if ((inode_size % block_size) != 0) {
 		inode_size += block_size - (inode_size % block_size);
 	}
 
-	// Logical blocks are numbered from 0
+	/* Logical blocks are numbered from 0 */
 	uint32_t new_block_idx = inode_size / block_size;
 
-	// Allocate new physical block
+	/* Allocate new physical block */
 	uint32_t phys_block;
 	rc =  ext4_balloc_alloc_block(inode_ref, &phys_block);
@@ -1143,5 +1144,5 @@
 	}
 
-	// Add physical block address to the i-node
+	/* Add physical block address to the i-node */
 	rc = ext4_filesystem_set_inode_data_block_index(inode_ref, new_block_idx, phys_block);
 	if (rc != EOK) {
@@ -1150,5 +1151,5 @@
 	}
 
-	// Update i-node
+	/* Update i-node */
 	ext4_inode_set_size(inode_ref->inode, inode_size + block_size);
 	inode_ref->dirty = true;
@@ -1173,8 +1174,8 @@
 			inode_ref->fs->superblock);
 
-	// Deletion time is used for holding next item of the list
+	/* Deletion time is used for holding next item of the list */
 	ext4_inode_set_deletion_time(inode_ref->inode, next_orphan);
 
-	// Head of the list is in the superblock
+	/* Head of the list is in the superblock */
 	ext4_superblock_set_last_orphan(
 			inode_ref->fs->superblock, inode_ref->index);
@@ -1196,5 +1197,5 @@
 	int rc;
 
-	// Get head of the linked list
+	/* Get head of the linked list */
 	uint32_t last_orphan = ext4_superblock_get_last_orphan(
 			inode_ref->fs->superblock);
@@ -1210,9 +1211,7 @@
 	uint32_t next_orphan = ext4_inode_get_deletion_time(current->inode);
 
-	// Check if the head is the target
+	/* Check if the head is the target */
 	if (last_orphan == inode_ref->index) {
 		ext4_superblock_set_last_orphan(inode_ref->fs->superblock, next_orphan);
-//		ext4_inode_set_deletion_time(inode_ref->inode, 0);
-//		inode_ref->dirty = true;
 		return EOK;
 	}
@@ -1220,13 +1219,11 @@
 	bool found = false;
 
-	// Walk thourgh the linked list
+	/* Walk thourgh the linked list */
 	while (next_orphan != 0) {
 
-		// Found?
+		/* Found? */
 		if (next_orphan == inode_ref->index) {
 			next_orphan = ext4_inode_get_deletion_time(inode_ref->inode);
 			ext4_inode_set_deletion_time(current->inode, next_orphan);
-//			ext4_inode_set_deletion_time(inode_ref->inode, 0);
-//			inode_ref->dirty = true;
 			current->dirty = true;
 			found = true;
