Index: uspace/lib/ext4/libext4_balloc.c =================================================================== --- uspace/lib/ext4/libext4_balloc.c (revision 49c94a3a0434b4b076957742b535ccde31846e07) +++ uspace/lib/ext4/libext4_balloc.c (revision 06d85e53f2ba96bd2ea9eae7bc274870ba1e1a85) @@ -52,5 +52,5 @@ uint32_t first_block = ext4_superblock_get_first_data_block(sb); - // First block == 0 or 1 + /* First block == 0 or 1 */ if (first_block == 0) { return block_addr % blocks_per_group; @@ -92,5 +92,5 @@ uint32_t first_block = ext4_superblock_get_first_data_block(sb); - // First block == 0 or 1 + /* First block == 0 or 1 */ if (first_block == 0) { return block_addr / blocks_per_group; @@ -114,9 +114,9 @@ ext4_superblock_t *sb = fs->superblock; - // Compute indexes + /* Compute indexes */ uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, block_addr); uint32_t index_in_group = ext4_balloc_blockaddr2_index_in_group(sb, block_addr); - // Load block group reference + /* Load block group reference */ ext4_block_group_ref_t *bg_ref; rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref); @@ -126,5 +126,5 @@ } - // Load block with bitmap + /* Load block with bitmap */ uint32_t bitmap_block_addr = ext4_block_group_get_block_bitmap( bg_ref->block_group, sb); @@ -136,13 +136,13 @@ } - // Modify bitmap + /* Modify bitmap */ ext4_bitmap_free_bit(bitmap_block->data, index_in_group); bitmap_block->dirty = true; - // Release block with bitmap + /* Release block with bitmap */ rc = block_put(bitmap_block); if (rc != EOK) { - // Error in saving bitmap + /* Error in saving bitmap */ ext4_filesystem_put_block_group_ref(bg_ref); EXT4FS_DBG("error in saving bitmap \%d", rc); @@ -152,10 +152,10 @@ uint32_t block_size = ext4_superblock_get_block_size(sb); - // Update superblock free blocks count + /* Update superblock free blocks count */ uint32_t sb_free_blocks = ext4_superblock_get_free_blocks_count(sb); sb_free_blocks++; ext4_superblock_set_free_blocks_count(sb, sb_free_blocks); - // Update inode blocks count + /* Update inode blocks count */ uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode); ino_blocks -= block_size / EXT4_INODE_BLOCK_SIZE; @@ -163,5 +163,5 @@ inode_ref->dirty = true; - // Update block group free blocks count + /* Update block group free blocks count */ uint32_t free_blocks = ext4_block_group_get_free_blocks_count( bg_ref->block_group, sb); @@ -171,5 +171,5 @@ bg_ref->dirty = true; - // Release block group reference + /* Release block group reference */ rc = ext4_filesystem_put_block_group_ref(bg_ref); if (rc != EOK) { @@ -196,5 +196,5 @@ ext4_superblock_t *sb = fs->superblock; - // Compute indexes + /* Compute indexes */ uint32_t block_group_first = ext4_balloc_get_bgid_of_block(sb, first); @@ -204,5 +204,5 @@ assert(block_group_first == block_group_last); - // Load block group reference + /* Load block group reference */ ext4_block_group_ref_t *bg_ref; rc = ext4_filesystem_get_block_group_ref(fs, block_group_first, &bg_ref); @@ -216,5 +216,5 @@ - // Load block with bitmap + /* Load block with bitmap */ uint32_t bitmap_block_addr = ext4_block_group_get_block_bitmap( bg_ref->block_group, sb); @@ -227,12 +227,12 @@ } - // Modify bitmap + /* Modify bitmap */ ext4_bitmap_free_bits(bitmap_block->data, index_in_group_first, count); bitmap_block->dirty = true; - // Release block with bitmap + /* Release block with bitmap */ rc = block_put(bitmap_block); if (rc != EOK) { - // Error in saving bitmap + /* Error in saving bitmap */ ext4_filesystem_put_block_group_ref(bg_ref); EXT4FS_DBG("error in saving bitmap \%d", rc); @@ -242,10 +242,10 @@ uint32_t block_size = ext4_superblock_get_block_size(sb); - // Update superblock free blocks count + /* Update superblock free blocks count */ uint32_t sb_free_blocks = ext4_superblock_get_free_blocks_count(sb); sb_free_blocks += count; ext4_superblock_set_free_blocks_count(sb, sb_free_blocks); - // Update inode blocks count + /* Update inode blocks count */ uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode); ino_blocks -= count * (block_size / EXT4_INODE_BLOCK_SIZE); @@ -253,5 +253,5 @@ inode_ref->dirty = true; - // Update block group free blocks count + /* Update block group free blocks count */ uint32_t free_blocks = ext4_block_group_get_free_blocks_count( bg_ref->block_group, sb); @@ -261,5 +261,5 @@ bg_ref->dirty = true; - // Release block group reference + /* Release block group reference */ rc = ext4_filesystem_put_block_group_ref(bg_ref); if (rc != EOK) { @@ -292,5 +292,5 @@ inode_table_bytes = inodes_per_group * inode_table_item_size; } else { - // last block group could be smaller + /* last block group could be smaller */ uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb); inode_table_bytes = @@ -328,5 +328,5 @@ } - // If inode has some blocks, get last block address + 1 + /* If inode has some blocks, get last block address + 1 */ if (inode_block_count > 0) { @@ -341,13 +341,13 @@ } - // if goal == 0, sparse file -> continue - } - - // Identify block group of inode + /* if goal == 0, sparse file -> continue */ + } + + /* Identify block group of inode */ uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb); uint32_t block_group = (inode_ref->index - 1) / inodes_per_group; block_size = ext4_superblock_get_block_size(sb); - // Load block group reference + /* Load block group reference */ ext4_block_group_ref_t *bg_ref; rc = ext4_filesystem_get_block_group_ref(inode_ref->fs, block_group, &bg_ref); @@ -356,5 +356,5 @@ } - // Compute indexes + /* Compute indexes */ uint32_t block_group_count = ext4_superblock_get_block_group_count(sb); uint32_t inode_table_first_block = ext4_block_group_get_inode_table_first_block( @@ -363,9 +363,9 @@ uint32_t inode_table_bytes; - // Check for last block group + /* Check for last block group */ if (block_group < block_group_count - 1) { inode_table_bytes = inodes_per_group * inode_table_item_size; } else { - // last block group could be smaller + /* last block group could be smaller */ uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb); inode_table_bytes = @@ -403,9 +403,9 @@ uint32_t rel_block_idx = 0; - // Find GOAL + /* Find GOAL */ uint32_t goal = ext4_balloc_find_goal(inode_ref); if (goal == 0) { - // no goal found => partition is full - EXT4FS_DBG("ERRORR (goal == 0)"); + /* no goal found => partition is full */ + EXT4FS_DBG("ERROR (goal == 0)"); return ENOSPC; } @@ -413,10 +413,10 @@ ext4_superblock_t *sb = inode_ref->fs->superblock; - // Load block group number for goal and relative index + /* Load block group number for goal and relative index */ uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, goal); uint32_t index_in_group = ext4_balloc_blockaddr2_index_in_group(sb, goal); - // Load block group reference + /* Load block group reference */ ext4_block_group_ref_t *bg_ref; rc = ext4_filesystem_get_block_group_ref(inode_ref->fs, block_group, &bg_ref); @@ -426,5 +426,5 @@ } - // Compute indexes + /* Compute indexes */ uint32_t first_in_group = ext4_balloc_get_first_data_block_in_group(sb, @@ -438,5 +438,5 @@ } - // Load block with bitmap + /* Load block with bitmap */ bitmap_block_addr = ext4_block_group_get_block_bitmap(bg_ref->block_group, sb); @@ -449,5 +449,5 @@ } - // Check if goal is free + /* Check if goal is free */ if (ext4_bitmap_is_free_bit(bitmap_block->data, index_in_group)) { ext4_bitmap_set_bit(bitmap_block->data, index_in_group); @@ -472,5 +472,5 @@ } - // Try to find free block near to goal + /* Try to find free block near to goal */ for (uint32_t tmp_idx = index_in_group + 1; tmp_idx < end_idx; ++tmp_idx) { if (ext4_bitmap_is_free_bit(bitmap_block->data, tmp_idx)) { @@ -492,5 +492,5 @@ } - // Find free BYTE in bitmap + /* Find free BYTE in bitmap */ rc = ext4_bitmap_find_free_byte_and_set_bit(bitmap_block->data, index_in_group, &rel_block_idx, blocks_in_group); if (rc == EOK) { @@ -508,5 +508,5 @@ } - // Find free bit in bitmap + /* Find free bit in bitmap */ rc = ext4_bitmap_find_free_bit_and_set(bitmap_block->data, index_in_group, &rel_block_idx, blocks_in_group); if (rc == EOK) { @@ -524,9 +524,9 @@ } - // No free block found yet + /* No free block found yet */ block_put(bitmap_block); ext4_filesystem_put_block_group_ref(bg_ref); - // Try other block groups + /* Try other block groups */ uint32_t block_group_count = ext4_superblock_get_block_group_count(sb); @@ -541,5 +541,5 @@ } - // Load block with bitmap + /* Load block with bitmap */ bitmap_block_addr = ext4_block_group_get_block_bitmap( bg_ref->block_group, sb); @@ -552,5 +552,5 @@ } - // Compute indexes + /* Compute indexes */ first_in_group = ext4_balloc_get_first_data_block_in_group( sb, bg_ref->block_group, bgid); @@ -566,5 +566,5 @@ } - // Try to find free byte in bitmap + /* Try to find free byte in bitmap */ rc = ext4_bitmap_find_free_byte_and_set_bit(bitmap_block->data, index_in_group, &rel_block_idx, blocks_in_group); if (rc == EOK) { @@ -582,5 +582,5 @@ } - // Try to find free bit in bitmap + /* Try to find free bit in bitmap */ rc = ext4_bitmap_find_free_bit_and_set(bitmap_block->data, index_in_group, &rel_block_idx, blocks_in_group); if (rc == EOK) { @@ -601,5 +601,5 @@ ext4_filesystem_put_block_group_ref(bg_ref); - // Goto next group + /* Goto next group */ bgid = (bgid + 1) % block_group_count; count--; @@ -609,14 +609,14 @@ success: - ; // Empty command - because of syntax + ; /* Empty command - because of syntax */ uint32_t block_size = ext4_superblock_get_block_size(sb); - // Update superblock free blocks count + /* Update superblock free blocks count */ uint32_t sb_free_blocks = ext4_superblock_get_free_blocks_count(sb); sb_free_blocks--; ext4_superblock_set_free_blocks_count(sb, sb_free_blocks); - // Update inode blocks (different block size!) count + /* Update inode blocks (different block size!) count */ uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode); ino_blocks += block_size / EXT4_INODE_BLOCK_SIZE; @@ -624,5 +624,5 @@ inode_ref->dirty = true; - // Update block group free blocks count + /* Update block group free blocks count */ uint32_t bg_free_blocks = ext4_block_group_get_free_blocks_count( bg_ref->block_group, sb); @@ -652,9 +652,9 @@ ext4_superblock_t *sb = fs->superblock; - // Compute indexes + /* Compute indexes */ uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, fblock); uint32_t index_in_group = ext4_balloc_blockaddr2_index_in_group(sb, fblock); - // Load block group reference + /* Load block group reference */ ext4_block_group_ref_t *bg_ref; rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref); @@ -664,5 +664,5 @@ } - // Load block with bitmap + /* Load block with bitmap */ uint32_t bitmap_block_addr = ext4_block_group_get_block_bitmap( bg_ref->block_group, sb); @@ -674,8 +674,8 @@ } - // Check if block is free + /* Check if block is free */ *free = ext4_bitmap_is_free_bit(bitmap_block->data, index_in_group); - // Allocate block if possible + /* Allocate block if possible */ if (*free) { ext4_bitmap_set_bit(bitmap_block->data, index_in_group); @@ -683,8 +683,8 @@ } - // Release block with bitmap + /* Release block with bitmap */ rc = block_put(bitmap_block); if (rc != EOK) { - // Error in saving bitmap + /* Error in saving bitmap */ ext4_filesystem_put_block_group_ref(bg_ref); EXT4FS_DBG("error in saving bitmap \%d", rc); @@ -692,5 +692,5 @@ } - // If block is not free, return + /* If block is not free, return */ if (!(*free)) { goto terminate; @@ -699,10 +699,10 @@ uint32_t block_size = ext4_superblock_get_block_size(sb); - // Update superblock free blocks count + /* Update superblock free blocks count */ uint32_t sb_free_blocks = ext4_superblock_get_free_blocks_count(sb); sb_free_blocks--; ext4_superblock_set_free_blocks_count(sb, sb_free_blocks); - // Update inode blocks count + /* Update inode blocks count */ uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode); ino_blocks += block_size / EXT4_INODE_BLOCK_SIZE; @@ -710,5 +710,5 @@ inode_ref->dirty = true; - // Update block group free blocks count + /* Update block group free blocks count */ uint32_t free_blocks = ext4_block_group_get_free_blocks_count( bg_ref->block_group, sb); Index: uspace/lib/ext4/libext4_bitmap.c =================================================================== --- uspace/lib/ext4/libext4_bitmap.c (revision 49c94a3a0434b4b076957742b535ccde31846e07) +++ uspace/lib/ext4/libext4_bitmap.c (revision 06d85e53f2ba96bd2ea9eae7bc274870ba1e1a85) @@ -73,5 +73,5 @@ uint32_t byte_index; - // Align index to multiple of 8 + /* Align index to multiple of 8 */ while (((idx % 8) != 0) && (remaining > 0)) { @@ -87,5 +87,5 @@ } - // For < 8 bits this check necessary + /* For < 8 bits this check necessary */ if (remaining == 0) { return; @@ -97,5 +97,5 @@ target = bitmap + byte_index; - // Zero the whole bytes + /* Zero the whole bytes */ while (remaining >= 8) { *target = 0; @@ -108,5 +108,5 @@ assert(remaining < 8); - // Zero remaining bytes + /* Zero remaining bytes */ while (remaining != 0) { @@ -174,5 +174,5 @@ uint32_t idx; - // Align idx + /* Align idx */ if (start % 8) { idx = start + (8 - (start % 8)); @@ -183,5 +183,5 @@ uint8_t *pos = bitmap + (idx / 8); - // Try to find free byte + /* Try to find free byte */ while (idx < max) { @@ -197,5 +197,5 @@ } - // Free byte not found + /* Free byte not found */ return ENOSPC; } @@ -218,5 +218,5 @@ bool byte_part = false; - // Check the rest of first byte + /* Check the rest of first byte */ while ((idx % 8) != 0) { byte_part = true; @@ -235,9 +235,9 @@ } - // Check the whole bytes (255 = 11111111 binary) + /* Check the whole bytes (255 = 11111111 binary) */ while (idx < max) { if ((*pos & 255) != 255) { - // free bit found + /* free bit found */ break; } @@ -247,11 +247,11 @@ } - // If idx < max, some free bit found + /* If idx < max, some free bit found */ if (idx < max) { - // Check which bit from byte is free + /* Check which bit from byte is free */ for (uint8_t i = 0; i < 8; ++i) { if ((*pos & (1 << i)) == 0) { - // free bit found + /* free bit found */ *pos |= (1 << i); *index = idx; @@ -262,5 +262,5 @@ } - // Free bit not found + /* Free bit not found */ return ENOSPC; } Index: uspace/lib/ext4/libext4_directory.c =================================================================== --- uspace/lib/ext4/libext4_directory.c (revision 49c94a3a0434b4b076957742b535ccde31846e07) +++ uspace/lib/ext4/libext4_directory.c (revision 06d85e53f2ba96bd2ea9eae7bc274870ba1e1a85) @@ -159,5 +159,5 @@ } - // else do nothing + /* else do nothing */ } @@ -237,5 +237,5 @@ } - // Compute next block address + /* Compute next block address */ uint32_t block_size = ext4_superblock_get_block_size( it->inode_ref->fs->superblock); @@ -313,5 +313,5 @@ } - // Everything OK - "publish" the entry + /* Everything OK - "publish" the entry */ it->current = entry; return EOK; @@ -357,17 +357,17 @@ { - // Check maximum entry length + /* Check maximum entry length */ uint32_t block_size = ext4_superblock_get_block_size(sb); assert(entry_len <= block_size); - // Set basic attributes + /* Set basic attributes */ ext4_directory_entry_ll_set_inode(entry, child->index); ext4_directory_entry_ll_set_entry_length(entry, entry_len); ext4_directory_entry_ll_set_name_length(sb, entry, name_len); - // Write name + /* Write name */ memcpy(entry->name, name, name_len); - // Set type of entry + /* Set type of entry */ if (ext4_inode_is_type(sb, child->inode, EXT4_INODE_MODE_DIRECTORY)) { ext4_directory_entry_ll_set_inode_type( @@ -394,5 +394,5 @@ ext4_filesystem_t *fs = parent->fs; - // Index adding (if allowed) + /* Index adding (if allowed) */ if (ext4_superblock_has_feature_compatible(fs->superblock, EXT4_FEATURE_COMPAT_DIR_INDEX) && ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX)) { @@ -400,5 +400,5 @@ rc = ext4_directory_dx_add_entry(parent, child, name); - // Check if index is not corrupted + /* Check if index is not corrupted */ if (rc != EXT4_ERR_BAD_DX_DIR) { @@ -410,5 +410,5 @@ } - // Needed to clear dir index flag if corrupted + /* Needed to clear dir index flag if corrupted */ ext4_inode_clear_flag(parent->inode, EXT4_INODE_FLAG_INDEX); parent->dirty = true; @@ -417,5 +417,5 @@ } - // Linear algorithm + /* Linear algorithm */ uint32_t iblock = 0, fblock = 0; @@ -426,5 +426,5 @@ uint32_t name_len = strlen(name); - // Find block, where is space for new entry and try to add + /* Find block, where is space for new entry and try to add */ bool success = false; for (iblock = 0; iblock < total_blocks; ++iblock) { @@ -441,5 +441,5 @@ } - // If adding is successful, function can finish + /* If adding is successful, function can finish */ rc = ext4_directory_try_insert_entry(fs->superblock, block, child, name, name_len); if (rc == EOK) { @@ -457,5 +457,5 @@ } - // No free block found - needed to allocate next data block + /* No free block found - needed to allocate next data block */ iblock = 0; @@ -466,5 +466,5 @@ } - // Load new block + /* Load new block */ block_t *new_block; rc = block_get(&new_block, fs->device, fblock, BLOCK_FLAGS_NOREAD); @@ -473,10 +473,10 @@ } - // Fill block with zeroes + /* Fill block with zeroes */ memset(new_block->data, 0, block_size); ext4_directory_entry_ll_t *block_entry = new_block->data; ext4_directory_write_entry(fs->superblock, block_entry, block_size, child, name, name_len); - // Save new block + /* Save new block */ new_block->dirty = true; rc = block_put(new_block); @@ -503,5 +503,5 @@ ext4_superblock_t *sb = parent->fs->superblock; - // Index search + /* Index search */ if (ext4_superblock_has_feature_compatible(sb, EXT4_FEATURE_COMPAT_DIR_INDEX) && ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX)) { @@ -509,5 +509,5 @@ rc = ext4_directory_dx_find_entry(result, parent, name_len, name); - // Check if index is not corrupted + /* Check if index is not corrupted */ if (rc != EXT4_ERR_BAD_DX_DIR) { @@ -518,5 +518,5 @@ } - // Needed to clear dir index flag if corrupted + /* Needed to clear dir index flag if corrupted */ ext4_inode_clear_flag(parent->inode, EXT4_INODE_FLAG_INDEX); parent->dirty = true; @@ -525,5 +525,5 @@ } - // Linear algorithm + /* Linear algorithm */ uint32_t iblock, fblock; @@ -532,8 +532,8 @@ uint32_t total_blocks = inode_size / block_size; - // Walk through all data blocks + /* Walk through all data blocks */ for (iblock = 0; iblock < total_blocks; ++iblock) { - // Load block address + /* Load block address */ rc = ext4_filesystem_get_inode_data_block_index(parent, iblock, &fblock); if (rc != EOK) { @@ -541,5 +541,5 @@ } - // Load data block + /* Load data block */ block_t *block; rc = block_get(&block, parent->fs->device, fblock, BLOCK_FLAGS_NONE); @@ -548,5 +548,5 @@ } - // Try to find entry in block + /* Try to find entry in block */ ext4_directory_entry_ll_t *res_entry; rc = ext4_directory_find_in_block(block, sb, name_len, name, &res_entry); @@ -557,5 +557,5 @@ } - // Entry not found - put block and continue to the next block + /* Entry not found - put block and continue to the next block */ rc = block_put(block); @@ -565,5 +565,5 @@ } - // Entry was not found + /* Entry was not found */ result->block = NULL; @@ -584,5 +584,5 @@ int rc; - // Check if removing from directory + /* Check if removing from directory */ if (!ext4_inode_is_type(parent->fs->superblock, parent->inode, EXT4_INODE_MODE_DIRECTORY)) { @@ -590,5 +590,5 @@ } - // Try to find entry + /* Try to find entry */ ext4_directory_search_result_t result; rc = ext4_directory_find_entry(&result, parent, name); @@ -597,22 +597,23 @@ } - // Invalidate entry + /* Invalidate entry */ ext4_directory_entry_ll_set_inode(result.dentry, 0); - // Store entry position in block + /* Store entry position in block */ uint32_t pos = (void *)result.dentry - result.block->data; - // If entry is not the first in block, it must be merged - // with previous entry + /* If entry is not the first in block, it must be merged + * with previous entry + */ if (pos != 0) { uint32_t offset = 0; - // Start from the first entry in block + /* Start from the first entry in block */ ext4_directory_entry_ll_t *tmp_dentry = result.block->data; uint16_t tmp_dentry_length = ext4_directory_entry_ll_get_entry_length(tmp_dentry); - // Find direct predecessor of removed entry + /* Find direct predecessor of removed entry */ while ((offset + tmp_dentry_length) < pos) { offset += ext4_directory_entry_ll_get_entry_length(tmp_dentry); @@ -624,5 +625,5 @@ assert(tmp_dentry_length + offset == pos); - // Add to removed entry length to predecessor's length + /* Add to removed entry length to predecessor's length */ uint16_t del_entry_length = ext4_directory_entry_ll_get_entry_length(result.dentry); @@ -650,5 +651,5 @@ const char *name, uint32_t name_len) { - // Compute required length entry and align it to 4 bytes + /* Compute required length entry and align it to 4 bytes */ uint32_t block_size = ext4_superblock_get_block_size(sb); uint16_t required_len = sizeof(ext4_fake_directory_entry_t) + name_len; @@ -657,10 +658,11 @@ } - // Initialize pointers, stop means to upper bound + /* Initialize pointers, stop means to upper bound */ ext4_directory_entry_ll_t *dentry = target_block->data; ext4_directory_entry_ll_t *stop = target_block->data + block_size; - // Walk through the block and check for invalid entries - // or entries with free space for new entry + /* Walk through the block and check for invalid entries + * or entries with free space for new entry + */ while (dentry < stop) { @@ -668,5 +670,5 @@ uint16_t rec_len = ext4_directory_entry_ll_get_entry_length(dentry); - // If invalid and large enough entry, use it + /* If invalid and large enough entry, use it */ if ((inode == 0) && (rec_len >= required_len)) { ext4_directory_write_entry(sb, dentry, rec_len, child, name, name_len); @@ -675,5 +677,5 @@ } - // Valid entry, try to split it + /* Valid entry, try to split it */ if (inode != 0) { uint16_t used_name_len = @@ -687,8 +689,8 @@ uint16_t free_space = rec_len - used_space; - // There is free space for new entry + /* There is free space for new entry */ if (free_space >= required_len) { - // Cut tail of current entry + /* Cut tail of current entry */ ext4_directory_entry_ll_set_entry_length(dentry, used_space); ext4_directory_entry_ll_t *new_entry = @@ -702,9 +704,9 @@ } - // Jump to the next entry + /* Jump to the next entry */ dentry = (void *)dentry + rec_len; } - // No free space found for new entry + /* No free space found for new entry */ return ENOSPC; @@ -724,23 +726,23 @@ ext4_directory_entry_ll_t **res_entry) { - // Start from the first entry in block + /* Start from the first entry in block */ ext4_directory_entry_ll_t *dentry = (ext4_directory_entry_ll_t *)block->data; - //Set upper bound for cycling + /*Set upper bound for cycling */ uint8_t *addr_limit = block->data + ext4_superblock_get_block_size(sb); - // Walk through the block and check entries + /* Walk through the block and check entries */ while ((uint8_t *)dentry < addr_limit) { - // Termination condition + /* Termination condition */ if ((uint8_t*) dentry + name_len > addr_limit) { break; } - // Valid entry - check it + /* Valid entry - check it */ if (dentry->inode != 0) { - // For more effectivity compare firstly only lengths + /* For more effectivity compare firstly only lengths */ if (name_len == ext4_directory_entry_ll_get_name_length(sb, dentry)) { - // Compare names + /* Compare names */ if (bcmp((uint8_t *)name, dentry->name, name_len) == 0) { *res_entry = dentry; @@ -752,14 +754,14 @@ uint16_t dentry_len = ext4_directory_entry_ll_get_entry_length(dentry); - // Corrupted entry + /* Corrupted entry */ if (dentry_len == 0) { return EINVAL; } - // Jump to next entry + /* Jump to next entry */ dentry = (ext4_directory_entry_ll_t *)((uint8_t *)dentry + dentry_len); } - // Entry not found + /* Entry not found */ return ENOENT; } Index: uspace/lib/ext4/libext4_directory_index.c =================================================================== --- uspace/lib/ext4/libext4_directory_index.c (revision 49c94a3a0434b4b076957742b535ccde31846e07) +++ uspace/lib/ext4/libext4_directory_index.c (revision 06d85e53f2ba96bd2ea9eae7bc274870ba1e1a85) @@ -218,5 +218,5 @@ int rc; - // Load block 0, where will be index root located + /* Load block 0, where will be index root located */ uint32_t fblock; rc = ext4_filesystem_get_inode_data_block_index(dir, 0, &fblock); @@ -231,9 +231,9 @@ } - // Initialize pointers to data structures + /* Initialize pointers to data structures */ ext4_directory_dx_root_t *root = block->data; ext4_directory_dx_root_info_t *info = &(root->info); - // Initialize root info structure + /* Initialize root info structure */ uint8_t hash_version = ext4_superblock_get_default_hash_version(dir->fs->superblock); @@ -243,5 +243,5 @@ ext4_directory_dx_root_info_set_info_length(info, 8); - // Set limit and current number of entries + /* Set limit and current number of entries */ ext4_directory_dx_countlimit_t *countlimit = (ext4_directory_dx_countlimit_t *)&root->entries; @@ -254,5 +254,5 @@ ext4_directory_dx_countlimit_set_limit(countlimit, root_limit); - // Append new block, where will be new entries inserted in the future + /* Append new block, where will be new entries inserted in the future */ uint32_t iblock; rc = ext4_filesystem_append_inode_block(dir, &fblock, &iblock); @@ -269,5 +269,5 @@ } - // Fill the whole block with empty entry + /* Fill the whole block with empty entry */ ext4_directory_entry_ll_t *block_entry = new_block->data; ext4_directory_entry_ll_set_entry_length(block_entry, block_size); @@ -281,5 +281,5 @@ } - // Connect new block to the only entry in index + /* Connect new block to the only entry in index */ ext4_directory_dx_entry_t *entry = root->entries; ext4_directory_dx_entry_set_block(entry, iblock); @@ -316,5 +316,5 @@ } - // Check unused flags + /* Check unused flags */ if (root->info.unused_flags != 0) { EXT4FS_DBG("ERR: unused_flags = \%u", root->info.unused_flags); @@ -322,5 +322,5 @@ } - // Check indirect levels + /* Check indirect levels */ if (root->info.indirect_levels > 1) { EXT4FS_DBG("ERR: indirect_levels = \%u", root->info.indirect_levels); @@ -328,5 +328,5 @@ } - // Check if node limit is correct + /* Check if node limit is correct */ uint32_t block_size = ext4_superblock_get_block_size(sb); uint32_t entry_space = block_size; @@ -340,16 +340,16 @@ } - // Check hash version and modify if necessary + /* Check hash version and modify if necessary */ hinfo->hash_version = ext4_directory_dx_root_info_get_hash_version(&root->info); if ((hinfo->hash_version <= EXT4_HASH_VERSION_TEA) && (ext4_superblock_has_flag(sb, EXT4_SUPERBLOCK_FLAGS_UNSIGNED_HASH))) { - // 3 is magic from ext4 linux implementation + /* 3 is magic from ext4 linux implementation */ hinfo->hash_version += 3; } - // Load hash seed from superblock + /* Load hash seed from superblock */ hinfo->seed = ext4_superblock_get_hash_seed(sb); - // Compute hash value of name + /* Compute hash value of name */ if (name) { ext4_hash_string(hinfo, name_len, name); @@ -385,5 +385,5 @@ ext4_directory_dx_entry_t *p, *q, *m, *at; - // Walk through the index tree + /* Walk through the index tree */ while (true) { @@ -394,5 +394,5 @@ - // Do binary search in every node + /* Do binary search in every node */ p = entries + 1; q = entries + count - 1; @@ -409,10 +409,10 @@ at = p - 1; - // Write results + /* Write results */ tmp_dx_block->block = tmp_block; tmp_dx_block->entries = entries; tmp_dx_block->position = at; - // Is algorithm in the leaf? + /* Is algorithm in the leaf? */ if (indirect_level == 0) { *dx_block = tmp_dx_block; @@ -420,5 +420,5 @@ } - // Goto child node + /* Goto child node */ uint32_t next_block = ext4_directory_dx_entry_get_block(at); @@ -454,5 +454,5 @@ } - // Unreachable + /* Unreachable */ return EOK; } @@ -475,5 +475,5 @@ ext4_directory_dx_block_t *p = dx_block; - // Try to find data block with next bunch of entries + /* Try to find data block with next bunch of entries */ while (1) { @@ -494,5 +494,5 @@ } - // Check hash collision (if not occured - no next block cannot be used) + /* Check hash collision (if not occured - no next block cannot be used) */ uint32_t current_hash = ext4_directory_dx_entry_get_hash(p->position); if ((hash & 1) == 0) { @@ -502,5 +502,5 @@ } - // Fill new path + /* Fill new path */ while (num_handles--) { @@ -520,5 +520,5 @@ p++; - // Don't forget to put old block (prevent memory leak) + /* Don't forget to put old block (prevent memory leak) */ block_put(p->block); @@ -546,5 +546,5 @@ int rc; - // Load direct block 0 (index root) + /* Load direct block 0 (index root) */ uint32_t root_block_addr; rc = ext4_filesystem_get_inode_data_block_index(inode_ref, 0, &root_block_addr); @@ -561,5 +561,5 @@ } - // Initialize hash info (compute hash value) + /* Initialize hash info (compute hash value) */ ext4_hash_info_t hinfo; rc = ext4_directory_hinfo_init(&hinfo, root_block, fs->superblock, name_len, name); @@ -569,5 +569,5 @@ } - // Hardcoded number 2 means maximum height of index tree, specified in linux driver + /* Hardcoded number 2 means maximum height of index tree, specified in linux driver */ ext4_directory_dx_block_t dx_blocks[2]; ext4_directory_dx_block_t *dx_block, *tmp; @@ -579,5 +579,5 @@ do { - // Load leaf block + /* Load leaf block */ uint32_t leaf_block_idx = ext4_directory_dx_entry_get_block(dx_block->position); uint32_t leaf_block_addr; @@ -593,9 +593,9 @@ } - // Linear search inside block + /* Linear search inside block */ ext4_directory_entry_ll_t *res_dentry; rc = ext4_directory_find_in_block(leaf_block, fs->superblock, name_len, name, &res_dentry); - // Found => return it + /* Found => return it */ if (rc == EOK) { result->block = leaf_block; @@ -604,5 +604,5 @@ } - // Not found, leave untouched + /* Not found, leave untouched */ block_put(leaf_block); @@ -611,5 +611,5 @@ } - // check if the next block could be checked + /* check if the next block could be checked */ rc = ext4_directory_dx_next_block(inode_ref, hinfo.hash, dx_block, &dx_blocks[0]); if (rc < 0) { @@ -619,10 +619,10 @@ } while (rc == 1); - // Entry not found + /* Entry not found */ rc = ENOENT; cleanup: - // The whole path must be released (preventing memory leak) + /* The whole path must be released (preventing memory leak) */ tmp = dx_blocks; while (tmp <= dx_block) { @@ -705,5 +705,5 @@ int rc = EOK; - // Allocate buffer for directory entries + /* Allocate buffer for directory entries */ uint32_t block_size = ext4_superblock_get_block_size(inode_ref->fs->superblock); @@ -713,8 +713,8 @@ } - // dot entry has the smallest size available + /* dot entry has the smallest size available */ uint32_t max_entry_count = block_size / sizeof(ext4_directory_dx_dot_entry_t); - // Allocate sort entry + /* Allocate sort entry */ ext4_dx_sort_entry_t *sort_array = malloc(max_entry_count * sizeof(ext4_dx_sort_entry_t)); if (sort_array == NULL) { @@ -726,14 +726,14 @@ uint32_t real_size = 0; - // Initialize hinfo + /* Initialize hinfo */ ext4_hash_info_t tmp_hinfo; memcpy(&tmp_hinfo, hinfo, sizeof(ext4_hash_info_t)); - // Load all valid entries to the buffer + /* Load all valid entries to the buffer */ ext4_directory_entry_ll_t *dentry = old_data_block->data; void *entry_buffer_ptr = entry_buffer; while ((void *)dentry < old_data_block->data + block_size) { - // Read only valid entries + /* Read only valid entries */ if (ext4_directory_entry_ll_get_inode(dentry) != 0) { @@ -762,9 +762,9 @@ } - // Sort all entries + /* Sort all entries */ qsort(sort_array, idx, sizeof(ext4_dx_sort_entry_t), ext4_directory_dx_entry_comparator, NULL); - // Allocate new block for store the second part of entries + /* Allocate new block for store the second part of entries */ uint32_t new_fblock; uint32_t new_iblock; @@ -776,5 +776,5 @@ } - // Load new block + /* Load new block */ block_t *new_data_block_tmp; rc = block_get(&new_data_block_tmp, inode_ref->fs->device, @@ -786,6 +786,7 @@ } - // Distribute entries to two blocks (by size) - // Compute the half + /* Distribute entries to two blocks (by size) + * - compute the half + */ uint32_t new_hash = 0; uint32_t current_size = 0; @@ -801,5 +802,5 @@ } - // Check hash collision + /* Check hash collision */ uint32_t continued = 0; if (new_hash == sort_array[mid-1].hash) { @@ -810,5 +811,5 @@ void *ptr; - // First part - to the old block + /* First part - to the old block */ for (uint32_t i = 0; i < mid; ++i) { ptr = old_data_block->data + offset; @@ -825,5 +826,5 @@ } - // Second part - to the new block + /* Second part - to the new block */ offset = 0; for (uint32_t i = mid; i < idx; ++i) { @@ -841,5 +842,5 @@ } - // Do some steps to finish operation + /* Do some steps to finish operation */ old_data_block->dirty = true; new_data_block_tmp->dirty = true; @@ -879,5 +880,5 @@ uint16_t leaf_count = ext4_directory_dx_countlimit_get_count(countlimit); - // Check if is necessary to split index block + /* Check if is necessary to split index block */ if (leaf_limit == leaf_count) { @@ -894,5 +895,5 @@ ext4_directory_dx_countlimit_get_count(root_countlimit); - // Linux limitation + /* Linux limitation */ if ((levels > 0) && (root_limit == root_count)) { EXT4FS_DBG("Directory index is full"); @@ -900,5 +901,5 @@ } - // Add new block to directory + /* Add new block to directory */ uint32_t new_fblock; uint32_t new_iblock; @@ -909,5 +910,5 @@ } - // load new block + /* load new block */ block_t * new_block; rc = block_get(&new_block, inode_ref->fs->device, @@ -923,5 +924,5 @@ inode_ref->fs->superblock); - // Split leaf node + /* Split leaf node */ if (levels > 0) { @@ -931,9 +932,9 @@ ext4_directory_dx_entry_get_hash(entries + count_left); - // Copy data to new node + /* Copy data to new node */ memcpy((void *) new_entries, (void *) (entries + count_left), count_right * sizeof(ext4_directory_dx_entry_t)); - // Initialize new node + /* Initialize new node */ ext4_directory_dx_countlimit_t *left_countlimit = (ext4_directory_dx_countlimit_t *)entries; @@ -948,5 +949,5 @@ ext4_directory_dx_countlimit_set_limit(right_countlimit, node_limit); - // Which index block is target for new entry + /* Which index block is target for new entry */ uint32_t position_index = (dx_block->position - dx_block->entries); if (position_index >= count_left) { @@ -963,5 +964,5 @@ } - // Finally insert new entry + /* Finally insert new entry */ ext4_directory_dx_insert_entry(dx_blocks, hash_right, new_iblock); @@ -970,7 +971,7 @@ } else { - // Create second level index - - // Copy data from root to child block + /* Create second level index */ + + /* Copy data from root to child block */ memcpy((void *) new_entries, (void *) entries, leaf_count * sizeof(ext4_directory_dx_entry_t)); @@ -983,5 +984,5 @@ ext4_directory_dx_countlimit_set_limit(new_countlimit, node_limit); - // Set values in root node + /* Set values in root node */ ext4_directory_dx_countlimit_t *new_root_countlimit = (ext4_directory_dx_countlimit_t *)entries; @@ -992,5 +993,5 @@ ((ext4_directory_dx_root_t *)dx_blocks[0].block->data)->info.indirect_levels = 1; - // Add new entry to the path + /* Add new entry to the path */ dx_block = dx_blocks + 1; dx_block->position = dx_block->position - entries + new_entries; @@ -1017,5 +1018,5 @@ int rc2 = EOK; - // get direct block 0 (index root) + /* get direct block 0 (index root) */ uint32_t root_block_addr; rc = ext4_filesystem_get_inode_data_block_index(parent, 0, &root_block_addr); @@ -1032,5 +1033,5 @@ } - // Initialize hinfo structure (mainly compute hash) + /* Initialize hinfo structure (mainly compute hash) */ uint32_t name_len = strlen(name); ext4_hash_info_t hinfo; @@ -1042,5 +1043,5 @@ } - // Hardcoded number 2 means maximum height of index tree defined in linux + /* Hardcoded number 2 means maximum height of index tree defined in linux */ ext4_directory_dx_block_t dx_blocks[2]; ext4_directory_dx_block_t *dx_block, *dx_it; @@ -1053,5 +1054,5 @@ - // Try to insert to existing data block + /* Try to insert to existing data block */ uint32_t leaf_block_idx = ext4_directory_dx_entry_get_block(dx_block->position); uint32_t leaf_block_addr; @@ -1068,5 +1069,5 @@ } - // Check if insert operation passed + /* Check if insert operation passed */ rc = ext4_directory_try_insert_entry(fs->superblock, target_block, child, name, name_len); if (rc == EOK) { @@ -1074,6 +1075,7 @@ } - // Check if there is needed to split index node - // (and recursively also parent nodes) + /* Check if there is needed to split index node + * (and recursively also parent nodes) + */ rc = ext4_directory_dx_split_index(parent, dx_blocks, dx_block); if (rc != EOK) { @@ -1081,5 +1083,5 @@ } - // Split entries to two blocks (includes sorting by hash value) + /* Split entries to two blocks (includes sorting by hash value) */ block_t *new_block = NULL; rc = ext4_directory_dx_split_data(parent, &hinfo, target_block, dx_block, &new_block); @@ -1089,5 +1091,5 @@ } - // Where to save new entry + /* Where to save new entry */ uint32_t new_block_hash = ext4_directory_dx_entry_get_hash(dx_block->position + 1); if (hinfo.hash >= new_block_hash) { @@ -1097,5 +1099,5 @@ } - // Cleanup + /* Cleanup */ rc = block_put(new_block); if (rc != EOK) { @@ -1104,5 +1106,5 @@ } - // Cleanup operations + /* Cleanup operations */ release_target_index: Index: uspace/lib/ext4/libext4_extent.c =================================================================== --- uspace/lib/ext4/libext4_extent.c (revision 49c94a3a0434b4b076957742b535ccde31846e07) +++ uspace/lib/ext4/libext4_extent.c (revision 06d85e53f2ba96bd2ea9eae7bc274870ba1e1a85) @@ -262,9 +262,9 @@ uint16_t entries_count = ext4_extent_header_get_entries_count(header); - // Initialize bounds + /* Initialize bounds */ l = EXT4_EXTENT_FIRST_INDEX(header) + 1; r = EXT4_EXTENT_FIRST_INDEX(header) + entries_count - 1; - // Do binary search + /* Do binary search */ while (l <= r) { m = l + (r - l) / 2; @@ -277,5 +277,5 @@ } - // Set output value + /* Set output value */ *index = l - 1; } @@ -296,14 +296,14 @@ if (entries_count == 0) { - // this leaf is empty + /* this leaf is empty */ *extent = NULL; return; } - // Initialize bounds + /* Initialize bounds */ l = EXT4_EXTENT_FIRST(header) + 1; r = EXT4_EXTENT_FIRST(header) + entries_count - 1; - // Do binary search + /* Do binary search */ while (l <= r) { m = l + (r - l) / 2; @@ -316,5 +316,5 @@ } - // Set output value + /* Set output value */ *extent = l - 1; } @@ -334,5 +334,5 @@ int rc; - // Compute bound defined by i-node size + /* Compute bound defined by i-node size */ uint64_t inode_size = ext4_inode_get_size( inode_ref->fs->superblock, inode_ref->inode); @@ -343,5 +343,5 @@ uint32_t last_idx = (inode_size - 1) / block_size; - // Check if requested iblock is not over size of i-node + /* Check if requested iblock is not over size of i-node */ if (iblock > last_idx) { *fblock = 0; @@ -351,17 +351,14 @@ block_t* block = NULL; - // Walk through extent tree + /* Walk through extent tree */ ext4_extent_header_t *header = ext4_inode_get_extent_header(inode_ref->inode); -// EXT4FS_DBG("inode = \%u", inode_ref->index); -// EXT4FS_DBG("count = \%u", ext4_extent_header_get_entries_count(header)); - while (ext4_extent_header_get_depth(header) != 0) { - // Search index in node + /* Search index in node */ ext4_extent_index_t *index; ext4_extent_binsearch_idx(header, &index, iblock); - // Load child node and set values for the next iteration + /* Load child node and set values for the next iteration */ uint64_t child = ext4_extent_index_get_leaf(index); @@ -378,27 +375,22 @@ } - // Search extent in the leaf block + /* Search extent in the leaf block */ ext4_extent_t* extent = NULL; ext4_extent_binsearch(header, &extent, iblock); - // Prevent empty leaf + /* Prevent empty leaf */ if (extent == NULL) { *fblock = 0; } else { -// EXT4FS_DBG("required = \%u, first = \%u, start = \%u, count = \%u", iblock, ext4_extent_get_first_block(extent), (uint32_t)ext4_extent_get_start(extent), ext4_extent_get_block_count(extent)); - - // Compute requested physical block address + /* Compute requested physical block address */ uint32_t phys_block; uint32_t first = ext4_extent_get_first_block(extent); phys_block = ext4_extent_get_start(extent) + iblock - first; -// phys_block = ext4_extent_get_start(extent) + iblock; -// phys_block -= ext4_extent_get_first_block(extent); - *fblock = phys_block; } - // Cleanup + /* Cleanup */ if (block != NULL) { block_put(block); @@ -431,5 +423,5 @@ ext4_extent_path_t *tmp_path; - // Added 2 for possible tree growing + /* Added 2 for possible tree growing */ tmp_path = malloc(sizeof(ext4_extent_path_t) * (depth + 2)); if (tmp_path == NULL) { @@ -437,13 +429,13 @@ } - // Initialize structure for algorithm start + /* Initialize structure for algorithm start */ tmp_path[0].block = inode_ref->block; tmp_path[0].header = eh; - // Walk through the extent tree + /* Walk through the extent tree */ uint16_t pos = 0; while (ext4_extent_header_get_depth(eh) != 0) { - // Search index in index node by iblock + /* Search index in index node by iblock */ ext4_extent_binsearch_idx(tmp_path[pos].header, &tmp_path[pos].index, iblock); @@ -453,5 +445,5 @@ assert(tmp_path[pos].index != NULL); - // Load information for the next iteration + /* Load information for the next iteration */ uint64_t fblock = ext4_extent_index_get_leaf(tmp_path[pos].index); @@ -474,5 +466,5 @@ tmp_path[pos].index = NULL; - // Find extent in the leaf node + /* Find extent in the leaf node */ ext4_extent_binsearch(tmp_path[pos].header, &tmp_path[pos].extent, iblock); @@ -482,6 +474,7 @@ cleanup: - // Put loaded blocks - // From 1 -> 0 is a block with inode data + /* Put loaded blocks + * From 1: 0 is a block with inode data + */ for (uint16_t i = 1; i < tmp_path->depth; ++i) { if (tmp_path[i].block) { @@ -490,5 +483,5 @@ } - // Destroy temporary data structure + /* Destroy temporary data structure */ free(tmp_path); @@ -507,5 +500,5 @@ int rc; - // Compute number of the first physical block to release + /* Compute number of the first physical block to release */ uint64_t start = ext4_extent_get_start(extent); uint16_t block_count = ext4_extent_get_block_count(extent); @@ -549,9 +542,9 @@ if (ext4_extent_header_get_depth(header)) { - // The node is non-leaf, do recursion + /* The node is non-leaf, do recursion */ ext4_extent_index_t *idx = EXT4_EXTENT_FIRST_INDEX(header); - // Release all subbranches + /* Release all subbranches */ for (uint32_t i = 0; i < ext4_extent_header_get_entries_count(header); ++i, ++idx) { rc = ext4_extent_release_branch(inode_ref, idx); @@ -563,8 +556,8 @@ } else { - // Leaf node reached + /* Leaf node reached */ ext4_extent_t *ext = EXT4_EXTENT_FIRST(header); - // Release all extents and stop recursion + /* Release all extents and stop recursion */ for (uint32_t i = 0; i < ext4_extent_header_get_entries_count(header); ++i, ++ext) { @@ -577,5 +570,5 @@ } - // Release data block where the node was stored + /* Release data block where the node was stored */ rc = block_put(block); @@ -600,5 +593,5 @@ int rc = EOK; - // Find the first extent to modify + /* Find the first extent to modify */ ext4_extent_path_t *path; rc = ext4_extent_find_extent(inode_ref, iblock_from, &path); @@ -607,5 +600,5 @@ } - // Jump to last item of the path (extent) + /* Jump to last item of the path (extent) */ ext4_extent_path_t *path_ptr = path; while (path_ptr->depth != 0) { @@ -615,5 +608,5 @@ assert(path_ptr->extent != NULL); - // First extent maybe released partially + /* First extent maybe released partially */ uint32_t first_iblock = ext4_extent_get_first_block(path_ptr->extent); uint32_t first_fblock = ext4_extent_get_start(path_ptr->extent) + iblock_from - first_iblock; @@ -625,5 +618,5 @@ ext4_extent_get_start(path_ptr->extent) - first_fblock); - // Release all blocks + /* Release all blocks */ rc = ext4_balloc_free_blocks(inode_ref, first_fblock, delete_count); if (rc != EOK) { @@ -631,19 +624,19 @@ } - // Correct counter + /* Correct counter */ block_count -= delete_count; ext4_extent_set_block_count(path_ptr->extent, block_count); - // Initialize the following loop + /* Initialize the following loop */ uint16_t entries = ext4_extent_header_get_entries_count(path_ptr->header); ext4_extent_t *tmp_ext = path_ptr->extent + 1; ext4_extent_t *stop_ext = EXT4_EXTENT_FIRST(path_ptr->header) + entries; - // If first extent empty, release it + /* If first extent empty, release it */ if (block_count == 0) { entries--; } - // Release all successors of the first extent in the same node + /* Release all successors of the first extent in the same node */ while (tmp_ext < stop_ext) { first_fblock = ext4_extent_get_start(tmp_ext); @@ -662,8 +655,8 @@ path_ptr->block->dirty = true; - // If leaf node is empty, parent entry must be modified + /* If leaf node is empty, parent entry must be modified */ bool remove_parent_record = false; - // Don't release root block (including inode data) !!! + /* Don't release root block (including inode data) !!! */ if ((path_ptr != path) && (entries == 0)) { rc = ext4_balloc_free_block(inode_ref, path_ptr->block->lba); @@ -674,8 +667,8 @@ } - // Jump to the parent + /* Jump to the parent */ --path_ptr; - // release all successors in all tree levels + /* Release all successors in all tree levels */ while (path_ptr >= path) { entries = ext4_extent_header_get_entries_count(path_ptr->header); @@ -684,10 +677,10 @@ EXT4_EXTENT_FIRST_INDEX(path_ptr->header) + entries; - // Correct entries count because of changes in the previous iteration + /* Correct entries count because of changes in the previous iteration */ if (remove_parent_record) { entries--; } - // Iterate over all entries and release the whole subtrees + /* Iterate over all entries and release the whole subtrees */ while (index < stop) { rc = ext4_extent_release_branch(inode_ref, index); @@ -702,5 +695,5 @@ path_ptr->block->dirty = true; - // Free the node if it is empty + /* Free the node if it is empty */ if ((entries == 0) && (path_ptr != path)) { rc = ext4_balloc_free_block(inode_ref, path_ptr->block->lba); @@ -709,5 +702,5 @@ } - // Mark parent to be checked + /* Mark parent to be checked */ remove_parent_record = true; } else { @@ -720,6 +713,7 @@ cleanup: - // Put loaded blocks - // From 1 -> 0 is a block with inode data + /* Put loaded blocks + * starting from 1: 0 is a block with inode data + */ for (uint16_t i = 1; i <= path->depth; ++i) { if (path[i].block) { @@ -728,5 +722,5 @@ } - // Destroy temporary data structure + /* Destroy temporary data structure */ free(path); @@ -748,5 +742,4 @@ uint32_t iblock) { - EXT4FS_DBG(""); int rc; @@ -756,7 +749,6 @@ uint16_t limit = ext4_extent_header_get_max_entries_count(path_ptr->header); - // Trivial way - no splitting + /* Trivial way - no splitting */ if (entries < limit) { - EXT4FS_DBG("adding extent entry"); ext4_extent_header_set_entries_count(path_ptr->header, entries + 1); @@ -773,5 +765,5 @@ ext4_superblock_get_block_size(inode_ref->fs->superblock); - // Trivial tree - grow (extents were in root node) + /* Trivial tree - grow (extents were in root node) */ if (path_ptr == path) { @@ -793,5 +785,5 @@ memset(block->data, 0, block_size); - // Move data from root to the new block + /* Move data from root to the new block */ memcpy(block->data, inode_ref->inode->blocks, EXT4_INODE_BLOCKS * sizeof(uint32_t)); @@ -810,5 +802,5 @@ ext4_extent_header_set_max_entries_count(path_ptr->header, limit); - // Modify root (in inode) + /* Modify root (in inode) */ path->depth = 1; path->extent = NULL; @@ -829,7 +821,8 @@ } - assert(false); - - // start splitting + // TODO !!! +// assert(false); + + /* Start splitting */ uint32_t fblock = 0; while (path_ptr > path) { @@ -849,8 +842,8 @@ } - // Init block + /* Init block */ memset(block->data, 0, block_size); - // Not modified + /* Not modified */ block_put(path_ptr->block); path_ptr->block = block; @@ -867,5 +860,5 @@ } - // If splitting reached root node + /* If splitting reached root node */ if (path_ptr == path) { @@ -887,5 +880,5 @@ memset(block->data, 0, block_size); - // Move data from root to the new block + /* Move data from root to the new block */ memcpy(block->data, inode_ref->inode->blocks, EXT4_INODE_BLOCKS * sizeof(uint32_t)); @@ -904,5 +897,5 @@ ext4_extent_header_set_max_entries_count(path_ptr->header, limit); - // Modify root (in inode) + /* Modify root (in inode) */ path->depth = 1; path->extent = NULL; @@ -940,5 +933,4 @@ uint32_t *iblock, uint32_t *fblock) { - EXT4FS_DBG(""); int rc = EOK; @@ -947,5 +939,5 @@ uint32_t block_size = ext4_superblock_get_block_size(sb); - // Calculate number of new logical block + /* Calculate number of new logical block */ uint32_t new_block_idx = 0; if (inode_size > 0) { @@ -956,5 +948,5 @@ } - // Load the nearest leaf (with extent) + /* Load the nearest leaf (with extent) */ ext4_extent_path_t *path; rc = ext4_extent_find_extent(inode_ref, new_block_idx, &path); @@ -963,5 +955,5 @@ } - // Jump to last item of the path (extent) + /* Jump to last item of the path (extent) */ ext4_extent_path_t *path_ptr = path; while (path_ptr->depth != 0) { @@ -969,5 +961,5 @@ } - // Add new extent to the node if not present + /* Add new extent to the node if not present */ if (path_ptr->extent == NULL) { goto append_extent; @@ -980,9 +972,9 @@ if (block_count < block_limit) { - // There is space for new block in the extent + /* There is space for new block in the extent */ if (block_count == 0) { - // Existing extent is empty + /* Existing extent is empty */ rc = ext4_balloc_alloc_block(inode_ref, &phys_block); @@ -991,10 +983,10 @@ } - // Initialize extent + /* Initialize extent */ ext4_extent_set_first_block(path_ptr->extent, new_block_idx); ext4_extent_set_start(path_ptr->extent, phys_block); ext4_extent_set_block_count(path_ptr->extent, 1); - // Update i-node + /* Update i-node */ ext4_inode_set_size(inode_ref->inode, inode_size + block_size); inode_ref->dirty = true; @@ -1005,10 +997,10 @@ } else { - // Existing extent contains some blocks + /* Existing extent contains some blocks */ phys_block = ext4_extent_get_start(path_ptr->extent); phys_block += ext4_extent_get_block_count(path_ptr->extent); - // Check if the following block is free for allocation + /* Check if the following block is free for allocation */ bool free; rc = ext4_balloc_try_alloc_block(inode_ref, phys_block, &free); @@ -1018,13 +1010,13 @@ if (! free) { - // target is not free, new block must be appended to new extent + /* target is not free, new block must be appended to new extent */ goto append_extent; } - // Update extent + /* Update extent */ ext4_extent_set_block_count(path_ptr->extent, block_count + 1); - // Update i-node + /* Update i-node */ ext4_inode_set_size(inode_ref->inode, inode_size + block_size); inode_ref->dirty = true; @@ -1036,10 +1028,10 @@ } -// Append new extent to the tree +/* Append new extent to the tree */ append_extent: phys_block = 0; - // Allocate new data block + /* Allocate new data block */ rc = ext4_balloc_alloc_block(inode_ref, &phys_block); if (rc != EOK) { @@ -1048,5 +1040,5 @@ } - // Append extent for new block (includes tree splitting if needed) + /* Append extent for new block (includes tree splitting if needed) */ rc = ext4_extent_append_extent(inode_ref, path, &path_ptr, new_block_idx); if (rc != EOK) { @@ -1055,10 +1047,10 @@ } - // Initialize newly created extent + /* Initialize newly created extent */ ext4_extent_set_block_count(path_ptr->extent, 1); ext4_extent_set_first_block(path_ptr->extent, new_block_idx); ext4_extent_set_start(path_ptr->extent, phys_block); - // Update i-node + /* Update i-node */ ext4_inode_set_size(inode_ref->inode, inode_size + block_size); inode_ref->dirty = true; @@ -1068,10 +1060,11 @@ finish: - // Set return values + /* Set return values */ *iblock = new_block_idx; *fblock = phys_block; - // Put loaded blocks - // From 1 -> 0 is a block with inode data + /* Put loaded blocks + * starting from 1: 0 is a block with inode data + */ for (uint16_t i = 1; i <= path->depth; ++i) { if (path[i].block) { @@ -1080,5 +1073,5 @@ } - // Destroy temporary data structure + /* Destroy temporary data structure */ free(path); Index: uspace/lib/ext4/libext4_filesystem.c =================================================================== --- uspace/lib/ext4/libext4_filesystem.c (revision 49c94a3a0434b4b076957742b535ccde31846e07) +++ 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; Index: uspace/lib/ext4/libext4_ialloc.c =================================================================== --- uspace/lib/ext4/libext4_ialloc.c (revision 49c94a3a0434b4b076957742b535ccde31846e07) +++ uspace/lib/ext4/libext4_ialloc.c (revision 06d85e53f2ba96bd2ea9eae7bc274870ba1e1a85) @@ -94,5 +94,5 @@ ext4_superblock_t *sb = fs->superblock; - // Compute index of block group and load it + /* Compute index of block group and load it */ uint32_t block_group = ext4_ialloc_get_bgid_of_inode(sb, index); @@ -103,5 +103,5 @@ } - // Load i-node bitmap + /* Load i-node bitmap */ uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap( bg_ref->block_group, sb); @@ -112,18 +112,18 @@ } - // Free i-node in the bitmap + /* Free i-node in the bitmap */ uint32_t index_in_group = ext4_ialloc_inode2index_in_group(sb, index); ext4_bitmap_free_bit(bitmap_block->data, index_in_group); bitmap_block->dirty = true; - // Put back the block with bitmap + /* Put back the block with bitmap */ rc = block_put(bitmap_block); if (rc != EOK) { - // Error in saving bitmap + /* Error in saving bitmap */ ext4_filesystem_put_block_group_ref(bg_ref); return rc; } - // If released i-node is a directory, decrement used directories count + /* If released i-node is a directory, decrement used directories count */ if (is_dir) { uint32_t bg_used_dirs = ext4_block_group_get_used_dirs_count( @@ -134,5 +134,5 @@ } - // Update block group free inodes count + /* Update block group free inodes count */ uint32_t free_inodes = ext4_block_group_get_free_inodes_count( bg_ref->block_group, sb); @@ -141,5 +141,5 @@ sb, free_inodes); - // Set unused i-nodes count if supported + /* Set unused i-nodes count if supported */ if (ext4_block_group_has_flag(bg_ref->block_group, EXT4_BLOCK_GROUP_INODE_UNINIT)) { uint32_t unused_inodes = ext4_block_group_get_itable_unused( @@ -151,5 +151,5 @@ bg_ref->dirty = true; - // Put back the modified block group + /* Put back the modified block group */ rc = ext4_filesystem_put_block_group_ref(bg_ref); if (rc != EOK) { @@ -157,5 +157,5 @@ } - // Update superblock free inodes count + /* Update superblock free inodes count */ uint32_t sb_free_inodes = ext4_superblock_get_free_inodes_count(sb); sb_free_inodes++; @@ -185,8 +185,8 @@ uint32_t avg_free_inodes = sb_free_inodes / bg_count; - // Try to find free i-node in all block groups + /* Try to find free i-node in all block groups */ while (bgid < bg_count) { - // Load block group to check + /* Load block group to check */ ext4_block_group_ref_t *bg_ref; rc = ext4_filesystem_get_block_group_ref(fs, bgid, &bg_ref); @@ -197,13 +197,13 @@ ext4_block_group_t *bg = bg_ref->block_group; - // Read necessary values for algorithm + /* Read necessary values for algorithm */ uint32_t free_blocks = ext4_block_group_get_free_blocks_count(bg, sb); uint32_t free_inodes = ext4_block_group_get_free_inodes_count(bg, sb); uint32_t used_dirs = ext4_block_group_get_used_dirs_count(bg, sb); - // Check if this block group is good candidate for allocation + /* Check if this block group is good candidate for allocation */ if ((free_inodes >= avg_free_inodes) && (free_blocks > 0)) { - // Load block with bitmap + /* Load block with bitmap */ uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap( bg_ref->block_group, sb); @@ -216,5 +216,5 @@ } - // Try to allocate i-node in the bitmap + /* Try to allocate i-node in the bitmap */ uint32_t inodes_in_group = ext4_superblock_get_inodes_in_group(sb, bgid); uint32_t index_in_group; @@ -222,5 +222,5 @@ bitmap_block->data, 0, &index_in_group, inodes_in_group); - // Block group has not any free i-node + /* Block group has not any free i-node */ if (rc == ENOSPC) { block_put(bitmap_block); @@ -229,5 +229,5 @@ } - // Free i-node found, save the bitmap + /* Free i-node found, save the bitmap */ bitmap_block->dirty = true; @@ -237,9 +237,9 @@ } - // Modify filesystem counters + /* Modify filesystem counters */ free_inodes--; ext4_block_group_set_free_inodes_count(bg, sb, free_inodes); - // Decrement unused i-nodes counter if supported + /* Decrement unused i-nodes counter if supported */ if (ext4_block_group_has_flag(bg, EXT4_BLOCK_GROUP_INODE_UNINIT)) { uint16_t unused_inodes = ext4_block_group_get_itable_unused(bg, sb); @@ -248,5 +248,5 @@ } - // Increment used directories counter + /* Increment used directories counter */ if (is_dir) { used_dirs++; @@ -254,5 +254,5 @@ } - // Save modified block group + /* Save modified block group */ bg_ref->dirty = true; @@ -263,9 +263,9 @@ } - // Update superblock + /* Update superblock */ sb_free_inodes--; ext4_superblock_set_free_inodes_count(sb, sb_free_inodes); - // Compute the absolute i-nodex number + /* Compute the absolute i-nodex number */ *index = ext4_ialloc_index_in_group2inode(sb, index_in_group, bgid); @@ -274,5 +274,5 @@ } - // Block group not modified, put it and jump to the next block group + /* Block group not modified, put it and jump to the next block group */ ext4_filesystem_put_block_group_ref(bg_ref); ++bgid; Index: uspace/lib/ext4/libext4_inode.c =================================================================== --- uspace/lib/ext4/libext4_inode.c (revision 49c94a3a0434b4b076957742b535ccde31846e07) +++ uspace/lib/ext4/libext4_inode.c (revision 06d85e53f2ba96bd2ea9eae7bc274870ba1e1a85) @@ -266,5 +266,5 @@ if (ext4_superblock_has_feature_read_only(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) { - // 48-bit field + /* 48-bit field */ uint64_t count = ((uint64_t)uint16_t_le2host(inode->osd2.linux2.blocks_high)) << 32 | uint32_t_le2host(inode->blocks_count_lo); @@ -292,5 +292,5 @@ uint64_t count) { - // 32-bit maximum + /* 32-bit maximum */ uint64_t max = 0; max = ~max >> 32; @@ -303,10 +303,10 @@ } - // Check if there can be used huge files (many blocks) + /* Check if there can be used huge files (many blocks) */ if (!ext4_superblock_has_feature_read_only(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) { return EINVAL; } - // 48-bit maximum + /* 48-bit maximum */ max = 0; max = ~max >> 16; Index: uspace/lib/ext4/libext4_superblock.c =================================================================== --- uspace/lib/ext4/libext4_superblock.c (revision 49c94a3a0434b4b076957742b535ccde31846e07) +++ uspace/lib/ext4/libext4_superblock.c (revision 06d85e53f2ba96bd2ea9eae7bc274870ba1e1a85) @@ -981,5 +981,5 @@ int rc; - // Allocated memory for superblock structure + /* Allocated memory for superblock structure */ void *data = malloc(EXT4_SUPERBLOCK_SIZE); if (data == NULL) { @@ -987,5 +987,5 @@ } - // Read data from block device + /* Read data from block device */ rc = block_read_bytes_direct(service_id, EXT4_SUPERBLOCK_OFFSET, EXT4_SUPERBLOCK_SIZE, data); @@ -996,5 +996,5 @@ } - // Set output value + /* Set output value */ (*sb) = data; @@ -1014,5 +1014,5 @@ uint32_t phys_block_size; - // Load physical block size from block device + /* Load physical block size from block device */ rc = block_get_bsize(service_id, &phys_block_size); if (rc != EOK) { @@ -1020,15 +1020,15 @@ } - // Compute address of the first block + /* Compute address of the first block */ uint64_t first_block = EXT4_SUPERBLOCK_OFFSET / phys_block_size; - // Compute number of block to write + /* Compute number of block to write */ uint32_t block_count = EXT4_SUPERBLOCK_SIZE / phys_block_size; - // Check alignment + /* Check alignment */ if (EXT4_SUPERBLOCK_SIZE % phys_block_size) { block_count++; } - // Write data + /* Write data */ return block_write_direct(service_id, first_block, block_count, sb);