Index: uspace/Makefile =================================================================== --- uspace/Makefile (revision 13d5639ab7e7d19dac1eedb36e5aac468068353c) +++ uspace/Makefile (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -58,4 +58,5 @@ app/tester \ app/testread \ + app/testwrit \ app/tetris \ app/trace \ @@ -97,4 +98,5 @@ srv/fs/locfs \ srv/fs/ext2fs \ + srv/fs/ext4fs \ srv/hid/console \ srv/hid/s3c24xx_ts \ @@ -196,4 +198,5 @@ lib/nic \ lib/ext2 \ + lib/ext4 \ lib/usb \ lib/usbhost \ Index: uspace/Makefile.common =================================================================== --- uspace/Makefile.common (revision 13d5639ab7e7d19dac1eedb36e5aac468068353c) +++ uspace/Makefile.common (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -115,4 +115,5 @@ LIBEXT2_PREFIX = $(LIB_PREFIX)/ext2 +LIBEXT4_PREFIX = $(LIB_PREFIX)/ext4 LIBUSB_PREFIX = $(LIB_PREFIX)/usb Index: uspace/app/testwrit/Makefile =================================================================== --- uspace/app/testwrit/Makefile (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/app/testwrit/Makefile (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,35 @@ +# +# Copyright (c) 2011 Frantisek Princ +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +BINARY = testwrit + +SOURCES = \ + testwrit.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/testwrit/testwrit.c =================================================================== --- uspace/app/testwrit/testwrit.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/app/testwrit/testwrit.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2011 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup test + * @{ + */ + + +#include +#include + +#define BUF_SIZE 1024 + +int main(int argc, char **argv) +{ + + char buffer[BUF_SIZE]; + uint64_t iterations, i; + FILE *file; + char *file_name; + + /* Prepare some example data */ + memset(buffer, 0xcafebabe, BUF_SIZE); + + if (argc != 3) { + printf("syntax: testwrit \n"); + return 1; + } + + char *end; + iterations = strtoul(argv[1], &end, 10); + file_name = argv[2]; + + /* Open target file */ + file = fopen(file_name, "a"); + if (file == NULL) { + printf("Failed opening file\n"); + return 1; + } + + /* Writing loop */ + for (i = 0; i < iterations; ++i) { + fwrite(buffer, 1, BUF_SIZE, file); + } + + fclose(file); + + return 0; +} + + +/** + * @} + */ Index: uspace/lib/ext4/Makefile =================================================================== --- uspace/lib/ext4/Makefile (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/Makefile (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,49 @@ +# +# Copyright (c) 2012 Frantisek Princ +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBRARY = libext4 +EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBPOSIX_PREFIX) +LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBPOSIX_PREFIX)/libposix.a + +SOURCES = \ + libext4_balloc.c \ + libext4_bitmap.c \ + libext4_block_group.c \ + libext4_crc.c \ + libext4_directory.c \ + libext4_directory_index.c \ + libext4_extent.c \ + libext4_filesystem.c \ + libext4_hash.c \ + libext4_ialloc.c \ + libext4_inode.c \ + libext4_superblock.c + + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/ext4/libext4.h =================================================================== --- uspace/lib/ext4/libext4.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_H_ +#define LIBEXT4_LIBEXT4_H_ + +#include "libext4_balloc.h" +#include "libext4_bitmap.h" +#include "libext4_block_group.h" +#include "libext4_crc.h" +#include "libext4_directory.h" +#include "libext4_directory_index.h" +#include "libext4_extent.h" +#include "libext4_filesystem.h" +#include "libext4_hash.h" +#include "libext4_ialloc.h" +#include "libext4_inode.h" +#include "libext4_superblock.h" +#include "libext4_types.h" + +#include +#define EXT4FS_DBG(format, ...) {printf("ext4fs: %s: " format "\n", __FUNCTION__, ##__VA_ARGS__);} + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_balloc.c =================================================================== --- uspace/lib/ext4/libext4_balloc.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_balloc.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,675 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_balloc.c + * @brief Physical block allocator. + */ + +#include +#include +#include "libext4.h" + +/** Compute number of block group from block address. + * + * @param sb superblock pointer + * @param block_addr absolute address of block + * @return block group index + */ +static uint32_t ext4_balloc_get_bgid_of_block(ext4_superblock_t *sb, + uint32_t block_addr) +{ + uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb); + uint32_t first_block = ext4_superblock_get_first_data_block(sb); + + /* First block == 0 or 1 */ + if (first_block == 0) { + return block_addr / blocks_per_group; + } else { + return (block_addr - 1) / blocks_per_group; + } +} + +/** Free block. + * + * @param inode_ref inode, where the block is allocated + * @param block_addr absolute block address to free + * @return error code + */ +int ext4_balloc_free_block(ext4_inode_ref_t *inode_ref, uint32_t block_addr) +{ + int rc; + + ext4_filesystem_t *fs = inode_ref->fs; + ext4_superblock_t *sb = fs->superblock; + + /* Compute indexes */ + uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, block_addr); + uint32_t index_in_group = + ext4_filesystem_blockaddr2_index_in_group(sb, block_addr); + + /* Load block group reference */ + ext4_block_group_ref_t *bg_ref; + rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref); + if (rc != EOK) { + return rc; + } + + /* Load block with bitmap */ + uint32_t bitmap_block_addr = ext4_block_group_get_block_bitmap( + bg_ref->block_group, sb); + block_t *bitmap_block; + rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0); + if (rc != EOK) { + return rc; + } + + /* Modify bitmap */ + ext4_bitmap_free_bit(bitmap_block->data, index_in_group); + bitmap_block->dirty = true; + + + /* Release block with bitmap */ + rc = block_put(bitmap_block); + if (rc != EOK) { + /* Error in saving bitmap */ + ext4_filesystem_put_block_group_ref(bg_ref); + return rc; + } + + uint32_t block_size = ext4_superblock_get_block_size(sb); + + /* 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 */ + uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode); + ino_blocks -= block_size / EXT4_INODE_BLOCK_SIZE; + ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks); + inode_ref->dirty = true; + + /* Update block group free blocks count */ + uint32_t free_blocks = ext4_block_group_get_free_blocks_count( + bg_ref->block_group, sb); + free_blocks++; + ext4_block_group_set_free_blocks_count(bg_ref->block_group, + sb, free_blocks); + bg_ref->dirty = true; + + /* Release block group reference */ + rc = ext4_filesystem_put_block_group_ref(bg_ref); + if (rc != EOK) { + return rc; + } + + return EOK; +} + + +/** Free continuous set of blocks. + * + * @param inode_ref inode, where the blocks are allocated + * @param first first block to release + * @param count number of blocks to release + */ +int ext4_balloc_free_blocks(ext4_inode_ref_t *inode_ref, + uint32_t first, uint32_t count) +{ + int rc; + + ext4_filesystem_t *fs = inode_ref->fs; + ext4_superblock_t *sb = fs->superblock; + + /* Compute indexes */ + uint32_t block_group_first = + ext4_balloc_get_bgid_of_block(sb, first); + uint32_t block_group_last = + ext4_balloc_get_bgid_of_block(sb, first + count - 1); + + assert(block_group_first == block_group_last); + + /* Load block group reference */ + ext4_block_group_ref_t *bg_ref; + rc = ext4_filesystem_get_block_group_ref(fs, block_group_first, &bg_ref); + if (rc != EOK) { + return rc; + } + + uint32_t index_in_group_first = + ext4_filesystem_blockaddr2_index_in_group(sb, first); + + + /* Load block with bitmap */ + uint32_t bitmap_block_addr = ext4_block_group_get_block_bitmap( + bg_ref->block_group, sb); + + block_t *bitmap_block; + rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0); + if (rc != EOK) { + return rc; + } + + /* Modify bitmap */ + ext4_bitmap_free_bits(bitmap_block->data, index_in_group_first, count); + bitmap_block->dirty = true; + + /* Release block with bitmap */ + rc = block_put(bitmap_block); + if (rc != EOK) { + /* Error in saving bitmap */ + ext4_filesystem_put_block_group_ref(bg_ref); + return rc; + } + + uint32_t block_size = ext4_superblock_get_block_size(sb); + + /* 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 */ + uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode); + ino_blocks -= count * (block_size / EXT4_INODE_BLOCK_SIZE); + ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks); + inode_ref->dirty = true; + + /* Update block group free blocks count */ + uint32_t free_blocks = ext4_block_group_get_free_blocks_count( + bg_ref->block_group, sb); + free_blocks += count; + ext4_block_group_set_free_blocks_count(bg_ref->block_group, + sb, free_blocks); + bg_ref->dirty = true; + + /* Release block group reference */ + rc = ext4_filesystem_put_block_group_ref(bg_ref); + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** Compute first block for data in block group. + * + * @param sb pointer to superblock + * @param bg pointer to block group + * @param bgid index of block group + * @return absolute block index of first block + */ +uint32_t ext4_balloc_get_first_data_block_in_group( + ext4_superblock_t *sb, ext4_block_group_ref_t *bg_ref) +{ + 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( + bg_ref->block_group, sb); + uint16_t inode_table_item_size = ext4_superblock_get_inode_size(sb); + uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb); + uint32_t block_size = ext4_superblock_get_block_size(sb); + uint32_t inode_table_bytes; + + if (bg_ref->index < block_group_count - 1) { + inode_table_bytes = inodes_per_group * inode_table_item_size; + } else { + /* last block group could be smaller */ + uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb); + inode_table_bytes = + (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) + * inode_table_item_size; + } + + uint32_t inode_table_blocks = inode_table_bytes / block_size; + + if (inode_table_bytes % block_size) { + inode_table_blocks++; + } + + return inode_table_first_block + inode_table_blocks; +} + +/** Compute 'goal' for allocation algorithm. + * + * @param inode_ref reference to inode, to allocate block for + * @return goal block number + */ +static uint32_t ext4_balloc_find_goal(ext4_inode_ref_t *inode_ref) +{ + int rc; + uint32_t goal = 0; + + ext4_superblock_t *sb = inode_ref->fs->superblock; + + uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode); + uint32_t block_size = ext4_superblock_get_block_size(sb); + uint32_t inode_block_count = inode_size / block_size; + + if (inode_size % block_size != 0) { + inode_block_count++; + } + + /* If inode has some blocks, get last block address + 1 */ + if (inode_block_count > 0) { + + rc = ext4_filesystem_get_inode_data_block_index(inode_ref, inode_block_count - 1, &goal); + if (rc != EOK) { + return 0; + } + + if (goal != 0) { + goal++; + return goal; + } + + /* 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 */ + ext4_block_group_ref_t *bg_ref; + rc = ext4_filesystem_get_block_group_ref(inode_ref->fs, block_group, &bg_ref); + if (rc != EOK) { + return 0; + } + + /* 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( + bg_ref->block_group, sb); + uint16_t inode_table_item_size = ext4_superblock_get_inode_size(sb); + uint32_t inode_table_bytes; + + /* 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 */ + uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb); + inode_table_bytes = + (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) + * inode_table_item_size; + } + + uint32_t inode_table_blocks = inode_table_bytes / block_size; + + if (inode_table_bytes % block_size) { + inode_table_blocks++; + } + + goal = inode_table_first_block + inode_table_blocks; + + ext4_filesystem_put_block_group_ref(bg_ref); + + return goal; +} + +/** Data block allocation algorithm. + * + * @param inode_ref inode to allocate block for + * @param fblock allocated block address + * @return error code + */ +int ext4_balloc_alloc_block( + ext4_inode_ref_t *inode_ref, uint32_t *fblock) +{ + int rc; + uint32_t allocated_block = 0; + + uint32_t bitmap_block_addr; + block_t *bitmap_block; + uint32_t rel_block_idx = 0; + + /* Find GOAL */ + uint32_t goal = ext4_balloc_find_goal(inode_ref); + if (goal == 0) { + /* no goal found => partition is full */ + return ENOSPC; + } + + ext4_superblock_t *sb = inode_ref->fs->superblock; + + /* 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_filesystem_blockaddr2_index_in_group(sb, goal); + + + /* 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); + if (rc != EOK) { + return rc; + } + + /* Compute indexes */ + uint32_t first_in_group = + ext4_balloc_get_first_data_block_in_group(sb, bg_ref); + + uint32_t first_in_group_index = ext4_filesystem_blockaddr2_index_in_group( + sb, first_in_group); + + if (index_in_group < first_in_group_index) { + index_in_group = first_in_group_index; + } + + /* Load block with bitmap */ + bitmap_block_addr = ext4_block_group_get_block_bitmap( + bg_ref->block_group, sb); + + rc = block_get(&bitmap_block, inode_ref->fs->device, + bitmap_block_addr, BLOCK_FLAGS_NONE); + if (rc != EOK) { + ext4_filesystem_put_block_group_ref(bg_ref); + return rc; + } + + /* 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); + bitmap_block->dirty = true; + rc = block_put(bitmap_block); + if (rc != EOK) { + ext4_filesystem_put_block_group_ref(bg_ref); + return rc; + } + + allocated_block = ext4_filesystem_index_in_group2blockaddr( + sb, index_in_group, block_group); + + goto success; + + } + + uint32_t blocks_in_group = ext4_superblock_get_blocks_in_group(sb, block_group); + + uint32_t end_idx = (index_in_group + 63) & ~63; + if (end_idx > blocks_in_group) { + end_idx = blocks_in_group; + } + + /* 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)) { + + ext4_bitmap_set_bit(bitmap_block->data, tmp_idx); + bitmap_block->dirty = true; + rc = block_put(bitmap_block); + if (rc != EOK) { + return rc; + } + + allocated_block = ext4_filesystem_index_in_group2blockaddr( + sb, tmp_idx, block_group); + + goto success; + } + + } + + /* 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) { + bitmap_block->dirty = true; + rc = block_put(bitmap_block); + if (rc != EOK) { + return rc; + } + + allocated_block = ext4_filesystem_index_in_group2blockaddr( + sb, rel_block_idx, block_group); + + goto success; + } + + /* 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) { + bitmap_block->dirty = true; + rc = block_put(bitmap_block); + if (rc != EOK) { + return rc; + } + + allocated_block = ext4_filesystem_index_in_group2blockaddr( + sb, rel_block_idx, block_group); + + goto success; + } + + /* No free block found yet */ + block_put(bitmap_block); + ext4_filesystem_put_block_group_ref(bg_ref); + + /* Try other block groups */ + uint32_t block_group_count = ext4_superblock_get_block_group_count(sb); + + uint32_t bgid = (block_group + 1) % block_group_count; + uint32_t count = block_group_count; + + while (count > 0) { + rc = ext4_filesystem_get_block_group_ref(inode_ref->fs, bgid, &bg_ref); + if (rc != EOK) { + return rc; + } + + /* Load block with bitmap */ + bitmap_block_addr = ext4_block_group_get_block_bitmap( + bg_ref->block_group, sb); + + rc = block_get(&bitmap_block, inode_ref->fs->device, bitmap_block_addr, 0); + if (rc != EOK) { + ext4_filesystem_put_block_group_ref(bg_ref); + return rc; + } + + /* Compute indexes */ + first_in_group = ext4_balloc_get_first_data_block_in_group( + sb, bg_ref); + index_in_group = ext4_filesystem_blockaddr2_index_in_group(sb, + first_in_group); + blocks_in_group = ext4_superblock_get_blocks_in_group(sb, bgid); + + first_in_group_index = ext4_filesystem_blockaddr2_index_in_group( + sb, first_in_group); + + if (index_in_group < first_in_group_index) { + index_in_group = first_in_group_index; + } + + /* 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) { + bitmap_block->dirty = true; + rc = block_put(bitmap_block); + if (rc != EOK) { + return rc; + } + + allocated_block = ext4_filesystem_index_in_group2blockaddr( + sb, rel_block_idx, bgid); + + goto success; + } + + /* 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) { + bitmap_block->dirty = true; + rc = block_put(bitmap_block); + if (rc != EOK) { + return rc; + } + + allocated_block = ext4_filesystem_index_in_group2blockaddr( + sb, rel_block_idx, bgid); + + goto success; + } + + block_put(bitmap_block); + ext4_filesystem_put_block_group_ref(bg_ref); + + /* Goto next group */ + bgid = (bgid + 1) % block_group_count; + count--; + } + + return ENOSPC; + +success: + ; /* Empty command - because of syntax */ + + uint32_t block_size = ext4_superblock_get_block_size(sb); + + /* 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 */ + uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode); + ino_blocks += block_size / EXT4_INODE_BLOCK_SIZE; + ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks); + inode_ref->dirty = true; + + /* Update block group free blocks count */ + uint32_t bg_free_blocks = ext4_block_group_get_free_blocks_count( + bg_ref->block_group, sb); + bg_free_blocks--; + ext4_block_group_set_free_blocks_count(bg_ref->block_group, sb, bg_free_blocks); + bg_ref->dirty = true; + + ext4_filesystem_put_block_group_ref(bg_ref); + + *fblock = allocated_block; + return EOK; +} + +/** Try to allocate concrete block. + * + * @param inode_ref inode to allocate block for + * @param fblock block address to allocate + * @param free output value - if target block is free + * @return error code + */ +int ext4_balloc_try_alloc_block(ext4_inode_ref_t *inode_ref, + uint32_t fblock, bool *free) +{ + int rc = EOK; + + ext4_filesystem_t *fs = inode_ref->fs; + ext4_superblock_t *sb = fs->superblock; + + /* Compute indexes */ + uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, fblock); + uint32_t index_in_group = + ext4_filesystem_blockaddr2_index_in_group(sb, fblock); + + /* Load block group reference */ + ext4_block_group_ref_t *bg_ref; + rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref); + if (rc != EOK) { + return rc; + } + + /* Load block with bitmap */ + uint32_t bitmap_block_addr = ext4_block_group_get_block_bitmap( + bg_ref->block_group, sb); + block_t *bitmap_block; + rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0); + if (rc != EOK) { + return rc; + } + + /* Check if block is free */ + *free = ext4_bitmap_is_free_bit(bitmap_block->data, index_in_group); + + /* Allocate block if possible */ + if (*free) { + ext4_bitmap_set_bit(bitmap_block->data, index_in_group); + bitmap_block->dirty = true; + } + + /* Release block with bitmap */ + rc = block_put(bitmap_block); + if (rc != EOK) { + /* Error in saving bitmap */ + ext4_filesystem_put_block_group_ref(bg_ref); + return rc; + } + + /* If block is not free, return */ + if (!(*free)) { + goto terminate; + } + + uint32_t block_size = ext4_superblock_get_block_size(sb); + + /* 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 */ + uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode); + ino_blocks += block_size / EXT4_INODE_BLOCK_SIZE; + ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks); + inode_ref->dirty = true; + + /* Update block group free blocks count */ + uint32_t free_blocks = ext4_block_group_get_free_blocks_count( + bg_ref->block_group, sb); + free_blocks--; + ext4_block_group_set_free_blocks_count(bg_ref->block_group, + sb, free_blocks); + bg_ref->dirty = true; + +terminate: + + rc = ext4_filesystem_put_block_group_ref(bg_ref); + if (rc != EOK) { + return rc; + } + + return rc; +} + +/** + * @} + */ Index: uspace/lib/ext4/libext4_balloc.h =================================================================== --- uspace/lib/ext4/libext4_balloc.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_balloc.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_BALLOC_H_ +#define LIBEXT4_LIBEXT4_BALLOC_H_ + +#include +#include "libext4_types.h" + +extern int ext4_balloc_free_block(ext4_inode_ref_t *, uint32_t); +extern int ext4_balloc_free_blocks(ext4_inode_ref_t *, + uint32_t , uint32_t); +extern uint32_t ext4_balloc_get_first_data_block_in_group( + ext4_superblock_t *, ext4_block_group_ref_t *); +extern int ext4_balloc_alloc_block(ext4_inode_ref_t *, uint32_t *); +extern int ext4_balloc_try_alloc_block(ext4_inode_ref_t *, uint32_t, bool *); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_bitmap.c =================================================================== --- uspace/lib/ext4/libext4_bitmap.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_bitmap.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,270 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_bitmap.c + * @brief Ext4 bitmap operations. + */ + +#include +#include +#include +#include "libext4.h" + +/** Set bit in bitmap to 0 (free). + * + * Index must be checked by caller, if it's not out of bounds. + * + * @param bitmap pointer to bitmap + * @param index index of bit in bitmap + */ +void ext4_bitmap_free_bit(uint8_t *bitmap, uint32_t index) +{ + uint32_t byte_index = index / 8; + uint32_t bit_index = index % 8; + + uint8_t *target = bitmap + byte_index; + + *target &= ~ (1 << bit_index); +} + +/** Free continous set of bits (set to 0). + * + * Index and count must be checked by caller, if they aren't out of bounds. + * + * @param bitmap pointer to bitmap + * @param index index of first bit to zeroed + * @param count number of bits to be zeroed + */ +void ext4_bitmap_free_bits(uint8_t *bitmap, uint32_t index, uint32_t count) +{ + uint8_t *target; + uint32_t idx = index; + uint32_t remaining = count; + uint32_t byte_index; + + /* Align index to multiple of 8 */ + while (((idx % 8) != 0) && (remaining > 0)) { + + byte_index = idx / 8; + uint32_t bit_index = idx % 8; + + target = bitmap + byte_index; + + *target &= ~ (1 << bit_index); + + idx++; + remaining--; + } + + /* For < 8 bits this check necessary */ + if (remaining == 0) { + return; + } + + assert((idx % 8) == 0); + + byte_index = idx / 8; + target = bitmap + byte_index; + + /* Zero the whole bytes */ + while (remaining >= 8) { + *target = 0; + + idx += 8; + remaining -= 8; + target++; + } + + assert(remaining < 8); + + /* Zero remaining bytes */ + while (remaining != 0) { + + byte_index = idx / 8; + uint32_t bit_index = idx % 8; + + target = bitmap + byte_index; + + *target &= ~ (1 << bit_index); + + idx++; + remaining--; + } +} + +/** Set bit in bitmap to 1 (used). + * + * @param bitmap pointer to bitmap + * @param index index of bit to set + */ +void ext4_bitmap_set_bit(uint8_t *bitmap, uint32_t index) +{ + uint32_t byte_index = index / 8; + uint32_t bit_index = index % 8; + + uint8_t *target = bitmap + byte_index; + + *target |= 1 << bit_index; +} + +/** Check if requested bit is free. + * + * @param bitmap pointer to bitmap + * @param index index of bit to be checked + * @return true if bit is free, else false + */ +bool ext4_bitmap_is_free_bit(uint8_t *bitmap, uint32_t index) +{ + uint32_t byte_index = index / 8; + uint32_t bit_index = index % 8; + + uint8_t *target = bitmap + byte_index; + + if (*target & (1 << bit_index)) { + return false; + } else { + return true; + } + +} + +/** Try to find free byte and set the first bit as used. + * + * Walk through bitmap and try to find free byte ( == 0). + * If byte found, set the first bit as used. + * + * @param bitmap pointer to bitmap + * @param start index of bit, where the algorithm will begin + * @param index output value - index of bit (if found free byte) + * @param max maximum index of bit in bitmap + * @return error code + */ +int ext4_bitmap_find_free_byte_and_set_bit(uint8_t *bitmap, uint32_t start, uint32_t *index, uint32_t max) +{ + uint32_t idx; + + /* Align idx */ + if (start % 8) { + idx = start + (8 - (start % 8)); + } else { + idx = start; + } + + uint8_t *pos = bitmap + (idx / 8); + + /* Try to find free byte */ + while (idx < max) { + + if (*pos == 0) { + *pos |= 1; + + *index = idx; + return EOK; + } + + idx += 8; + ++pos; + } + + /* Free byte not found */ + return ENOSPC; +} + +/** Try to find free bit and set it as used (1). + * + * Walk through bitmap and try to find any free bit. + * + * @param bitmap pointer to bitmap + * @param start_idx index of bit, where algorithm will begin + * @param index output value - index of set bit (if found) + * @param max maximum index of bit in bitmap + * @return error code + */ +int ext4_bitmap_find_free_bit_and_set(uint8_t *bitmap, uint32_t start_idx, + uint32_t *index, uint32_t max) +{ + uint8_t *pos = bitmap + (start_idx / 8); + uint32_t idx = start_idx; + bool byte_part = false; + + /* Check the rest of first byte */ + while ((idx % 8) != 0) { + byte_part = true; + + if ((*pos & (1 << (idx % 8))) == 0) { + *pos |= (1 << (idx % 8)); + *index = idx; + return EOK; + } + + ++idx; + } + + if (byte_part) { + ++pos; + } + + /* Check the whole bytes (255 = 11111111 binary) */ + while (idx < max) { + + if ((*pos & 255) != 255) { + /* free bit found */ + break; + } + + idx += 8; + ++pos; + } + + /* If idx < max, some free bit found */ + if (idx < max) { + + /* Check which bit from byte is free */ + for (uint8_t i = 0; i < 8; ++i) { + if ((*pos & (1 << i)) == 0) { + /* free bit found */ + *pos |= (1 << i); + *index = idx; + return EOK; + } + idx++; + } + } + + /* Free bit not found */ + return ENOSPC; +} + +/** + * @} + */ Index: uspace/lib/ext4/libext4_bitmap.h =================================================================== --- uspace/lib/ext4/libext4_bitmap.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_bitmap.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_BITMAP_H_ +#define LIBEXT4_LIBEXT4_BITMAP_H_ + +#include + +extern void ext4_bitmap_free_bit(uint8_t *, uint32_t); +extern void ext4_bitmap_free_bits(uint8_t *, uint32_t, uint32_t); +extern void ext4_bitmap_set_bit(uint8_t *, uint32_t); +extern bool ext4_bitmap_is_free_bit(uint8_t *, uint32_t); +extern int ext4_bitmap_find_free_byte_and_set_bit(uint8_t *, uint32_t, + uint32_t *, uint32_t); +extern int ext4_bitmap_find_free_bit_and_set(uint8_t *, uint32_t, + uint32_t *, uint32_t); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_block_group.c =================================================================== --- uspace/lib/ext4/libext4_block_group.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_block_group.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,357 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_block_group.c + * @brief Ext4 block group structure operations. + */ + +#include +#include "libext4.h" + +/** Get address of block with data block bitmap. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @return address of block with block bitmap + */ +uint64_t ext4_block_group_get_block_bitmap(ext4_block_group_t *bg, + ext4_superblock_t *sb) +{ + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + return ((uint64_t)uint32_t_le2host(bg->block_bitmap_hi) << 32) | + uint32_t_le2host(bg->block_bitmap_lo); + } else { + return uint32_t_le2host(bg->block_bitmap_lo); + } +} + +/** Set address of block with data block bitmap. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @param block_bitmap address of block with block bitmap + */ +void ext4_block_group_set_block_bitmap(ext4_block_group_t *bg, + ext4_superblock_t *sb, uint64_t block_bitmap) +{ + bg->block_bitmap_lo = host2uint32_t_le((block_bitmap << 32) >> 32); + + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + bg->block_bitmap_hi = host2uint32_t_le(block_bitmap >> 32); + } +} + +/** Get address of block with i-node bitmap. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @return address of block with i-node bitmap + */ +uint64_t ext4_block_group_get_inode_bitmap(ext4_block_group_t *bg, + ext4_superblock_t *sb) +{ + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + return ((uint64_t)uint32_t_le2host(bg->inode_bitmap_hi) << 32) | + uint32_t_le2host(bg->inode_bitmap_lo); + } else { + return uint32_t_le2host(bg->inode_bitmap_lo); + } + +} + +/** Set address of block with i-node bitmap. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @param inode_bitmap address of block with i-node bitmap + */ +void ext4_block_group_set_inode_bitmap(ext4_block_group_t *bg, + ext4_superblock_t *sb, uint64_t inode_bitmap) +{ + bg->inode_bitmap_lo = host2uint32_t_le((inode_bitmap << 32) >> 32); + + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + bg->inode_bitmap_hi = host2uint32_t_le(inode_bitmap >> 32); + } +} + +/** Get address of the first block of the i-node table. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @return address of first block of i-node table + */ +uint64_t ext4_block_group_get_inode_table_first_block(ext4_block_group_t *bg, + ext4_superblock_t *sb) +{ + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + return ((uint64_t)uint32_t_le2host(bg->inode_table_first_block_hi) << 32) | + uint32_t_le2host(bg->inode_table_first_block_lo); + } else { + return uint32_t_le2host(bg->inode_table_first_block_lo); + } +} + +/** Set address of the first block of the i-node table. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @param inode_table_first address of first block of i-node table + */ +void ext4_block_group_set_inode_table_first_block(ext4_block_group_t *bg, + ext4_superblock_t *sb, uint64_t inode_table_first) +{ + bg->inode_table_first_block_lo = + host2uint32_t_le((inode_table_first << 32) >> 32); + + if (ext4_superblock_get_desc_size(sb) > + EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + + bg->inode_table_first_block_hi = + host2uint32_t_le(inode_table_first >> 32); + } +} + +/** Get number of free blocks in block group. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @return number of free blocks in block group + */ +uint32_t ext4_block_group_get_free_blocks_count(ext4_block_group_t *bg, + ext4_superblock_t *sb) +{ + if (ext4_superblock_get_desc_size(sb) > + EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + + return ((uint32_t)uint16_t_le2host(bg->free_blocks_count_hi) << 16) | + uint16_t_le2host(bg->free_blocks_count_lo); + } else { + return uint16_t_le2host(bg->free_blocks_count_lo); + } +} + +/** Set number of free blocks in block group. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @param value number of free blocks in block group + */ +void ext4_block_group_set_free_blocks_count(ext4_block_group_t *bg, + ext4_superblock_t *sb, uint32_t value) +{ + bg->free_blocks_count_lo = host2uint16_t_le((value << 16) >> 16); + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + bg->free_blocks_count_hi = host2uint16_t_le(value >> 16); + } +} + +/** Get number of free i-nodes in block group. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @return number of free i-nodes in block group + */ +uint32_t ext4_block_group_get_free_inodes_count(ext4_block_group_t *bg, + ext4_superblock_t *sb) +{ + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + return ((uint32_t)uint16_t_le2host(bg->free_inodes_count_hi) << 16) | + uint16_t_le2host(bg->free_inodes_count_lo); + } else { + return uint16_t_le2host(bg->free_inodes_count_lo); + } +} + +/** Set number of free i-nodes in block group. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @param value number of free i-nodes in block group + */ +void ext4_block_group_set_free_inodes_count(ext4_block_group_t *bg, + ext4_superblock_t *sb, uint32_t value) +{ + bg->free_inodes_count_lo = host2uint16_t_le((value << 16) >> 16); + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + bg->free_inodes_count_hi = host2uint16_t_le(value >> 16); + } +} + +/** Get number of used directories in block group. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @return number of used directories in block group + */ +uint32_t ext4_block_group_get_used_dirs_count(ext4_block_group_t *bg, + ext4_superblock_t *sb) +{ + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + return ((uint32_t)uint16_t_le2host(bg->used_dirs_count_hi) << 16) | + uint16_t_le2host(bg->used_dirs_count_lo); + } else { + return uint16_t_le2host(bg->used_dirs_count_lo); + } +} + +/** Set number of used directories in block group. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @param value number of used directories in block group + */ +void ext4_block_group_set_used_dirs_count(ext4_block_group_t *bg, + ext4_superblock_t *sb, uint32_t count) +{ + bg->used_dirs_count_lo = host2uint16_t_le((count << 16) >> 16); + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + bg->used_dirs_count_hi = host2uint16_t_le(count >> 16); + } +} + +/** Get flags of block group. + * + * @param bg pointer to block group + * @return flags of block group + */ +uint16_t ext4_block_group_get_flags(ext4_block_group_t *bg) +{ + return uint16_t_le2host(bg->flags); +} + +/** Set flags for block group. + * + * @param bg pointer to block group + * @param flags flags for block group + */ +void ext4_block_group_set_flags(ext4_block_group_t *bg, uint16_t flags) +{ + bg->flags = host2uint16_t_le(flags); +} + +/** Get number of unused i-nodes. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @return number of unused i-nodes + */ +uint32_t ext4_block_group_get_itable_unused(ext4_block_group_t *bg, + ext4_superblock_t *sb) +{ + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + return ((uint32_t)uint16_t_le2host(bg->itable_unused_hi) << 16) | + uint16_t_le2host(bg->itable_unused_lo); + } else { + return uint16_t_le2host(bg->itable_unused_lo); + } +} + +/** Set number of unused i-nodes. + * + * @param bg pointer to block group + * @param sb pointer to superblock + * @param value number of unused i-nodes + */ +void ext4_block_group_set_itable_unused(ext4_block_group_t *bg, + ext4_superblock_t *sb, uint32_t value) +{ + bg->itable_unused_lo = host2uint16_t_le((value << 16) >> 16); + if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + bg->itable_unused_hi = host2uint16_t_le(value >> 16); + } + +} + +/** Get checksum of block group. + * + * @param bg pointer to block group + * @return checksum of block group + */ +uint16_t ext4_block_group_get_checksum(ext4_block_group_t *bg) +{ + return uint16_t_le2host(bg->checksum); +} + +/** Set checksum of block group. + * + * @param bg pointer to block group + * @param checksum cheksum of block group + */ +void ext4_block_group_set_checksum(ext4_block_group_t *bg, uint16_t checksum) +{ + bg->checksum = host2uint16_t_le(checksum); +} + +/** Check if block group has a flag. + * + * @param bg pointer to block group + * @param flag flag to be checked + * @return true if flag is set to 1 + */ +bool ext4_block_group_has_flag(ext4_block_group_t *bg, uint32_t flag) +{ + if (ext4_block_group_get_flags(bg) & flag) { + return true; + } + return false; +} + +/** Set (add) flag of block group. + * + * @param bg pointer to block group + * @param flag flag to be set + */ +void ext4_block_group_set_flag(ext4_block_group_t *bg, uint32_t set_flag) +{ + uint32_t flags = ext4_block_group_get_flags(bg); + flags = flags | set_flag; + ext4_block_group_set_flags(bg, flags); +} + +/** Clear (remove) flag of block group. + * + * @param bg pointer to block group + * @param flag flag to be cleared + */ +void ext4_block_group_clear_flag(ext4_block_group_t *bg, uint32_t clear_flag) +{ + uint32_t flags = ext4_block_group_get_flags(bg); + flags = flags & (~clear_flag); + ext4_block_group_set_flags(bg, flags); +} + + +/** + * @} + */ Index: uspace/lib/ext4/libext4_block_group.h =================================================================== --- uspace/lib/ext4/libext4_block_group.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_block_group.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_BLOCK_GROUP_H_ +#define LIBEXT4_LIBEXT4_BLOCK_GROUP_H_ + +#include +#include +#include "libext4_types.h" + +extern uint64_t ext4_block_group_get_block_bitmap(ext4_block_group_t *, + ext4_superblock_t *); +extern void ext4_block_group_set_block_bitmap(ext4_block_group_t *, + ext4_superblock_t *, uint64_t); +extern uint64_t ext4_block_group_get_inode_bitmap(ext4_block_group_t *, + ext4_superblock_t *); +extern void ext4_block_group_set_inode_bitmap(ext4_block_group_t *, + ext4_superblock_t *, uint64_t); +extern uint64_t ext4_block_group_get_inode_table_first_block( + ext4_block_group_t *, ext4_superblock_t *); +extern void ext4_block_group_set_inode_table_first_block( + ext4_block_group_t *, ext4_superblock_t *, uint64_t); +extern uint32_t ext4_block_group_get_free_blocks_count(ext4_block_group_t *, + ext4_superblock_t *); +extern void ext4_block_group_set_free_blocks_count(ext4_block_group_t *, + ext4_superblock_t *, uint32_t); +extern uint32_t ext4_block_group_get_free_inodes_count(ext4_block_group_t *, + ext4_superblock_t *); +extern void ext4_block_group_set_free_inodes_count(ext4_block_group_t *, + ext4_superblock_t *, uint32_t); +extern void ext4_block_group_set_free_inodes_count(ext4_block_group_t *, + ext4_superblock_t *, uint32_t); +extern uint32_t ext4_block_group_get_used_dirs_count(ext4_block_group_t *, + ext4_superblock_t *); +extern void ext4_block_group_set_used_dirs_count(ext4_block_group_t *, + ext4_superblock_t *, uint32_t); +extern uint16_t ext4_block_group_get_flags(ext4_block_group_t *); +extern void ext4_block_group_set_flags(ext4_block_group_t *, uint16_t); +extern uint32_t ext4_block_group_get_itable_unused(ext4_block_group_t *, + ext4_superblock_t *); +extern void ext4_block_group_set_itable_unused(ext4_block_group_t *, + ext4_superblock_t *, uint32_t); +extern uint16_t ext4_block_group_get_checksum(ext4_block_group_t *); +extern void ext4_block_group_set_checksum(ext4_block_group_t *, uint16_t); + +extern bool ext4_block_group_has_flag(ext4_block_group_t *, uint32_t); +extern void ext4_block_group_set_flag(ext4_block_group_t *, uint32_t); +extern void ext4_block_group_clear_flag(ext4_block_group_t *, uint32_t); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_crc.c =================================================================== --- uspace/lib/ext4/libext4_crc.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_crc.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_crc.c + * @brief CRC checksumming implementation from Linux. + */ + +#include +#include "libext4.h" + +/** CRC table for the CRC-16. + * + * The poly is 0x8005 (x^16 + x^15 + x^2 + 1). + * + */ +uint16_t const crc16_table[256] = { + 0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, + 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, + 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, + 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, + 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, + 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, + 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, + 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, + 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, + 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, + 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, + 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, + 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, + 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, + 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, + 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, + 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, + 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, + 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, + 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, + 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, + 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, + 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640, + 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, + 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, + 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, + 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, + 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, + 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, + 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, + 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, + 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040 +}; + +/** Modify CRC value. + * + * @param crc current CRC value + * @param data new byte of data to be "added" to CRC + * @return updated CRC value + */ +static inline uint16_t crc16_byte(uint16_t crc, const uint8_t data) +{ + return (crc >> 8) ^ crc16_table[(crc ^ data) & 0xff]; +} + +/** Compute the CRC-16 for the data buffer. + * + * @param crc previous CRC value + * @param buffer data pointer + * @param len number of bytes in the buffer + * @return updated CRC value + */ +uint16_t crc16(uint16_t crc, const uint8_t *buffer, size_t len) +{ + while (len--) { + crc = crc16_byte(crc, *buffer++); + } + return crc; +} + + +/** + * @} + */ Index: uspace/lib/ext4/libext4_crc.h =================================================================== --- uspace/lib/ext4/libext4_crc.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_crc.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_CRC_H_ +#define LIBEXT4_LIBEXT4_CRC_H_ + +extern uint16_t crc16(uint16_t, const uint8_t *, size_t); +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_directory.c =================================================================== --- uspace/lib/ext4/libext4_directory.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_directory.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,782 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_directory.c + * @brief Ext4 directory structure operations. + */ + +#include +#include +#include +#include +#include "libext4.h" + + +/** Get i-node number from directory entry. + * + * @param de directory entry + * @return i-node number + */ +uint32_t ext4_directory_entry_ll_get_inode(ext4_directory_entry_ll_t *de) +{ + return uint32_t_le2host(de->inode); +} + +/** Set i-node number to directory entry. + * + * @param de directory entry + * @param inode i-node number + */ +void ext4_directory_entry_ll_set_inode(ext4_directory_entry_ll_t *de, + uint32_t inode) +{ + de->inode = host2uint32_t_le(inode); +} + +/** Get directory entry length. + * + * @param de directory entry + * @return entry length + */ +uint16_t ext4_directory_entry_ll_get_entry_length( + ext4_directory_entry_ll_t *de) +{ + return uint16_t_le2host(de->entry_length); +} + +/** Set directory entry length. + * + * @param de directory entry + * @param length entry length + */ + +void ext4_directory_entry_ll_set_entry_length(ext4_directory_entry_ll_t *de, + uint16_t length) +{ + de->entry_length = host2uint16_t_le(length); +} + +/** Get directory entry name length. + * + * @param sb superblock + * @param de directory entry + * @return entry name length + */ +uint16_t ext4_directory_entry_ll_get_name_length( + ext4_superblock_t *sb, ext4_directory_entry_ll_t *de) +{ + if (ext4_superblock_get_rev_level(sb) == 0 && + ext4_superblock_get_minor_rev_level(sb) < 5) { + + return ((uint16_t)de->name_length_high) << 8 | + ((uint16_t)de->name_length); + + } + return de->name_length; + +} + +/** Set directory entry name length. + * + * @param sb superblock + * @param de directory entry + * @param length entry name length + */ +void ext4_directory_entry_ll_set_name_length(ext4_superblock_t *sb, + ext4_directory_entry_ll_t *de, uint16_t length) +{ + de->name_length = (length << 8) >> 8; + + if (ext4_superblock_get_rev_level(sb) == 0 && + ext4_superblock_get_minor_rev_level(sb) < 5) { + + de->name_length_high = length >> 8; + } +} + +/** Get i-node type of directory entry. + * + * @param sb superblock + * @param de directory entry + * @return i-node type (file, dir, etc.) + */ +uint8_t ext4_directory_entry_ll_get_inode_type( + ext4_superblock_t *sb, ext4_directory_entry_ll_t *de) +{ + if (ext4_superblock_get_rev_level(sb) > 0 || + ext4_superblock_get_minor_rev_level(sb) >= 5) { + + return de->inode_type; + } + + return EXT4_DIRECTORY_FILETYPE_UNKNOWN; + +} + +/** Set i-node type of directory entry. + * + * @param sb superblock + * @param de directory entry + * @param type i-node type (file, dir, etc.) + */ +void ext4_directory_entry_ll_set_inode_type( + ext4_superblock_t *sb, ext4_directory_entry_ll_t *de, uint8_t type) +{ + if (ext4_superblock_get_rev_level(sb) > 0 || + ext4_superblock_get_minor_rev_level(sb) >= 5) { + + de->inode_type = type; + } + + /* else do nothing */ + +} + +static int ext4_directory_iterator_seek( + ext4_directory_iterator_t *, aoff64_t); +static int ext4_directory_iterator_set( + ext4_directory_iterator_t *, uint32_t); + + +/** Initialize directory iterator. + * + * Set position to the first valid entry from the required position. + * + * @param it pointer to iterator to be initialized + * @param inode_ref directory i-node + * @param pos position to start reading entries from + * @return error code + */ +int ext4_directory_iterator_init(ext4_directory_iterator_t *it, + ext4_inode_ref_t *inode_ref, aoff64_t pos) +{ + it->inode_ref = inode_ref; + it->current = NULL; + it->current_offset = 0; + it->current_block = NULL; + + return ext4_directory_iterator_seek(it, pos); +} + +/** Jump to the next valid entry + * + * @param it initialized iterator + * @return error code + */ +int ext4_directory_iterator_next(ext4_directory_iterator_t *it) +{ + uint16_t skip; + + assert(it->current != NULL); + + skip = ext4_directory_entry_ll_get_entry_length(it->current); + + return ext4_directory_iterator_seek(it, it->current_offset + skip); +} + +/** Seek to next valid directory entry. + * + * Here can be jumped to the next data block. + * + * @param it initialized iterator + * @param pos position of the next entry + * @return error code + */ +int ext4_directory_iterator_seek(ext4_directory_iterator_t *it, aoff64_t pos) +{ + int rc; + + uint64_t size = ext4_inode_get_size( + it->inode_ref->fs->superblock, it->inode_ref->inode); + + /* The iterator is not valid until we seek to the desired position */ + it->current = NULL; + + /* Are we at the end? */ + if (pos >= size) { + if (it->current_block) { + rc = block_put(it->current_block); + it->current_block = NULL; + if (rc != EOK) { + return rc; + } + } + + it->current_offset = pos; + return EOK; + } + + /* Compute next block address */ + uint32_t block_size = ext4_superblock_get_block_size( + it->inode_ref->fs->superblock); + aoff64_t current_block_idx = it->current_offset / block_size; + aoff64_t next_block_idx = pos / block_size; + + /* If we don't have a block or are moving accross block boundary, + * we need to get another block + */ + if (it->current_block == NULL || current_block_idx != next_block_idx) { + if (it->current_block) { + rc = block_put(it->current_block); + it->current_block = NULL; + if (rc != EOK) { + return rc; + } + } + + uint32_t next_block_phys_idx; + rc = ext4_filesystem_get_inode_data_block_index(it->inode_ref, + next_block_idx, &next_block_phys_idx); + if (rc != EOK) { + return rc; + } + + rc = block_get(&it->current_block, it->inode_ref->fs->device, + next_block_phys_idx, BLOCK_FLAGS_NONE); + if (rc != EOK) { + it->current_block = NULL; + return rc; + } + } + + it->current_offset = pos; + + return ext4_directory_iterator_set(it, block_size); +} + +/** Do some checks before returning iterator. + * + * @param it iterator to be checked + * @param block_size size of data block + * @return error code + */ +static int ext4_directory_iterator_set(ext4_directory_iterator_t *it, + uint32_t block_size) +{ + + it->current = NULL; + + uint32_t offset_in_block = it->current_offset % block_size; + + /* Ensure proper alignment */ + if ((offset_in_block % 4) != 0) { + return EIO; + } + + /* Ensure that the core of the entry does not overflow the block */ + if (offset_in_block > block_size - 8) { + return EIO; + } + + ext4_directory_entry_ll_t *entry = it->current_block->data + offset_in_block; + + /* Ensure that the whole entry does not overflow the block */ + uint16_t length = ext4_directory_entry_ll_get_entry_length(entry); + if (offset_in_block + length > block_size) { + return EIO; + } + + /* Ensure the name length is not too large */ + if (ext4_directory_entry_ll_get_name_length(it->inode_ref->fs->superblock, + entry) > length-8) { + return EIO; + } + + /* Everything OK - "publish" the entry */ + it->current = entry; + return EOK; +} + + +/** Uninitialize directory iterator. + * + * Release all allocated structures. + * + * @param it iterator to be finished + * @return error code + */ +int ext4_directory_iterator_fini(ext4_directory_iterator_t *it) +{ + int rc; + + it->inode_ref = NULL; + it->current = NULL; + + if (it->current_block) { + rc = block_put(it->current_block); + if (rc != EOK) { + return rc; + } + } + + return EOK; +} + +/** Write directory entry to concrete data block. + * + * @param sb superblock + * @param entry pointer to entry to be written + * @param entry_len lenght of new entry + * @param child child i-node to be written to new entry + * @param name name of the new entry + * @param name_len length of entry name + */ +void ext4_directory_write_entry(ext4_superblock_t *sb, + ext4_directory_entry_ll_t *entry, uint16_t entry_len, + ext4_inode_ref_t *child, const char *name, size_t name_len) +{ + + /* Check maximum entry length */ + uint32_t block_size = ext4_superblock_get_block_size(sb); + assert(entry_len <= block_size); + + /* 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 */ + memcpy(entry->name, name, name_len); + + /* Set type of entry */ + if (ext4_inode_is_type(sb, child->inode, EXT4_INODE_MODE_DIRECTORY)) { + ext4_directory_entry_ll_set_inode_type( + sb, entry, EXT4_DIRECTORY_FILETYPE_DIR); + } else { + ext4_directory_entry_ll_set_inode_type( + sb, entry, EXT4_DIRECTORY_FILETYPE_REG_FILE); + } + +} + +/** Add new entry to the directory. + * + * @param parent directory i-node + * @param name name of new entry + * @param child i-node to be referenced from new entry + * @return error code + */ +int ext4_directory_add_entry(ext4_inode_ref_t * parent, + const char *name, ext4_inode_ref_t *child) +{ + int rc; + + ext4_filesystem_t *fs = parent->fs; + + /* 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)) { + + rc = ext4_directory_dx_add_entry(parent, child, name); + + /* Check if index is not corrupted */ + if (rc != EXT4_ERR_BAD_DX_DIR) { + + if (rc != EOK) { + return rc; + } + + return EOK; + } + + /* Needed to clear dir index flag if corrupted */ + ext4_inode_clear_flag(parent->inode, EXT4_INODE_FLAG_INDEX); + parent->dirty = true; + } + + /* Linear algorithm */ + + uint32_t iblock = 0, fblock = 0; + uint32_t block_size = ext4_superblock_get_block_size(fs->superblock); + uint32_t inode_size = ext4_inode_get_size(fs->superblock, parent->inode); + uint32_t total_blocks = inode_size / block_size; + + uint32_t name_len = strlen(name); + + /* Find block, where is space for new entry and try to add */ + bool success = false; + for (iblock = 0; iblock < total_blocks; ++iblock) { + + rc = ext4_filesystem_get_inode_data_block_index(parent, iblock, &fblock); + if (rc != EOK) { + return rc; + } + + block_t *block; + rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + /* If adding is successful, function can finish */ + rc = ext4_directory_try_insert_entry(fs->superblock, block, child, name, name_len); + if (rc == EOK) { + success = true; + } + + rc = block_put(block); + if (rc != EOK) { + return rc; + } + + if (success) { + return EOK; + } + } + + /* No free block found - needed to allocate next data block */ + + iblock = 0; + fblock = 0; + rc = ext4_filesystem_append_inode_block(parent, &fblock, &iblock); + if (rc != EOK) { + return rc; + } + + /* Load new block */ + block_t *new_block; + rc = block_get(&new_block, fs->device, fblock, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + return rc; + } + + /* 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 */ + new_block->dirty = true; + rc = block_put(new_block); + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** Find directory entry with passed name. + * + * @param result result structure to be returned if entry found + * @param parent directory i-node + * @param name name of entry to be found + * @return error code + */ +int ext4_directory_find_entry(ext4_directory_search_result_t *result, + ext4_inode_ref_t *parent, const char *name) +{ + int rc; + uint32_t name_len = strlen(name); + + ext4_superblock_t *sb = parent->fs->superblock; + + /* Index search */ + if (ext4_superblock_has_feature_compatible(sb, EXT4_FEATURE_COMPAT_DIR_INDEX) && + ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX)) { + + rc = ext4_directory_dx_find_entry(result, parent, name_len, name); + + /* Check if index is not corrupted */ + if (rc != EXT4_ERR_BAD_DX_DIR) { + + if (rc != EOK) { + return rc; + } + return EOK; + } + + /* Needed to clear dir index flag if corrupted */ + ext4_inode_clear_flag(parent->inode, EXT4_INODE_FLAG_INDEX); + parent->dirty = true; + + } + + /* Linear algorithm */ + + uint32_t iblock, fblock; + uint32_t block_size = ext4_superblock_get_block_size(sb); + uint32_t inode_size = ext4_inode_get_size(sb, parent->inode); + uint32_t total_blocks = inode_size / block_size; + + /* Walk through all data blocks */ + for (iblock = 0; iblock < total_blocks; ++iblock) { + + /* Load block address */ + rc = ext4_filesystem_get_inode_data_block_index(parent, iblock, &fblock); + if (rc != EOK) { + return rc; + } + + /* Load data block */ + block_t *block; + rc = block_get(&block, parent->fs->device, fblock, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + /* 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); + if (rc == EOK) { + result->block = block; + result->dentry = res_entry; + return EOK; + } + + /* Entry not found - put block and continue to the next block */ + + rc = block_put(block); + if (rc != EOK) { + return rc; + } + } + + /* Entry was not found */ + + result->block = NULL; + result->dentry = NULL; + + return ENOENT; +} + + +/** Remove directory entry. + * + * @param parent directory i-node + * @param name name of the entry to be removed + * @return error code + */ +int ext4_directory_remove_entry(ext4_inode_ref_t *parent, const char *name) +{ + int rc; + + /* Check if removing from directory */ + if (!ext4_inode_is_type(parent->fs->superblock, parent->inode, + EXT4_INODE_MODE_DIRECTORY)) { + return ENOTDIR; + } + + /* Try to find entry */ + ext4_directory_search_result_t result; + rc = ext4_directory_find_entry(&result, parent, name); + if (rc != EOK) { + return rc; + } + + /* Invalidate entry */ + ext4_directory_entry_ll_set_inode(result.dentry, 0); + + /* 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 (pos != 0) { + + uint32_t offset = 0; + + /* 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 */ + while ((offset + tmp_dentry_length) < pos) { + offset += ext4_directory_entry_ll_get_entry_length(tmp_dentry); + tmp_dentry = result.block->data + offset; + tmp_dentry_length = + ext4_directory_entry_ll_get_entry_length(tmp_dentry); + } + + assert(tmp_dentry_length + offset == pos); + + /* Add to removed entry length to predecessor's length */ + uint16_t del_entry_length = + ext4_directory_entry_ll_get_entry_length(result.dentry); + ext4_directory_entry_ll_set_entry_length(tmp_dentry, + tmp_dentry_length + del_entry_length); + + } + + result.block->dirty = true; + + return ext4_directory_destroy_result(&result); +} + +/** Try to insert entry to concrete data block. + * + * @param sb superblock + * @param target_block block to try to insert entry to + * @param child child i-node to be inserted by new entry + * @param name name of the new entry + * @param name_len length of the new entry name + * @return error code + */ +int ext4_directory_try_insert_entry(ext4_superblock_t *sb, + block_t *target_block, ext4_inode_ref_t *child, + const char *name, uint32_t name_len) +{ + /* 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; + if ((required_len % 4) != 0) { + required_len += 4 - (required_len % 4); + } + + /* 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 + */ + while (dentry < stop) { + + uint32_t inode = ext4_directory_entry_ll_get_inode(dentry); + uint16_t rec_len = ext4_directory_entry_ll_get_entry_length(dentry); + + /* 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); + target_block->dirty = true; + return EOK; + } + + /* Valid entry, try to split it */ + if (inode != 0) { + uint16_t used_name_len = + ext4_directory_entry_ll_get_name_length(sb, dentry); + + uint16_t used_space = + sizeof(ext4_fake_directory_entry_t) + used_name_len; + if ((used_name_len % 4) != 0) { + used_space += 4 - (used_name_len % 4); + } + uint16_t free_space = rec_len - used_space; + + /* There is free space for new entry */ + if (free_space >= required_len) { + + /* Cut tail of current entry */ + ext4_directory_entry_ll_set_entry_length(dentry, used_space); + ext4_directory_entry_ll_t *new_entry = + (void *)dentry + used_space; + ext4_directory_write_entry(sb, new_entry, + free_space, child, name, name_len); + + target_block->dirty = true; + return EOK; + } + } + + /* Jump to the next entry */ + dentry = (void *)dentry + rec_len; + } + + /* No free space found for new entry */ + + return ENOSPC; +} + +/** Try to find entry in block by name. + * + * @param block block containing entries + * @param sb superblock + * @param name_len length of entry name + * @param name name of entry to be found + * @param res_entry output pointer to found entry, NULL if not found + * @return error code + */ +int ext4_directory_find_in_block(block_t *block, + ext4_superblock_t *sb, size_t name_len, const char *name, + ext4_directory_entry_ll_t **res_entry) +{ + /* 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 */ + uint8_t *addr_limit = block->data + ext4_superblock_get_block_size(sb); + + /* Walk through the block and check entries */ + while ((uint8_t *)dentry < addr_limit) { + + /* Termination condition */ + if ((uint8_t*) dentry + name_len > addr_limit) { + break; + } + + /* Valid entry - check it */ + if (dentry->inode != 0) { + + /* For more effectivity compare firstly only lengths */ + if (name_len == ext4_directory_entry_ll_get_name_length(sb, dentry)) { + /* Compare names */ + if (bcmp((uint8_t *)name, dentry->name, name_len) == 0) { + *res_entry = dentry; + return EOK; + } + } + } + + uint16_t dentry_len = ext4_directory_entry_ll_get_entry_length(dentry); + + /* Corrupted entry */ + if (dentry_len == 0) { + return EINVAL; + } + + /* Jump to next entry */ + dentry = (ext4_directory_entry_ll_t *)((uint8_t *)dentry + dentry_len); + } + + /* Entry not found */ + return ENOENT; +} + +/** Simple function to release allocated data from result. + * + * @param result search result to destroy + * @return error code + */ +int ext4_directory_destroy_result(ext4_directory_search_result_t *result) +{ + if (result->block) { + return block_put(result->block); + } + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/ext4/libext4_directory.h =================================================================== --- uspace/lib/ext4/libext4_directory.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_directory.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_DIRECTORY_H_ +#define LIBEXT4_LIBEXT4_DIRECTORY_H_ + +#include "libext4_types.h" + +extern uint32_t ext4_directory_entry_ll_get_inode(ext4_directory_entry_ll_t *); +extern void ext4_directory_entry_ll_set_inode(ext4_directory_entry_ll_t *, + uint32_t); +extern uint16_t ext4_directory_entry_ll_get_entry_length( + ext4_directory_entry_ll_t *); +extern void ext4_directory_entry_ll_set_entry_length( + ext4_directory_entry_ll_t *, uint16_t); +extern uint16_t ext4_directory_entry_ll_get_name_length( + ext4_superblock_t *, ext4_directory_entry_ll_t *); +extern void ext4_directory_entry_ll_set_name_length(ext4_superblock_t *, + ext4_directory_entry_ll_t *, uint16_t); +extern uint8_t ext4_directory_entry_ll_get_inode_type(ext4_superblock_t *, + ext4_directory_entry_ll_t *); +extern void ext4_directory_entry_ll_set_inode_type(ext4_superblock_t *, + ext4_directory_entry_ll_t *, uint8_t); + +extern int ext4_directory_iterator_init(ext4_directory_iterator_t *, + ext4_inode_ref_t *, aoff64_t); +extern int ext4_directory_iterator_next(ext4_directory_iterator_t *); +extern int ext4_directory_iterator_fini(ext4_directory_iterator_t *); + +extern void ext4_directory_write_entry(ext4_superblock_t *, + ext4_directory_entry_ll_t *, uint16_t, ext4_inode_ref_t *, + const char *, size_t); +extern int ext4_directory_add_entry(ext4_inode_ref_t *, + const char *, ext4_inode_ref_t *); +extern int ext4_directory_find_entry(ext4_directory_search_result_t *, + ext4_inode_ref_t *, const char *); +extern int ext4_directory_remove_entry(ext4_inode_ref_t *, const char *); + +extern int ext4_directory_try_insert_entry(ext4_superblock_t *, + block_t *, ext4_inode_ref_t *, const char *, uint32_t); + +extern int ext4_directory_find_in_block(block_t *, + ext4_superblock_t *, size_t, const char *, + ext4_directory_entry_ll_t **); + +extern int ext4_directory_destroy_result(ext4_directory_search_result_t *); +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_directory_index.c =================================================================== --- uspace/lib/ext4/libext4_directory_index.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_directory_index.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,1135 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_directory_index.c + * @brief Ext4 directory index operations. + */ + +#include +#include +#include +#include +#include +#include "libext4.h" + +/** Type entry to pass to sorting algorithm. + * + */ +typedef struct ext4_dx_sort_entry { + uint32_t hash; + uint32_t rec_len; + void *dentry; +} ext4_dx_sort_entry_t; + + +/** Get hash version used in directory index. + * + * @param root_info pointer to root info structure of index + * @return hash algorithm version + */ +uint8_t ext4_directory_dx_root_info_get_hash_version( + ext4_directory_dx_root_info_t *root_info) +{ + return root_info->hash_version; +} + +/** Set hash version, that will be used in directory index. + * + * @param root_info pointer to root info structure of index + * @param version hash algorithm version + */ +void ext4_directory_dx_root_info_set_hash_version( + ext4_directory_dx_root_info_t *root_info, uint8_t version) +{ + root_info->hash_version = version; +} + +/** Get length of root_info structure in bytes. + * + * @param root_info pointer to root info structure of index + * @return length of the structure + */ +uint8_t ext4_directory_dx_root_info_get_info_length( + ext4_directory_dx_root_info_t *root_info) +{ + return root_info->info_length; +} + +/** Set length of root_info structure in bytes. + * + * @param root_info pointer to root info structure of index + * @param info_length length of the structure + */ +void ext4_directory_dx_root_info_set_info_length( + ext4_directory_dx_root_info_t *root_info, uint8_t info_length) +{ + root_info->info_length = info_length; +} + +/** Get number of indirect levels of HTree. + * + * @param root_info pointer to root info structure of index + * @return height of HTree (actually only 0 or 1) + */ +uint8_t ext4_directory_dx_root_info_get_indirect_levels( + ext4_directory_dx_root_info_t *root_info) +{ + return root_info->indirect_levels; +} + +/** Set number of indirect levels of HTree. + * + * @param root_info pointer to root info structure of index + * @param levels height of HTree (actually only 0 or 1) + */ +void ext4_directory_dx_root_info_set_indirect_levels( + ext4_directory_dx_root_info_t *root_info, uint8_t levels) +{ + root_info->indirect_levels = levels; +} + +/** Get maximum number of index node entries. + * + * @param countlimit pointer to counlimit structure + * @return maximum of entries in node + */ +uint16_t ext4_directory_dx_countlimit_get_limit( + ext4_directory_dx_countlimit_t *countlimit) +{ + return uint16_t_le2host(countlimit->limit); +} + +/** Set maximum number of index node entries. + * + * @param countlimit pointer to counlimit structure + * @param limit maximum of entries in node + */ +void ext4_directory_dx_countlimit_set_limit( + ext4_directory_dx_countlimit_t *countlimit, uint16_t limit) +{ + countlimit->limit = host2uint16_t_le(limit); +} + +/** Get current number of index node entries. + * + * @param countlimit pointer to counlimit structure + * @return number of entries in node + */ +uint16_t ext4_directory_dx_countlimit_get_count( + ext4_directory_dx_countlimit_t *countlimit) +{ + return uint16_t_le2host(countlimit->count); +} + +/** Set current number of index node entries. + * + * @param countlimit pointer to counlimit structure + * @param count number of entries in node + */ +void ext4_directory_dx_countlimit_set_count( + ext4_directory_dx_countlimit_t *countlimit, uint16_t count) +{ + countlimit->count = host2uint16_t_le(count); +} + +/** Get hash value of index entry. + * + * @param entry pointer to index entry + * @return hash value + */ +uint32_t ext4_directory_dx_entry_get_hash(ext4_directory_dx_entry_t *entry) +{ + return uint32_t_le2host(entry->hash); +} + + +/** Set hash value of index entry. + * + * @param entry pointer to index entry + * @param hash hash value + */ +void ext4_directory_dx_entry_set_hash(ext4_directory_dx_entry_t *entry, + uint32_t hash) +{ + entry->hash = host2uint32_t_le(hash); +} + +/** Get block address where child node is located. + * + * @param entry pointer to index entry + * @return block address of child node + */ +uint32_t ext4_directory_dx_entry_get_block(ext4_directory_dx_entry_t *entry) +{ + return uint32_t_le2host(entry->block); +} + +/** Set block address where child node is located. + * + * @param entry pointer to index entry + * @param block block address of child node + */ +void ext4_directory_dx_entry_set_block(ext4_directory_dx_entry_t *entry, + uint32_t block) +{ + entry->block = host2uint32_t_le(block); +} + + +/**************************************************************************/ + +/** Initialize index structure of new directory. + * + * @param dir pointer to directory i-node + * @return error code + */ +int ext4_directory_dx_init(ext4_inode_ref_t *dir) +{ + int rc; + + /* Load block 0, where will be index root located */ + uint32_t fblock; + rc = ext4_filesystem_get_inode_data_block_index(dir, 0, &fblock); + if (rc != EOK) { + return rc; + } + + block_t *block; + rc = block_get(&block, dir->fs->device, fblock, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + /* 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 */ + uint8_t hash_version = + ext4_superblock_get_default_hash_version(dir->fs->superblock); + + ext4_directory_dx_root_info_set_hash_version(info, hash_version); + ext4_directory_dx_root_info_set_indirect_levels(info, 0); + ext4_directory_dx_root_info_set_info_length(info, 8); + + /* Set limit and current number of entries */ + ext4_directory_dx_countlimit_t *countlimit = + (ext4_directory_dx_countlimit_t *)&root->entries; + ext4_directory_dx_countlimit_set_count(countlimit, 1); + + uint32_t block_size = ext4_superblock_get_block_size(dir->fs->superblock); + uint32_t entry_space = block_size - 2 * sizeof(ext4_directory_dx_dot_entry_t) + - sizeof(ext4_directory_dx_root_info_t); + uint16_t root_limit = entry_space / sizeof(ext4_directory_dx_entry_t); + ext4_directory_dx_countlimit_set_limit(countlimit, root_limit); + + /* Append new block, where will be new entries inserted in the future */ + uint32_t iblock; + rc = ext4_filesystem_append_inode_block(dir, &fblock, &iblock); + if (rc != EOK) { + block_put(block); + return rc; + } + + block_t *new_block; + rc = block_get(&new_block, dir->fs->device, fblock, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + block_put(block); + return rc; + } + + /* 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); + ext4_directory_entry_ll_set_inode(block_entry, 0); + + new_block->dirty = true; + rc = block_put(new_block); + if (rc != EOK) { + block_put(block); + return rc; + } + + /* 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); + + block->dirty = true; + + rc = block_put(block); + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** Initialize hash info structure necessary for index operations. + * + * @param hinfo pointer to hinfo to be initialized + * @param root_block root block (number 0) of index + * @param sb pointer to superblock + * @param name_len length of name to be computed hash value from + * @param name name to be computed hash value from + * @return error code + */ +static int ext4_directory_hinfo_init(ext4_hash_info_t *hinfo, block_t *root_block, + ext4_superblock_t *sb, size_t name_len, const char *name) +{ + + ext4_directory_dx_root_t *root = (ext4_directory_dx_root_t *)root_block->data; + + if (root->info.hash_version != EXT4_HASH_VERSION_TEA && + root->info.hash_version != EXT4_HASH_VERSION_HALF_MD4 && + root->info.hash_version != EXT4_HASH_VERSION_LEGACY) { + return EXT4_ERR_BAD_DX_DIR; + } + + /* Check unused flags */ + if (root->info.unused_flags != 0) { + return EXT4_ERR_BAD_DX_DIR; + } + + /* Check indirect levels */ + if (root->info.indirect_levels > 1) { + return EXT4_ERR_BAD_DX_DIR; + } + + /* Check if node limit is correct */ + uint32_t block_size = ext4_superblock_get_block_size(sb); + uint32_t entry_space = block_size; + entry_space -= 2 * sizeof(ext4_directory_dx_dot_entry_t); + entry_space -= sizeof(ext4_directory_dx_root_info_t); + entry_space = entry_space / sizeof(ext4_directory_dx_entry_t); + + uint16_t limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)&root->entries); + if (limit != entry_space) { + return EXT4_ERR_BAD_DX_DIR; + } + + /* 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 */ + hinfo->hash_version += 3; + } + + /* Load hash seed from superblock */ + hinfo->seed = ext4_superblock_get_hash_seed(sb); + + /* Compute hash value of name */ + if (name) { + ext4_hash_string(hinfo, name_len, name); + } + + return EOK; +} + +/** Walk through index tree and load leaf with corresponding hash value. + * + * @param hinfo initialized hash info structure + * @param inode_ref current i-node + * @param root_block root block (iblock 0), where is root node located + * @param dx_block pointer to leaf node in dx_blocks array + * @param dx_blocks array with the whole path from root to leaf + * @return error code + */ +static int ext4_directory_dx_get_leaf(ext4_hash_info_t *hinfo, + ext4_inode_ref_t *inode_ref, block_t *root_block, + ext4_directory_dx_block_t **dx_block, ext4_directory_dx_block_t *dx_blocks) +{ + int rc; + + ext4_directory_dx_block_t *tmp_dx_block = dx_blocks; + + ext4_directory_dx_root_t *root = (ext4_directory_dx_root_t *)root_block->data; + ext4_directory_dx_entry_t *entries = (ext4_directory_dx_entry_t *)&root->entries; + + uint16_t limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)entries); + uint8_t indirect_level = ext4_directory_dx_root_info_get_indirect_levels(&root->info); + + block_t *tmp_block = root_block; + ext4_directory_dx_entry_t *p, *q, *m, *at; + + /* Walk through the index tree */ + while (true) { + + uint16_t count = ext4_directory_dx_countlimit_get_count((ext4_directory_dx_countlimit_t *)entries); + if ((count == 0) || (count > limit)) { + return EXT4_ERR_BAD_DX_DIR; + } + + + /* Do binary search in every node */ + p = entries + 1; + q = entries + count - 1; + + while (p <= q) { + m = p + (q - p) / 2; + if (ext4_directory_dx_entry_get_hash(m) > hinfo->hash) { + q = m - 1; + } else { + p = m + 1; + } + } + + at = p - 1; + + /* Write results */ + tmp_dx_block->block = tmp_block; + tmp_dx_block->entries = entries; + tmp_dx_block->position = at; + + /* Is algorithm in the leaf? */ + if (indirect_level == 0) { + *dx_block = tmp_dx_block; + return EOK; + } + + /* Goto child node */ + uint32_t next_block = ext4_directory_dx_entry_get_block(at); + + indirect_level--; + + uint32_t fblock; + rc = ext4_filesystem_get_inode_data_block_index( + inode_ref, next_block, &fblock); + if (rc != EOK) { + return rc; + } + + rc = block_get(&tmp_block, inode_ref->fs->device, fblock, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + entries = ((ext4_directory_dx_node_t *) tmp_block->data)->entries; + limit = ext4_directory_dx_countlimit_get_limit( + (ext4_directory_dx_countlimit_t *)entries); + + uint16_t entry_space = ext4_superblock_get_block_size(inode_ref->fs->superblock) + - sizeof(ext4_directory_dx_dot_entry_t); + entry_space = entry_space / sizeof(ext4_directory_dx_entry_t); + + + if (limit != entry_space) { + block_put(tmp_block); + return EXT4_ERR_BAD_DX_DIR; + } + + ++tmp_dx_block; + } + + /* Unreachable */ + return EOK; +} + + +/** Check if the the next block would be checked during entry search. + * + * @param inode_ref directory i-node + * @param hash hash value to check + * @param dx_block current block + * @param dx_blocks aray with path from root to leaf node + * @return error code + */ +static int ext4_directory_dx_next_block(ext4_inode_ref_t *inode_ref, uint32_t hash, + ext4_directory_dx_block_t *dx_block, ext4_directory_dx_block_t *dx_blocks) +{ + int rc; + + uint32_t num_handles = 0; + ext4_directory_dx_block_t *p = dx_block; + + /* Try to find data block with next bunch of entries */ + while (1) { + + p->position++; + uint16_t count = ext4_directory_dx_countlimit_get_count( + (ext4_directory_dx_countlimit_t *)p->entries); + + if (p->position < p->entries + count) { + break; + } + + if (p == dx_blocks) { + return 0; + } + + num_handles++; + p--; + } + + /* 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) { + if ((current_hash & ~1) != hash) { + return 0; + } + } + + /* Fill new path */ + while (num_handles--) { + + uint32_t block_idx = ext4_directory_dx_entry_get_block(p->position); + uint32_t block_addr; + rc = ext4_filesystem_get_inode_data_block_index(inode_ref, block_idx, &block_addr); + if (rc != EOK) { + return rc; + } + + block_t *block; + rc = block_get(&block, inode_ref->fs->device, block_addr, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + p++; + + /* Don't forget to put old block (prevent memory leak) */ + block_put(p->block); + + p->block = block; + p->entries = ((ext4_directory_dx_node_t *) block->data)->entries; + p->position = p->entries; + } + + return 1; + +} + +/** Try to find directory entry using directory index. + * + * @param result output value - if entry will be found, + * than will be passed through this parameter + * @param inode_ref directory i-node + * @param name_len length of name to be found + * @param name name to be found + * @return error code + */ +int ext4_directory_dx_find_entry(ext4_directory_search_result_t *result, + ext4_inode_ref_t *inode_ref, size_t name_len, const char *name) +{ + int rc; + + /* 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); + if (rc != EOK) { + return rc; + } + + ext4_filesystem_t *fs = inode_ref->fs; + + block_t *root_block; + rc = block_get(&root_block, fs->device, root_block_addr, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + /* Initialize hash info (compute hash value) */ + ext4_hash_info_t hinfo; + rc = ext4_directory_hinfo_init(&hinfo, root_block, fs->superblock, name_len, name); + if (rc != EOK) { + block_put(root_block); + return EXT4_ERR_BAD_DX_DIR; + } + + /* 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; + rc = ext4_directory_dx_get_leaf(&hinfo, inode_ref, root_block, &dx_block, dx_blocks); + if (rc != EOK) { + block_put(root_block); + return EXT4_ERR_BAD_DX_DIR; + } + + do { + /* Load leaf block */ + uint32_t leaf_block_idx = ext4_directory_dx_entry_get_block(dx_block->position); + uint32_t leaf_block_addr; + rc = ext4_filesystem_get_inode_data_block_index(inode_ref, leaf_block_idx, &leaf_block_addr); + if (rc != EOK) { + goto cleanup; + } + + block_t *leaf_block; + rc = block_get(&leaf_block, fs->device, leaf_block_addr, BLOCK_FLAGS_NONE); + if (rc != EOK) { + goto cleanup; + } + + /* 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 */ + if (rc == EOK) { + result->block = leaf_block; + result->dentry = res_dentry; + goto cleanup; + } + + /* Not found, leave untouched */ + block_put(leaf_block); + + if (rc != ENOENT) { + goto cleanup; + } + + /* 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) { + goto cleanup; + } + + } while (rc == 1); + + /* Entry not found */ + rc = ENOENT; + +cleanup: + + /* The whole path must be released (preventing memory leak) */ + tmp = dx_blocks; + while (tmp <= dx_block) { + block_put(tmp->block); + ++tmp; + } + return rc; +} + +/** Compare function used to pass in quicksort implementation. + * + * It can compare two entries by hash value. + * + * @param arg1 first entry + * @param arg2 second entry + * @param dummy unused parameter, can be NULL + * @return classic compare result (0: equal, -1: arg1 < arg2, 1: arg1 > arg2) + */ +static int ext4_directory_dx_entry_comparator(void *arg1, void *arg2, void *dummy) +{ + ext4_dx_sort_entry_t *entry1 = arg1; + ext4_dx_sort_entry_t *entry2 = arg2; + + if (entry1->hash == entry2->hash) { + return 0; + } + + if (entry1->hash < entry2->hash) { + return -1; + } else { + return 1; + } + +} + +/** Insert new index entry to block. + * + * Note that space for new entry must be checked by caller. + * + * @param index_block block where to insert new entry + * @param hash hash value covered by child node + * @param iblock logical number of child block + * + */ +static void ext4_directory_dx_insert_entry( + ext4_directory_dx_block_t *index_block, uint32_t hash, uint32_t iblock) +{ + ext4_directory_dx_entry_t *old_index_entry = index_block->position; + ext4_directory_dx_entry_t *new_index_entry = old_index_entry + 1; + + ext4_directory_dx_countlimit_t *countlimit = + (ext4_directory_dx_countlimit_t *)index_block->entries; + uint32_t count = ext4_directory_dx_countlimit_get_count(countlimit); + + ext4_directory_dx_entry_t *start_index = index_block->entries; + size_t bytes = (void *)(start_index + count) - (void *)(new_index_entry); + + memmove(new_index_entry + 1, new_index_entry, bytes); + + ext4_directory_dx_entry_set_block(new_index_entry, iblock); + ext4_directory_dx_entry_set_hash(new_index_entry, hash); + + ext4_directory_dx_countlimit_set_count(countlimit, count + 1); + + index_block->block->dirty = true; +} + +/** Split directory entries to two parts preventing node overflow. + * + * @param inode_ref directory i-node + * @param hinfo hash info + * @param old_data_block block with data to be split + * @param index_block block where index entries are located + * @param new_data_block output value for newly allocated data block + */ +static int ext4_directory_dx_split_data(ext4_inode_ref_t *inode_ref, + ext4_hash_info_t *hinfo, block_t *old_data_block, + ext4_directory_dx_block_t *index_block, block_t **new_data_block) +{ + int rc = EOK; + + /* Allocate buffer for directory entries */ + uint32_t block_size = + ext4_superblock_get_block_size(inode_ref->fs->superblock); + void *entry_buffer = malloc(block_size); + if (entry_buffer == NULL) { + return ENOMEM; + } + + /* dot entry has the smallest size available */ + uint32_t max_entry_count = block_size / sizeof(ext4_directory_dx_dot_entry_t); + + /* Allocate sort entry */ + ext4_dx_sort_entry_t *sort_array = malloc(max_entry_count * sizeof(ext4_dx_sort_entry_t)); + if (sort_array == NULL) { + free(entry_buffer); + return ENOMEM; + } + + uint32_t idx = 0; + uint32_t real_size = 0; + + /* Initialize hinfo */ + ext4_hash_info_t tmp_hinfo; + memcpy(&tmp_hinfo, hinfo, sizeof(ext4_hash_info_t)); + + /* 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 */ + if (ext4_directory_entry_ll_get_inode(dentry) != 0) { + + uint8_t len = ext4_directory_entry_ll_get_name_length( + inode_ref->fs->superblock, dentry); + ext4_hash_string(&tmp_hinfo, len, (char *)dentry->name); + + uint32_t rec_len = 8 + len; + + if ((rec_len % 4) != 0) { + rec_len += 4 - (rec_len % 4); + } + + memcpy(entry_buffer_ptr, dentry, rec_len); + + sort_array[idx].dentry = entry_buffer_ptr; + sort_array[idx].rec_len = rec_len; + sort_array[idx].hash = tmp_hinfo.hash; + + entry_buffer_ptr += rec_len; + real_size += rec_len; + idx++; + } + + dentry = (void *)dentry + ext4_directory_entry_ll_get_entry_length(dentry); + } + + /* 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 */ + uint32_t new_fblock; + uint32_t new_iblock; + rc = ext4_filesystem_append_inode_block(inode_ref, &new_fblock, &new_iblock); + if (rc != EOK) { + free(sort_array); + free(entry_buffer); + return rc; + } + + /* Load new block */ + block_t *new_data_block_tmp; + rc = block_get(&new_data_block_tmp, inode_ref->fs->device, + new_fblock, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + free(sort_array); + free(entry_buffer); + return rc; + } + + /* Distribute entries to two blocks (by size) + * - compute the half + */ + uint32_t new_hash = 0; + uint32_t current_size = 0; + uint32_t mid = 0; + for (uint32_t i = 0; i < idx; ++i) { + if ((current_size + sort_array[i].rec_len) > (real_size / 2)) { + new_hash = sort_array[i].hash; + mid = i; + break; + } + + current_size += sort_array[i].rec_len; + } + + /* Check hash collision */ + uint32_t continued = 0; + if (new_hash == sort_array[mid-1].hash) { + continued = 1; + } + + uint32_t offset = 0; + void *ptr; + + /* First part - to the old block */ + for (uint32_t i = 0; i < mid; ++i) { + ptr = old_data_block->data + offset; + memcpy(ptr, sort_array[i].dentry, sort_array[i].rec_len); + + ext4_directory_entry_ll_t *tmp = ptr; + if (i < (mid - 1)) { + ext4_directory_entry_ll_set_entry_length(tmp, sort_array[i].rec_len); + } else { + ext4_directory_entry_ll_set_entry_length(tmp, block_size - offset); + } + + offset += sort_array[i].rec_len; + } + + /* Second part - to the new block */ + offset = 0; + for (uint32_t i = mid; i < idx; ++i) { + ptr = new_data_block_tmp->data + offset; + memcpy(ptr, sort_array[i].dentry, sort_array[i].rec_len); + + ext4_directory_entry_ll_t *tmp = ptr; + if (i < (idx - 1)) { + ext4_directory_entry_ll_set_entry_length(tmp, sort_array[i].rec_len); + } else { + ext4_directory_entry_ll_set_entry_length(tmp, block_size - offset); + } + + offset += sort_array[i].rec_len; + } + + /* Do some steps to finish operation */ + old_data_block->dirty = true; + new_data_block_tmp->dirty = true; + + free(sort_array); + free(entry_buffer); + + ext4_directory_dx_insert_entry(index_block, new_hash + continued, new_iblock); + + *new_data_block = new_data_block_tmp; + + return EOK; +} + +/** Split index node and maybe some parent nodes in the tree hierarchy. + * + * @param inode_ref directory i-node + * @param dx_blocks array with path from root to leaf node + * @param dx_block leaf block to be split if needed + * @return error code + */ +static int ext4_directory_dx_split_index(ext4_inode_ref_t *inode_ref, + ext4_directory_dx_block_t *dx_blocks, ext4_directory_dx_block_t *dx_block) +{ + int rc; + + ext4_directory_dx_entry_t *entries; + if (dx_block == dx_blocks) { + entries = ((ext4_directory_dx_root_t *) dx_block->block->data)->entries; + } else { + entries = ((ext4_directory_dx_node_t *) dx_block->block->data)->entries; + } + + ext4_directory_dx_countlimit_t *countlimit = + (ext4_directory_dx_countlimit_t *)entries; + uint16_t leaf_limit = ext4_directory_dx_countlimit_get_limit(countlimit); + uint16_t leaf_count = ext4_directory_dx_countlimit_get_count(countlimit); + + /* Check if is necessary to split index block */ + if (leaf_limit == leaf_count) { + + unsigned int levels = dx_block - dx_blocks; + + ext4_directory_dx_entry_t *root_entries = + ((ext4_directory_dx_root_t *)dx_blocks[0].block->data)->entries; + + ext4_directory_dx_countlimit_t *root_countlimit = + (ext4_directory_dx_countlimit_t *)root_entries; + uint16_t root_limit = + ext4_directory_dx_countlimit_get_limit(root_countlimit); + uint16_t root_count = + ext4_directory_dx_countlimit_get_count(root_countlimit); + + /* Linux limitation */ + if ((levels > 0) && (root_limit == root_count)) { + return ENOSPC; + } + + /* Add new block to directory */ + uint32_t new_fblock; + uint32_t new_iblock; + rc = ext4_filesystem_append_inode_block( + inode_ref, &new_fblock, &new_iblock); + if (rc != EOK) { + return rc; + } + + /* load new block */ + block_t * new_block; + rc = block_get(&new_block, inode_ref->fs->device, + new_fblock, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + return rc; + } + + ext4_directory_dx_node_t *new_node = new_block->data; + ext4_directory_dx_entry_t *new_entries = new_node->entries; + + uint32_t block_size = ext4_superblock_get_block_size( + inode_ref->fs->superblock); + + /* Split leaf node */ + if (levels > 0) { + + uint32_t count_left = leaf_count / 2; + uint32_t count_right = leaf_count - count_left; + uint32_t hash_right = + ext4_directory_dx_entry_get_hash(entries + count_left); + + /* Copy data to new node */ + memcpy((void *) new_entries, (void *) (entries + count_left), + count_right * sizeof(ext4_directory_dx_entry_t)); + + /* Initialize new node */ + ext4_directory_dx_countlimit_t *left_countlimit = + (ext4_directory_dx_countlimit_t *)entries; + ext4_directory_dx_countlimit_t *right_countlimit = + (ext4_directory_dx_countlimit_t *)new_entries; + + ext4_directory_dx_countlimit_set_count(left_countlimit, count_left); + ext4_directory_dx_countlimit_set_count(right_countlimit, count_right); + + uint32_t entry_space = block_size - sizeof(ext4_fake_directory_entry_t); + uint32_t node_limit = entry_space / sizeof(ext4_directory_dx_entry_t); + ext4_directory_dx_countlimit_set_limit(right_countlimit, node_limit); + + /* Which index block is target for new entry */ + uint32_t position_index = (dx_block->position - dx_block->entries); + if (position_index >= count_left) { + + dx_block->block->dirty = true; + + block_t *block_tmp = dx_block->block; + dx_block->block = new_block; + dx_block->position = new_entries + position_index - count_left; + dx_block->entries = new_entries; + + new_block = block_tmp; + + } + + /* Finally insert new entry */ + ext4_directory_dx_insert_entry(dx_blocks, hash_right, new_iblock); + + return block_put(new_block); + + } else { + + /* 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)); + + ext4_directory_dx_countlimit_t *new_countlimit = + (ext4_directory_dx_countlimit_t *)new_entries; + + uint32_t entry_space = block_size - sizeof(ext4_fake_directory_entry_t); + uint32_t node_limit = entry_space / sizeof(ext4_directory_dx_entry_t); + ext4_directory_dx_countlimit_set_limit(new_countlimit, node_limit); + + /* Set values in root node */ + ext4_directory_dx_countlimit_t *new_root_countlimit = + (ext4_directory_dx_countlimit_t *)entries; + + ext4_directory_dx_countlimit_set_count(new_root_countlimit, 1); + ext4_directory_dx_entry_set_block(entries, new_iblock); + + ((ext4_directory_dx_root_t *)dx_blocks[0].block->data)->info.indirect_levels = 1; + + /* Add new entry to the path */ + dx_block = dx_blocks + 1; + dx_block->position = dx_block->position - entries + new_entries; + dx_block->entries = new_entries; + dx_block->block = new_block; + } + + } + + return EOK; +} + +/** Add new entry to indexed directory + * + * @param parent directory i-node + * @param child i-node to be referenced from directory entry + * @param name name of new directory entry + * @return error code + */ +int ext4_directory_dx_add_entry(ext4_inode_ref_t *parent, + ext4_inode_ref_t *child, const char *name) +{ + int rc = EOK; + int rc2 = EOK; + + /* get direct block 0 (index root) */ + uint32_t root_block_addr; + rc = ext4_filesystem_get_inode_data_block_index(parent, 0, &root_block_addr); + if (rc != EOK) { + return rc; + } + + ext4_filesystem_t *fs = parent->fs; + + block_t *root_block; + rc = block_get(&root_block, fs->device, root_block_addr, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + /* Initialize hinfo structure (mainly compute hash) */ + uint32_t name_len = strlen(name); + ext4_hash_info_t hinfo; + rc = ext4_directory_hinfo_init(&hinfo, root_block, fs->superblock, name_len, name); + if (rc != EOK) { + block_put(root_block); + return EXT4_ERR_BAD_DX_DIR; + } + + /* 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; + rc = ext4_directory_dx_get_leaf(&hinfo, parent, root_block, &dx_block, dx_blocks); + if (rc != EOK) { + rc = EXT4_ERR_BAD_DX_DIR; + goto release_index; + } + + + /* 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; + rc = ext4_filesystem_get_inode_data_block_index(parent, leaf_block_idx, &leaf_block_addr); + if (rc != EOK) { + goto release_index; + } + + + block_t *target_block; + rc = block_get(&target_block, fs->device, leaf_block_addr, BLOCK_FLAGS_NONE); + if (rc != EOK) { + goto release_index; + } + + /* Check if insert operation passed */ + rc = ext4_directory_try_insert_entry(fs->superblock, target_block, child, name, name_len); + if (rc == EOK) { + goto release_target_index; + } + + /* 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) { + goto release_target_index; + } + + /* 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); + if (rc != EOK) { + rc2 = rc; + goto release_target_index; + } + + /* 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) { + rc = ext4_directory_try_insert_entry(fs->superblock, new_block, child, name, name_len); + } else { + rc = ext4_directory_try_insert_entry(fs->superblock, target_block, child, name, name_len); + } + + /* Cleanup */ + rc = block_put(new_block); + if (rc != EOK) { + return rc; + } + + /* Cleanup operations */ + +release_target_index: + + rc2 = rc; + + rc = block_put(target_block); + if (rc != EOK) { + return rc; + } + +release_index: + + if (rc != EOK) { + rc2 = rc; + } + + dx_it = dx_blocks; + + while (dx_it <= dx_block) { + rc = block_put(dx_it->block); + if (rc != EOK) { + return rc; + } + dx_it++; + } + + return rc2; +} + + +/** + * @} + */ Index: uspace/lib/ext4/libext4_directory_index.h =================================================================== --- uspace/lib/ext4/libext4_directory_index.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_directory_index.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_DIRECTORY_INDEX_H_ +#define LIBEXT4_LIBEXT4_DIRECTORY_INDEX_H_ + +#include "libext4_types.h" + +extern uint8_t ext4_directory_dx_root_info_get_hash_version( + ext4_directory_dx_root_info_t *); +extern void ext4_directory_dx_root_info_set_hash_version( + ext4_directory_dx_root_info_t *, uint8_t); +extern uint8_t ext4_directory_dx_root_info_get_info_length( + ext4_directory_dx_root_info_t *); +extern void ext4_directory_dx_root_info_set_info_length( + ext4_directory_dx_root_info_t *, uint8_t); +extern uint8_t ext4_directory_dx_root_info_get_indirect_levels( + ext4_directory_dx_root_info_t *); +extern void ext4_directory_dx_root_info_set_indirect_levels( + ext4_directory_dx_root_info_t *, uint8_t); + +extern uint16_t ext4_directory_dx_countlimit_get_limit( + ext4_directory_dx_countlimit_t *); +extern void ext4_directory_dx_countlimit_set_limit( + ext4_directory_dx_countlimit_t *, uint16_t); +extern uint16_t ext4_directory_dx_countlimit_get_count( + ext4_directory_dx_countlimit_t *); +extern void ext4_directory_dx_countlimit_set_count( + ext4_directory_dx_countlimit_t *, uint16_t); + +extern uint32_t ext4_directory_dx_entry_get_hash(ext4_directory_dx_entry_t *); +extern void ext4_directory_dx_entry_set_hash(ext4_directory_dx_entry_t *, + uint32_t); +extern uint32_t ext4_directory_dx_entry_get_block(ext4_directory_dx_entry_t *); +void ext4_directory_dx_entry_set_block(ext4_directory_dx_entry_t *, uint32_t); + +/*********************************************************************************/ + +extern int ext4_directory_dx_init(ext4_inode_ref_t *); +extern int ext4_directory_dx_find_entry(ext4_directory_search_result_t *, + ext4_inode_ref_t *, size_t, const char *); +extern int ext4_directory_dx_add_entry( + ext4_inode_ref_t *, ext4_inode_ref_t *, const char *); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_extent.c =================================================================== --- uspace/lib/ext4/libext4_extent.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_extent.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,1093 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_extent.c + * @brief Ext4 extent structures operations. + */ + +#include +#include +#include +#include "libext4.h" + +/** Get logical number of the block covered by extent. + * + * @param extent extent to load number from + * @return logical number of the first block covered by extent + */ +uint32_t ext4_extent_get_first_block(ext4_extent_t *extent) +{ + return uint32_t_le2host(extent->first_block); +} + +/** Set logical number of the first block covered by extent. + * + * @param extent extent to set number to + * @param iblock logical number of the first block covered by extent + */ +void ext4_extent_set_first_block(ext4_extent_t *extent, uint32_t iblock) +{ + extent->first_block = host2uint32_t_le(iblock); +} + +/** Get number of blocks covered by extent. + * + * @param extent extent to load count from + * @return number of blocks covered by extent + */ +uint16_t ext4_extent_get_block_count(ext4_extent_t *extent) +{ + return uint16_t_le2host(extent->block_count); +} + +/** Set number of blocks covered by extent. + * + * @param extent extent to load count from + * @param count number of blocks covered by extent + */ +void ext4_extent_set_block_count(ext4_extent_t *extent, uint16_t count) +{ + extent->block_count = host2uint16_t_le(count); +} + +/** Get physical number of the first block covered by extent. + * + * @param extent extent to load number + * @return physical number of the first block covered by extent + */ +uint64_t ext4_extent_get_start(ext4_extent_t *extent) +{ + return ((uint64_t)uint16_t_le2host(extent->start_hi)) << 32 | + ((uint64_t)uint32_t_le2host(extent->start_lo)); +} + +/** Set physical number of the first block covered by extent. + * + * @param extent extent to load number + * @param fblock physical number of the first block covered by extent + */ +void ext4_extent_set_start(ext4_extent_t *extent, uint64_t fblock) +{ + extent->start_lo = host2uint32_t_le((fblock << 32) >> 32); + extent->start_hi = host2uint16_t_le((uint16_t)(fblock >> 32)); +} + +/** Get logical number of the block covered by extent index. + * + * @param index extent index to load number from + * @return logical number of the first block covered by extent index + */ +uint32_t ext4_extent_index_get_first_block(ext4_extent_index_t *index) +{ + return uint32_t_le2host(index->first_block); +} + +/** Set logical number of the block covered by extent index. + * + * @param index extent index to set number to + * @param iblock logical number of the first block covered by extent index + */ +void ext4_extent_index_set_first_block(ext4_extent_index_t *index, + uint32_t iblock) +{ + index->first_block = host2uint32_t_le(iblock); +} + +/** Get physical number of block where the child node is located. + * + * @param index extent index to load number from + * @return physical number of the block with child node + */ +uint64_t ext4_extent_index_get_leaf(ext4_extent_index_t *index) +{ + return ((uint64_t)uint16_t_le2host(index->leaf_hi)) << 32 | + ((uint64_t)uint32_t_le2host(index->leaf_lo)); +} + +/** Set physical number of block where the child node is located. + * + * @param index extent index to set number to + * @param fblock physical number of the block with child node + */ +void ext4_extent_index_set_leaf(ext4_extent_index_t *index, uint64_t fblock) +{ + index->leaf_lo = host2uint32_t_le((fblock << 32) >> 32); + index->leaf_hi = host2uint16_t_le((uint16_t)(fblock >> 32)); +} + +/** Get magic value from extent header. + * + * @param header extent header to load value from + * @return magic value of extent header + */ +uint16_t ext4_extent_header_get_magic(ext4_extent_header_t *header) +{ + return uint16_t_le2host(header->magic); +} + +/** Set magic value to extent header. + * + * @param header extent header to set value to + * @param magic magic value of extent header + */ +void ext4_extent_header_set_magic(ext4_extent_header_t *header, uint16_t magic) +{ + header->magic = host2uint16_t_le(magic); +} + +/** Get number of entries from extent header + * + * @param header extent header to get value from + * @return number of entries covered by extent header + */ +uint16_t ext4_extent_header_get_entries_count(ext4_extent_header_t *header) +{ + return uint16_t_le2host(header->entries_count); +} + +/** Set number of entries to extent header + * + * @param header extent header to set value to + * @param count number of entries covered by extent header + */ +void ext4_extent_header_set_entries_count(ext4_extent_header_t *header, + uint16_t count) +{ + header->entries_count = host2uint16_t_le(count); +} + +/** Get maximum number of entries from extent header + * + * @param header extent header to get value from + * @return maximum number of entries covered by extent header + */ +uint16_t ext4_extent_header_get_max_entries_count(ext4_extent_header_t *header) +{ + return uint16_t_le2host(header->max_entries_count); +} + +/** Set maximum number of entries to extent header + * + * @param header extent header to set value to + * @param max_count maximum number of entries covered by extent header + */ +void ext4_extent_header_set_max_entries_count(ext4_extent_header_t *header, + uint16_t max_count) +{ + header->max_entries_count = host2uint16_t_le(max_count); +} + +/** Get depth of extent subtree. + * + * @param header extent header to get value from + * @return depth of extent subtree + */ +uint16_t ext4_extent_header_get_depth(ext4_extent_header_t *header) +{ + return uint16_t_le2host(header->depth); +} + +/** Set depth of extent subtree. + * + * @param header extent header to set value to + * @param depth depth of extent subtree + */ +void ext4_extent_header_set_depth(ext4_extent_header_t *header, uint16_t depth) +{ + header->depth = host2uint16_t_le(depth); +} + +/** Get generation from extent header + * + * @param header extent header to get value from + * @return generation + */ +uint32_t ext4_extent_header_get_generation(ext4_extent_header_t *header) +{ + return uint32_t_le2host(header->generation); +} + +/** Set generation to extent header + * + * @param header extent header to set value to + * @param generation generation + */ +void ext4_extent_header_set_generation(ext4_extent_header_t *header, + uint32_t generation) +{ + header->generation = host2uint32_t_le(generation); +} + +/** Binary search in extent index node. + * + * @param header extent header of index node + * @param index output value - found index will be set here + * @param iblock logical block number to find in index node + */ +static void ext4_extent_binsearch_idx(ext4_extent_header_t *header, + ext4_extent_index_t **index, uint32_t iblock) +{ + ext4_extent_index_t *r, *l, *m; + + uint16_t entries_count = ext4_extent_header_get_entries_count(header); + + /* Initialize bounds */ + l = EXT4_EXTENT_FIRST_INDEX(header) + 1; + r = EXT4_EXTENT_FIRST_INDEX(header) + entries_count - 1; + + /* Do binary search */ + while (l <= r) { + m = l + (r - l) / 2; + uint32_t first_block = ext4_extent_index_get_first_block(m); + if (iblock < first_block) { + r = m - 1; + } else { + l = m + 1; + } + } + + /* Set output value */ + *index = l - 1; +} + +/** Binary search in extent leaf node. + * @param header extent header of leaf node + * @param extent output value - found extent will be set here, + * or NULL if node is empty + * @param iblock logical block number to find in leaf node + * + */ +static void ext4_extent_binsearch(ext4_extent_header_t *header, + ext4_extent_t **extent, uint32_t iblock) +{ + ext4_extent_t *r, *l, *m; + + uint16_t entries_count = ext4_extent_header_get_entries_count(header); + + if (entries_count == 0) { + /* this leaf is empty */ + *extent = NULL; + return; + } + + /* Initialize bounds */ + l = EXT4_EXTENT_FIRST(header) + 1; + r = EXT4_EXTENT_FIRST(header) + entries_count - 1; + + /* Do binary search */ + while (l <= r) { + m = l + (r - l) / 2; + uint32_t first_block = ext4_extent_get_first_block(m); + if (iblock < first_block) { + r = m - 1; + } else { + l = m + 1; + } + } + + /* Set output value */ + *extent = l - 1; +} + +/** Find physical block in the extent tree by logical block number. + * + * There is no need to save path in the tree during this algorithm. + * + * @param inode_ref i-node to load block from + * @param iblock logical block number to find + * @param fblock output value for physical block number + * @return error code + */ +int ext4_extent_find_block(ext4_inode_ref_t *inode_ref, + uint32_t iblock, uint32_t *fblock) +{ + int rc; + + /* Compute bound defined by i-node size */ + uint64_t inode_size = ext4_inode_get_size( + inode_ref->fs->superblock, inode_ref->inode); + + uint32_t block_size = ext4_superblock_get_block_size( + inode_ref->fs->superblock); + + uint32_t last_idx = (inode_size - 1) / block_size; + + /* Check if requested iblock is not over size of i-node */ + if (iblock > last_idx) { + *fblock = 0; + return EOK; + } + + block_t* block = NULL; + + /* Walk through extent tree */ + ext4_extent_header_t *header = ext4_inode_get_extent_header(inode_ref->inode); + + while (ext4_extent_header_get_depth(header) != 0) { + + /* 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 */ + uint64_t child = ext4_extent_index_get_leaf(index); + + if (block != NULL) { + block_put(block); + } + + rc = block_get(&block, inode_ref->fs->device, child, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + header = (ext4_extent_header_t *)block->data; + } + + /* Search extent in the leaf block */ + ext4_extent_t* extent = NULL; + ext4_extent_binsearch(header, &extent, iblock); + + /* Prevent empty leaf */ + if (extent == NULL) { + *fblock = 0; + } else { + + /* 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; + + *fblock = phys_block; + } + + /* Cleanup */ + if (block != NULL) { + block_put(block); + } + + return EOK; +} + + +/** Find extent for specified iblock. + * + * This function is used for finding block in the extent tree with + * saving the path through the tree for possible future modifications. + * + * @param inode_ref i-node to read extent tree from + * @param iblock iblock to find extent for + * @param ret_path output value for loaded path from extent tree + * @return error code + */ +static int ext4_extent_find_extent(ext4_inode_ref_t *inode_ref, + uint32_t iblock, ext4_extent_path_t **ret_path) +{ + int rc; + + ext4_extent_header_t *eh = + ext4_inode_get_extent_header(inode_ref->inode); + + uint16_t depth = ext4_extent_header_get_depth(eh); + + ext4_extent_path_t *tmp_path; + + /* Added 2 for possible tree growing */ + tmp_path = malloc(sizeof(ext4_extent_path_t) * (depth + 2)); + if (tmp_path == NULL) { + return ENOMEM; + } + + /* Initialize structure for algorithm start */ + tmp_path[0].block = inode_ref->block; + tmp_path[0].header = eh; + + /* Walk through the extent tree */ + uint16_t pos = 0; + while (ext4_extent_header_get_depth(eh) != 0) { + + /* Search index in index node by iblock */ + ext4_extent_binsearch_idx(tmp_path[pos].header, &tmp_path[pos].index, iblock); + + tmp_path[pos].depth = depth; + tmp_path[pos].extent = NULL; + + assert(tmp_path[pos].index != NULL); + + /* Load information for the next iteration */ + uint64_t fblock = ext4_extent_index_get_leaf(tmp_path[pos].index); + + block_t *block; + rc = block_get(&block, inode_ref->fs->device, fblock, BLOCK_FLAGS_NONE); + if (rc != EOK) { + goto cleanup; + } + + pos++; + + eh = (ext4_extent_header_t *)block->data; + tmp_path[pos].block = block; + tmp_path[pos].header = eh; + + } + + tmp_path[pos].depth = 0; + tmp_path[pos].extent = NULL; + tmp_path[pos].index = NULL; + + /* Find extent in the leaf node */ + ext4_extent_binsearch(tmp_path[pos].header, &tmp_path[pos].extent, iblock); + + *ret_path = tmp_path; + + return EOK; + +cleanup: + /* 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) { + block_put(tmp_path[i].block); + } + } + + /* Destroy temporary data structure */ + free(tmp_path); + + return rc; +} + +/** Release extent and all data blocks covered by the extent. + * + * @param inode_ref i-node to release extent and block from + * @param extent extent to release + * @return error code + */ +static int ext4_extent_release( + ext4_inode_ref_t *inode_ref, ext4_extent_t *extent) +{ + int rc; + + /* 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); + + rc = ext4_balloc_free_blocks(inode_ref, start, block_count); + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** Recursively release the whole branch of the extent tree. + * + * For each entry of the node release the subbranch and finally release + * the node. In the leaf node all extents will be released. + * + * @param inode_ref i-node where the branch is released + * @param index index in the non-leaf node to be released + * with the whole subtree + * @return error code + */ +static int ext4_extent_release_branch(ext4_inode_ref_t *inode_ref, + ext4_extent_index_t *index) +{ + int rc; + + block_t* block; + + uint32_t fblock = ext4_extent_index_get_leaf(index); + + rc = block_get(&block, inode_ref->fs->device, fblock, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + ext4_extent_header_t *header = block->data; + + if (ext4_extent_header_get_depth(header)) { + + /* The node is non-leaf, do recursion */ + + ext4_extent_index_t *idx = EXT4_EXTENT_FIRST_INDEX(header); + + /* 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); + if (rc != EOK) { + return rc; + } + } + } else { + + /* Leaf node reached */ + ext4_extent_t *ext = EXT4_EXTENT_FIRST(header); + + /* Release all extents and stop recursion */ + + for (uint32_t i = 0; i < ext4_extent_header_get_entries_count(header); ++i, ++ext) { + rc = ext4_extent_release(inode_ref, ext); + if (rc != EOK) { + return rc; + } + } + } + + /* Release data block where the node was stored */ + + rc = block_put(block); + if (rc != EOK) { + return rc; + } + + ext4_balloc_free_block(inode_ref, fblock); + + return EOK; +} + +/** Release all data blocks starting from specified logical block. + * + * @param inode_ref i-node to release blocks from + * @param iblock_from first logical block to release + */ +int ext4_extent_release_blocks_from(ext4_inode_ref_t *inode_ref, + uint32_t iblock_from) +{ + int rc = EOK; + + /* Find the first extent to modify */ + ext4_extent_path_t *path; + rc = ext4_extent_find_extent(inode_ref, iblock_from, &path); + if (rc != EOK) { + return rc; + } + + /* Jump to last item of the path (extent) */ + ext4_extent_path_t *path_ptr = path; + while (path_ptr->depth != 0) { + path_ptr++; + } + + assert(path_ptr->extent != NULL); + + /* 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; + + + uint16_t block_count = ext4_extent_get_block_count(path_ptr->extent); + + uint16_t delete_count = block_count - ( + ext4_extent_get_start(path_ptr->extent) - first_fblock); + + /* Release all blocks */ + rc = ext4_balloc_free_blocks(inode_ref, first_fblock, delete_count); + if (rc != EOK) { + goto cleanup; + } + + /* Correct counter */ + block_count -= delete_count; + ext4_extent_set_block_count(path_ptr->extent, block_count); + + /* 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 (block_count == 0) { + entries--; + } + + /* Release all successors of the first extent in the same node */ + while (tmp_ext < stop_ext) { + first_fblock = ext4_extent_get_start(tmp_ext); + delete_count = ext4_extent_get_block_count(tmp_ext); + + rc = ext4_balloc_free_blocks(inode_ref, first_fblock, delete_count); + if (rc != EOK) { + goto cleanup; + } + + entries--; + tmp_ext++; + } + + ext4_extent_header_set_entries_count(path_ptr->header, entries); + path_ptr->block->dirty = true; + + /* If leaf node is empty, parent entry must be modified */ + bool remove_parent_record = false; + + /* 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); + if (rc != EOK) { + goto cleanup; + } + remove_parent_record = true; + } + + /* Jump to the parent */ + --path_ptr; + + /* Release all successors in all tree levels */ + while (path_ptr >= path) { + entries = ext4_extent_header_get_entries_count(path_ptr->header); + ext4_extent_index_t *index = path_ptr->index + 1; + ext4_extent_index_t *stop = + EXT4_EXTENT_FIRST_INDEX(path_ptr->header) + entries; + + /* Correct entries count because of changes in the previous iteration */ + if (remove_parent_record) { + entries--; + } + + /* Iterate over all entries and release the whole subtrees */ + while (index < stop) { + rc = ext4_extent_release_branch(inode_ref, index); + if (rc != EOK) { + goto cleanup; + } + ++index; + --entries; + } + + ext4_extent_header_set_entries_count(path_ptr->header, entries); + path_ptr->block->dirty = true; + + /* Free the node if it is empty */ + if ((entries == 0) && (path_ptr != path)) { + rc = ext4_balloc_free_block(inode_ref, path_ptr->block->lba); + if (rc != EOK) { + goto cleanup; + } + + /* Mark parent to be checked */ + remove_parent_record = true; + } else { + remove_parent_record = false; + } + + --path_ptr; + } + + +cleanup: + /* 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) { + block_put(path[i].block); + } + } + + /* Destroy temporary data structure */ + free(path); + + return rc; +} + + +/** Append new extent to the i-node and do some splitting if necessary. + * + * @param inode_ref i-node to append extent to + * @param path path in the extent tree for possible splitting + * @param last_path_item input/output parameter for pointer to the last + * valid item in the extent tree path + * @param iblock logical index of block to append extent for + * @return error code + */ +static int ext4_extent_append_extent(ext4_inode_ref_t *inode_ref, + ext4_extent_path_t *path, uint32_t iblock) +{ + int rc; + + ext4_extent_path_t *path_ptr = path + path->depth; + + uint32_t block_size = + ext4_superblock_get_block_size(inode_ref->fs->superblock); + + /* Start splitting */ + while (path_ptr > path) { + + uint16_t entries = ext4_extent_header_get_entries_count(path_ptr->header); + uint16_t limit = ext4_extent_header_get_max_entries_count(path_ptr->header); + + if (entries == limit) { + + /* Full node - allocate block for new one */ + uint32_t fblock; + rc = ext4_balloc_alloc_block(inode_ref, &fblock); + if (rc != EOK) { + return rc; + } + + block_t *block; + rc = block_get(&block, inode_ref->fs->device, fblock, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + ext4_balloc_free_block(inode_ref, fblock); + return rc; + } + + /* Put back not modified old block */ + block_put(path_ptr->block); + + /* Initialize newly allocated block and remember it */ + memset(block->data, 0, block_size); + path_ptr->block = block; + + /* Update pointers in extent path structure */ + path_ptr->header = block->data; + if (path_ptr->depth) { + path_ptr->index = EXT4_EXTENT_FIRST_INDEX(path_ptr->header); + ext4_extent_index_set_first_block(path_ptr->index, iblock); + ext4_extent_index_set_leaf(path_ptr->index, (path_ptr + 1)->block->lba); + limit = (block_size - sizeof(ext4_extent_header_t)) / + sizeof(ext4_extent_index_t); + } else { + path_ptr->extent = EXT4_EXTENT_FIRST(path_ptr->header); + ext4_extent_set_first_block(path_ptr->extent, iblock); + limit = (block_size - sizeof(ext4_extent_header_t)) / + sizeof(ext4_extent_t); + } + + /* Initialize on-disk structure (header) */ + ext4_extent_header_set_entries_count(path_ptr->header, 1); + ext4_extent_header_set_max_entries_count(path_ptr->header, limit); + ext4_extent_header_set_magic(path_ptr->header, EXT4_EXTENT_MAGIC); + ext4_extent_header_set_depth(path_ptr->header, path_ptr->depth); + ext4_extent_header_set_generation(path_ptr->header, 0); + + path_ptr->block->dirty = true; + + /* Jump to the preceeding item */ + path_ptr--; + + } else { + + /* Node with free space */ + if (path_ptr->depth) { + path_ptr->index = EXT4_EXTENT_FIRST_INDEX(path_ptr->header) + entries; + ext4_extent_index_set_first_block(path_ptr->index, iblock); + ext4_extent_index_set_leaf(path_ptr->index, (path_ptr + 1)->block->lba); + } else { + path_ptr->extent = EXT4_EXTENT_FIRST(path_ptr->header) + entries; + ext4_extent_set_first_block(path_ptr->extent, iblock); + } + + ext4_extent_header_set_entries_count(path_ptr->header, entries + 1); + path_ptr->block->dirty = true; + + /* No more splitting needed */ + return EOK; + } + + } + + assert(path_ptr == path); + + /* Should be the root split too? */ + + uint16_t entries = ext4_extent_header_get_entries_count(path->header); + uint16_t limit = ext4_extent_header_get_max_entries_count(path->header); + + if (entries == limit) { + + uint32_t new_fblock; + rc = ext4_balloc_alloc_block(inode_ref, &new_fblock); + if (rc != EOK) { + return rc; + } + + block_t *block; + rc = block_get(&block, inode_ref->fs->device, + new_fblock, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + return rc; + } + + /* Initialize newly allocated block */ + memset(block->data, 0, block_size); + + /* Move data from root to the new block */ + memcpy(block->data, inode_ref->inode->blocks, + EXT4_INODE_BLOCKS * sizeof(uint32_t)); + + // Data block initialized !!! + + block_t *root_block = path->block; + uint16_t root_depth = path->depth; + ext4_extent_header_t *root_header = path->header; + + /* Make space for tree growing */ + ext4_extent_path_t *new_root = path; + ext4_extent_path_t *old_root = path + 1; + + size_t nbytes = sizeof(ext4_extent_path_t) * (path->depth + 1); + memmove(old_root, new_root, nbytes); + memset(new_root, 0, sizeof(ext4_extent_path_t)); + + /* Update old root structure */ + old_root->block = block; + old_root->header = (ext4_extent_header_t *)block->data; + + /* Add new entry and update limit for entries */ + if (old_root->depth) { + limit = (block_size - sizeof(ext4_extent_header_t)) / + sizeof(ext4_extent_index_t); + old_root->index = EXT4_EXTENT_FIRST_INDEX(old_root->header) + entries; + ext4_extent_index_set_first_block(old_root->index, iblock); + ext4_extent_index_set_leaf(old_root->index, (old_root + 1)->block->lba); + old_root->extent = NULL; + } else { + limit = (block_size - sizeof(ext4_extent_header_t)) / + sizeof(ext4_extent_t); + old_root->extent = EXT4_EXTENT_FIRST(old_root->header) + entries; + ext4_extent_set_first_block(old_root->extent, iblock); + old_root->index = NULL; + } + ext4_extent_header_set_entries_count(old_root->header, entries + 1); + ext4_extent_header_set_max_entries_count(old_root->header, limit); + + old_root->block->dirty = true; + + /* Re-initialize new root metadata */ + new_root->depth = root_depth + 1; + new_root->block = root_block; + new_root->header = root_header; + new_root->extent = NULL; + new_root->index = EXT4_EXTENT_FIRST_INDEX(new_root->header); + + ext4_extent_header_set_depth(new_root->header, new_root->depth); + + /* Create new entry in root */ + ext4_extent_header_set_entries_count(new_root->header, 1); + ext4_extent_index_set_first_block(new_root->index, 0); + ext4_extent_index_set_leaf(new_root->index, new_fblock); + + new_root->block->dirty = true; + + } else { + + if (path->depth) { + path->index = EXT4_EXTENT_FIRST_INDEX(path->header) + entries; + ext4_extent_index_set_first_block(path->index, iblock); + ext4_extent_index_set_leaf(path->index, (path + 1)->block->lba); + } else { + path->extent = EXT4_EXTENT_FIRST(path->header) + entries; + ext4_extent_set_first_block(path->extent, iblock); + } + + ext4_extent_header_set_entries_count(path->header, entries + 1); + path->block->dirty = true; + } + + return EOK; +} + +/** Append data block to the i-node. + * + * This function allocates data block, tries to append it + * to some existing extent or creates new extents. + * It includes possible extent tree modifications (splitting). + *< + * @param inode_ref i-node to append block to + * @param iblock output logical number of newly allocated block + * @param fblock output physical block address of newly allocated block + * @return error code + */ +int ext4_extent_append_block(ext4_inode_ref_t *inode_ref, + uint32_t *iblock, uint32_t *fblock, bool update_size) +{ + int rc = EOK; + + ext4_superblock_t *sb = inode_ref->fs->superblock; + uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode); + uint32_t block_size = ext4_superblock_get_block_size(sb); + + /* Calculate number of new logical block */ + uint32_t new_block_idx = 0; + if (inode_size > 0) { + if ((inode_size % block_size) != 0) { + inode_size += block_size - (inode_size % block_size); + } + new_block_idx = inode_size / block_size; + } + + /* Load the nearest leaf (with extent) */ + ext4_extent_path_t *path; + rc = ext4_extent_find_extent(inode_ref, new_block_idx, &path); + if (rc != EOK) { + return rc; + } + + /* Jump to last item of the path (extent) */ + ext4_extent_path_t *path_ptr = path; + while (path_ptr->depth != 0) { + path_ptr++; + } + + /* Add new extent to the node if not present */ + if (path_ptr->extent == NULL) { + goto append_extent; + } + + uint16_t block_count = ext4_extent_get_block_count(path_ptr->extent); + uint16_t block_limit = (1 << 15); + + uint32_t phys_block = 0; + if (block_count < block_limit) { + + /* There is space for new block in the extent */ + + if (block_count == 0) { + + /* Existing extent is empty */ + + rc = ext4_balloc_alloc_block(inode_ref, &phys_block); + if (rc != EOK) { + goto finish; + } + + /* 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 */ + if (update_size) { + ext4_inode_set_size(inode_ref->inode, inode_size + block_size); + inode_ref->dirty = true; + } + + path_ptr->block->dirty = true; + + goto finish; + } else { + + /* 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 */ + bool free; + rc = ext4_balloc_try_alloc_block(inode_ref, phys_block, &free); + if (rc != EOK) { + goto finish; + } + + if (! free) { + /* target is not free, new block must be appended to new extent */ + goto append_extent; + } + + + /* Update extent */ + ext4_extent_set_block_count(path_ptr->extent, block_count + 1); + + /* Update i-node */ + if (update_size) { + ext4_inode_set_size(inode_ref->inode, inode_size + block_size); + inode_ref->dirty = true; + } + + path_ptr->block->dirty = true; + + goto finish; + } + } + +/* Append new extent to the tree */ +append_extent: + + phys_block = 0; + + /* Allocate new data block */ + rc = ext4_balloc_alloc_block(inode_ref, &phys_block); + if (rc != EOK) { + goto finish; + } + + /* Append extent for new block (includes tree splitting if needed) */ + rc = ext4_extent_append_extent(inode_ref, path, new_block_idx); + if (rc != EOK) { + ext4_balloc_free_block(inode_ref, phys_block); + goto finish; + } + + uint32_t tree_depth = ext4_extent_header_get_depth(path->header); + path_ptr = path + tree_depth; + + /* 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 */ + if (update_size) { + ext4_inode_set_size(inode_ref->inode, inode_size + block_size); + inode_ref->dirty = true; + } + + path_ptr->block->dirty = true; + + +finish: + /* Set return values */ + *iblock = new_block_idx; + *fblock = phys_block; + + /* 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) { + block_put(path[i].block); + } + } + + /* Destroy temporary data structure */ + free(path); + + return rc; +} + +/** + * @} + */ Index: uspace/lib/ext4/libext4_extent.h =================================================================== --- uspace/lib/ext4/libext4_extent.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_extent.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_EXTENT_H_ +#define LIBEXT4_LIBEXT4_EXTENT_H_ + +#include "libext4_types.h" + +extern uint32_t ext4_extent_get_first_block(ext4_extent_t *); +extern void ext4_extent_set_first_block(ext4_extent_t *, uint32_t); +extern uint16_t ext4_extent_get_block_count(ext4_extent_t *); +extern void ext4_extent_set_block_count(ext4_extent_t *, uint16_t); +extern uint64_t ext4_extent_get_start(ext4_extent_t *); +extern void ext4_extent_set_start(ext4_extent_t *, uint64_t); + +extern uint32_t ext4_extent_index_get_first_block(ext4_extent_index_t *); +extern void ext4_extent_index_set_first_block(ext4_extent_index_t *, uint32_t); +extern uint64_t ext4_extent_index_get_leaf(ext4_extent_index_t *); +extern void ext4_extent_index_set_leaf(ext4_extent_index_t *, uint64_t); + +extern uint16_t ext4_extent_header_get_magic(ext4_extent_header_t *); +extern void ext4_extent_header_set_magic(ext4_extent_header_t *, uint16_t); +extern uint16_t ext4_extent_header_get_entries_count(ext4_extent_header_t *); +extern void ext4_extent_header_set_entries_count(ext4_extent_header_t *, + uint16_t); +extern uint16_t ext4_extent_header_get_max_entries_count(ext4_extent_header_t *); +extern void ext4_extent_header_set_max_entries_count(ext4_extent_header_t *, + uint16_t); +extern uint16_t ext4_extent_header_get_depth(ext4_extent_header_t *); +extern void ext4_extent_header_set_depth(ext4_extent_header_t *, uint16_t); +extern uint32_t ext4_extent_header_get_generation(ext4_extent_header_t *); +extern void ext4_extent_header_set_generation(ext4_extent_header_t *, uint32_t); + +extern int ext4_extent_find_block(ext4_inode_ref_t *, uint32_t, uint32_t *); +extern int ext4_extent_release_blocks_from(ext4_inode_ref_t *, uint32_t); + +extern int ext4_extent_append_block(ext4_inode_ref_t *, uint32_t *, uint32_t *, bool); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_filesystem.c =================================================================== --- uspace/lib/ext4/libext4_filesystem.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_filesystem.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,1430 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_filesystem.c + * @brief More complex filesystem operations. + */ + +#include +#include +#include +#include "libext4.h" + +/** Initialize filesystem and read all needed data. + * + * @param fs filesystem instance to be initialized + * @param service_id identifier if device with the filesystem + * @return error code + */ +int ext4_filesystem_init(ext4_filesystem_t *fs, service_id_t service_id, + enum cache_mode cmode) +{ + int rc; + + fs->device = service_id; + + /* Initialize block library (4096 is size of communication channel) */ + rc = block_init(EXCHANGE_SERIALIZE, fs->device, 4096); + if (rc != EOK) { + return rc; + } + + /* Read superblock from device to memory */ + ext4_superblock_t *temp_superblock; + rc = ext4_superblock_read_direct(fs->device, &temp_superblock); + if (rc != EOK) { + block_fini(fs->device); + return rc; + } + + /* 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) { + block_fini(fs->device); + return ENOTSUP; + } + + /* Initialize block caching by libblock */ + rc = block_cache_init(service_id, block_size, 0, cmode); + if (rc != EOK) { + block_fini(fs->device); + return rc; + } + + /* 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; + fs->inode_blocks_per_level[0] = 1; + for (int i = 1; i < 4; i++) { + fs->inode_blocks_per_level[i] = fs->inode_blocks_per_level[i-1] * + block_ids_per_block; + fs->inode_block_limits[i] = fs->inode_block_limits[i-1] + + fs->inode_blocks_per_level[i]; + } + + /* Return loaded superblock */ + fs->superblock = temp_superblock; + + uint16_t state = ext4_superblock_get_state(fs->superblock); + + if (state != EXT4_SUPERBLOCK_STATE_VALID_FS) { + block_cache_fini(fs->device); + block_fini(fs->device); + return ENOTSUP; + } + + /* Mark system as mounted */ + ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_ERROR_FS); + rc = ext4_superblock_write_direct(fs->device, fs->superblock); + if (rc != EOK) { + block_cache_fini(fs->device); + block_fini(fs->device); + return rc; + } + + uint16_t mnt_count = ext4_superblock_get_mount_count(fs->superblock); + ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1); + + return EOK; +} + +/** Destroy filesystem instance (used by unmount operation). + * + * @param fs filesystem to be destroyed + * @param write_sb flag if superblock should be written to device + * @return error code + */ +int ext4_filesystem_fini(ext4_filesystem_t *fs) +{ + int rc = EOK; + + /* 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 */ + free(fs->superblock); + + /* Finish work with block library */ + block_cache_fini(fs->device); + block_fini(fs->device); + + return rc; +} + +/** Check sanity of the filesystem. + * + * Main is the check of the superblock structure. + * + * @param fs filesystem to be checked + * @return error code + */ +int ext4_filesystem_check_sanity(ext4_filesystem_t *fs) +{ + int rc; + + /* Check superblock */ + rc = ext4_superblock_check_sanity(fs->superblock); + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** Check filesystem's features, if supported by this driver + * + * Function can return EOK and set read_only flag. It mean's that + * there are some not-supported features, that can cause problems + * during some write operations. + * + * @param fs filesystem to be checked + * @param read_only flag if filesystem should be mounted only for reading + * @return error code + */ +int ext4_filesystem_check_features(ext4_filesystem_t *fs, bool *read_only) +{ + /* Feature flags are present only in higher revisions */ + if (ext4_superblock_get_rev_level(fs->superblock) == 0) { + *read_only = false; + return EOK; + } + + /* 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); + incompatible_features &= ~EXT4_FEATURE_INCOMPAT_SUPP; + if (incompatible_features > 0) { + return ENOTSUP; + } + + /* 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); + compatible_read_only &= ~EXT4_FEATURE_RO_COMPAT_SUPP; + if (compatible_read_only > 0) { + *read_only = true; + return EOK; + } + + return EOK; +} + + +/** Convert block address to relative index in block group. + * + * @param sb superblock pointer + * @param block_addr block number to convert + * @return relative number of block + */ +uint32_t ext4_filesystem_blockaddr2_index_in_group(ext4_superblock_t *sb, + uint32_t block_addr) +{ + uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb); + uint32_t first_block = ext4_superblock_get_first_data_block(sb); + + /* First block == 0 or 1 */ + if (first_block == 0) { + return block_addr % blocks_per_group; + } else { + return (block_addr - 1) % blocks_per_group; + } +} + + +/** Convert relative block address in group to absolute address. + * + * @param sb superblock pointer + * @param block_addr block number to convert + * @return absolute block address + */ +uint32_t ext4_filesystem_index_in_group2blockaddr(ext4_superblock_t *sb, + uint32_t index, uint32_t bgid) +{ + uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb); + + if (ext4_superblock_get_first_data_block(sb) == 0) { + return bgid * blocks_per_group + index; + } else { + return bgid * blocks_per_group + index + 1; + } + +} + +/** Initialize block bitmap in block group. + * + * @param bg_ref reference to block group + * @return error code + */ +static int ext4_filesystem_init_block_bitmap(ext4_block_group_ref_t *bg_ref) +{ + int rc; + + /* Load bitmap */ + uint32_t bitmap_block_addr = ext4_block_group_get_block_bitmap( + bg_ref->block_group, bg_ref->fs->superblock); + block_t *bitmap_block; + + rc = block_get(&bitmap_block, bg_ref->fs->device, + bitmap_block_addr, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + return rc; + } + + uint8_t *bitmap = bitmap_block->data; + + /* Initialize all bitmap bits to zero */ + uint32_t block_size = ext4_superblock_get_block_size(bg_ref->fs->superblock); + memset(bitmap, 0, block_size); + + /* Determine first block and first data block in group */ + uint32_t first_idx = 0; + + uint32_t first_data = ext4_balloc_get_first_data_block_in_group( + bg_ref->fs->superblock, bg_ref); + uint32_t first_data_idx = ext4_filesystem_blockaddr2_index_in_group( + bg_ref->fs->superblock, first_data); + + /* Set bits from to first block to first data block - 1 to one (allocated) */ + for (uint32_t block = first_idx; block < first_data_idx; ++block) { + ext4_bitmap_set_bit(bitmap, block); + } + + bitmap_block->dirty = true; + + /* Save bitmap */ + rc = block_put(bitmap_block); + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** Initialize i-node bitmap in block group. + * + * @param bg_ref reference to block group + * @return error code + */ +static int ext4_filesystem_init_inode_bitmap(ext4_block_group_ref_t *bg_ref) +{ + int rc; + + /* Load bitmap */ + uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap( + bg_ref->block_group, bg_ref->fs->superblock); + block_t *bitmap_block; + + rc = block_get(&bitmap_block, bg_ref->fs->device, + bitmap_block_addr, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + return rc; + } + + uint8_t *bitmap = bitmap_block->data; + + /* Initialize all bitmap bits to zero */ + uint32_t block_size = ext4_superblock_get_block_size(bg_ref->fs->superblock); + uint32_t inodes_per_group = + ext4_superblock_get_inodes_per_group(bg_ref->fs->superblock); + memset(bitmap, 0, (inodes_per_group + 7) / 8); + + uint32_t start_bit = inodes_per_group; + uint32_t end_bit = block_size * 8; + + uint32_t i; + for (i = start_bit; i < ((start_bit + 7) & ~7UL); i++) { + ext4_bitmap_set_bit(bitmap, i); + } + + if (i < end_bit) { + memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3); + } + + bitmap_block->dirty = true; + + /* Save bitmap */ + rc = block_put(bitmap_block); + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** Initialize i-node table in block group. + * + * @param bg_ref reference to block group + * @return error code + */ +static int ext4_filesystem_init_inode_table(ext4_block_group_ref_t *bg_ref) +{ + int rc; + + ext4_superblock_t *sb = bg_ref->fs->superblock; + + uint32_t inode_size = ext4_superblock_get_inode_size(sb); + uint32_t block_size = ext4_superblock_get_block_size(sb); + uint32_t inodes_per_block = block_size / inode_size; + + uint32_t inodes_in_group = + ext4_superblock_get_inodes_in_group(sb, bg_ref->index); + + uint32_t table_blocks = inodes_in_group / inodes_per_block; + + if (inodes_in_group % inodes_per_block) { + table_blocks++; + } + + /* Compute initialization bounds */ + uint32_t first_block = ext4_block_group_get_inode_table_first_block( + bg_ref->block_group, sb); + + uint32_t last_block = first_block + table_blocks - 1; + + /* Initialization of all itable blocks */ + for (uint32_t fblock = first_block; fblock <= last_block; ++fblock) { + block_t *block; + rc = block_get(&block, bg_ref->fs->device, fblock, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + return rc; + } + + memset(block->data, 0, block_size); + block->dirty = true; + + rc = block_put(block); + if (rc != EOK) { + return rc; + } + } + + return EOK; +} + +/** Get reference to block group specified by index. + * + * @param fs filesystem to find block group on + * @param bgid index of block group to load + * @param ref output pointer for reference + * @return error code + */ +int ext4_filesystem_get_block_group_ref(ext4_filesystem_t *fs, uint32_t bgid, + ext4_block_group_ref_t **ref) +{ + int rc; + + /* Allocate memory for new structure */ + ext4_block_group_ref_t *newref = malloc(sizeof(ext4_block_group_ref_t)); + if (newref == NULL) { + return ENOMEM; + } + + /* 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 */ + aoff64_t block_id = ext4_superblock_get_first_data_block(fs->superblock) + 1; + + /* 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 */ + rc = block_get(&newref->block, fs->device, block_id, 0); + if (rc != EOK) { + free(newref); + return rc; + } + + /* Inititialize in-memory representation */ + newref->block_group = newref->block->data + offset; + newref->fs = fs; + newref->index = bgid; + newref->dirty = false; + + *ref = newref; + + if (ext4_block_group_has_flag(newref->block_group, + EXT4_BLOCK_GROUP_BLOCK_UNINIT)) { + + rc = ext4_filesystem_init_block_bitmap(newref); + if (rc != EOK) { + block_put(newref->block); + free(newref); + return rc; + } + ext4_block_group_clear_flag(newref->block_group, + EXT4_BLOCK_GROUP_BLOCK_UNINIT); + + newref->dirty = true; + } + + if (ext4_block_group_has_flag(newref->block_group, + EXT4_BLOCK_GROUP_INODE_UNINIT)) { + + rc = ext4_filesystem_init_inode_bitmap(newref); + if (rc != EOK) { + block_put(newref->block); + free(newref); + return rc; + } + + ext4_block_group_clear_flag(newref->block_group, + EXT4_BLOCK_GROUP_INODE_UNINIT); + + ext4_block_group_set_itable_unused(newref->block_group, + newref->fs->superblock, 0); + + + if (! ext4_block_group_has_flag(newref->block_group, + EXT4_BLOCK_GROUP_ITABLE_ZEROED)) { + + rc = ext4_filesystem_init_inode_table(newref); + if (rc != EOK) { + return rc; + } + + ext4_block_group_set_flag(newref->block_group, + EXT4_BLOCK_GROUP_ITABLE_ZEROED); + + } + newref->dirty = true; + + } + + return EOK; +} + +/** Compute checksum of block group descriptor. + * + * It uses crc functions from Linux kernel implementation. + * + * @param sb superblock + * @param bgid index of block group in the filesystem + * @param bg block group to compute checksum for + * @return checksum value + */ +static uint16_t ext4_filesystem_bg_checksum(ext4_superblock_t *sb, uint32_t bgid, + ext4_block_group_t *bg) +{ + /* If checksum not supported, 0 will be returned */ + uint16_t crc = 0; + + /* Compute the checksum only if the filesystem supports it */ + if (ext4_superblock_has_feature_read_only(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { + + void *base = bg; + void *checksum = &bg->checksum; + + uint32_t offset = (uint32_t)(checksum - base); + + /* Convert block group index to little endian */ + uint32_t le_group = host2uint32_t_le(bgid); + + /* Initialization */ + crc = crc16(~0, sb->uuid, sizeof(sb->uuid)); + + /* 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) */ + crc = crc16(crc, (uint8_t *)bg, offset); + + /* Skip checksum */ + offset += sizeof(bg->checksum); + + /* 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)) { + + crc = crc16(crc, ((uint8_t *)bg) + offset, ext4_superblock_get_desc_size(sb) - offset); + } + } + + return crc; + +} + +/** Put reference to block group. + * + * @oaram ref pointer for reference to be put back + * @return error code + */ +int ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *ref) +{ + int rc; + + /* Check if reference modified */ + if (ref->dirty) { + + /* 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 */ + ref->block->dirty = true; + } + + /* Put back block, that contains block group descriptor */ + rc = block_put(ref->block); + free(ref); + + return rc; +} + +/** Get reference to i-node specified by index. + * + * @param fs filesystem to find i-node on + * @param index index of i-node to load + * @oaram ref output pointer for reference + * @return error code + */ +int ext4_filesystem_get_inode_ref(ext4_filesystem_t *fs, uint32_t index, + ext4_inode_ref_t **ref) +{ + int rc; + + /* Allocate memory for new structure */ + ext4_inode_ref_t *newref = malloc(sizeof(ext4_inode_ref_t)); + if (newref == NULL) { + return ENOMEM; + } + + /* 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 + * when computing indices + */ + index -= 1; + uint32_t block_group = index / inodes_per_group; + uint32_t offset_in_group = index % inodes_per_group; + + /* 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); + if (rc != EOK) { + free(newref); + return rc; + } + + /* 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) */ + rc = ext4_filesystem_put_block_group_ref(bg_ref); + if (rc != EOK) { + free(newref); + return rc; + } + + /* 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 */ + aoff64_t block_id = inode_table_start + (byte_offset_in_group / block_size); + rc = block_get(&newref->block, fs->device, block_id, 0); + if (rc != EOK) { + free(newref); + return rc; + } + + /* 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 */ + newref->index = index + 1; + newref->fs = fs; + newref->dirty = false; + + *ref = newref; + + return EOK; +} + +/** Put reference to i-node. + * + * @param ref pointer for reference to be put back + * @return error code + */ +int ext4_filesystem_put_inode_ref(ext4_inode_ref_t *ref) +{ + int rc; + + /* Check if reference modified */ + if (ref->dirty) { + + /* Mark block dirty for writing changes to physical device */ + ref->block->dirty = true; + } + + /* Put back block, that contains i-node */ + rc = block_put(ref->block); + free(ref); + + return rc; +} + +/** Allocate new i-node in the filesystem. + * + * @param fs filesystem to allocated i-node on + * @param inode_ref output pointer to return reference to allocated i-node + * @param flags flags to be set for newly created i-node + * @return error code + */ +int ext4_filesystem_alloc_inode(ext4_filesystem_t *fs, + ext4_inode_ref_t **inode_ref, int flags) +{ + int rc; + + /* Check if newly allocated i-node will be a directory */ + bool is_dir = false; + if (flags & L_DIRECTORY) { + is_dir = true; + } + + /* Allocate inode by allocation algorithm */ + uint32_t index; + rc = ext4_ialloc_alloc_inode(fs, &index, is_dir); + if (rc != EOK) { + return rc; + } + + /* Load i-node from on-disk i-node table */ + rc = ext4_filesystem_get_inode_ref(fs, index, inode_ref); + if (rc != EOK) { + ext4_ialloc_free_inode(fs, index, is_dir); + return rc; + } + + /* Initialize i-node */ + ext4_inode_t *inode = (*inode_ref)->inode; + + uint16_t mode; + if (is_dir) { + /* + * Default directory permissions to be compatible with other systems + * 0777 (octal) == rwxrwxrwx + */ + mode = 0777; + mode |= EXT4_INODE_MODE_DIRECTORY; + ext4_inode_set_mode(fs->superblock, inode, mode); + ext4_inode_set_links_count(inode, 1); /* '.' entry */ + } else { + /* + * Default file permissions to be compatible with other systems + * 0666 (octal) == rw-rw-rw- + */ + + mode = 0666; + mode |= EXT4_INODE_MODE_FILE; + ext4_inode_set_mode(fs->superblock, inode, mode); + ext4_inode_set_links_count(inode, 0); + } + + ext4_inode_set_uid(inode, 0); + ext4_inode_set_gid(inode, 0); + ext4_inode_set_size(inode, 0); + ext4_inode_set_access_time(inode, 0); + ext4_inode_set_change_inode_time(inode, 0); + ext4_inode_set_modification_time(inode, 0); + ext4_inode_set_deletion_time(inode, 0); + ext4_inode_set_blocks_count(fs->superblock, inode, 0); + ext4_inode_set_flags(inode, 0); + ext4_inode_set_generation(inode, 0); + + /* Reset blocks array */ + for (uint32_t i = 0; i < EXT4_INODE_BLOCKS; i++) { + inode->blocks[i] = 0; + } + + /* Initialize extents if needed */ + if (ext4_superblock_has_feature_incompatible( + fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS)) { + + ext4_inode_set_flag(inode, EXT4_INODE_FLAG_EXTENTS); + + /* Initialize extent root header */ + ext4_extent_header_t *header = ext4_inode_get_extent_header(inode); + ext4_extent_header_set_depth(header, 0); + ext4_extent_header_set_entries_count(header, 0); + ext4_extent_header_set_generation(header, 0); + ext4_extent_header_set_magic(header, EXT4_EXTENT_MAGIC); + + uint16_t max_entries = (EXT4_INODE_BLOCKS * sizeof (uint32_t) - sizeof(ext4_extent_header_t)) + / sizeof(ext4_extent_t); + + ext4_extent_header_set_max_entries_count(header, max_entries); + } + + (*inode_ref)->dirty = true; + + return EOK; +} + +/** Release i-node and mark it as free. + * + * @param inode_ref i-node to be released + * @return error code + */ +int ext4_filesystem_free_inode(ext4_inode_ref_t *inode_ref) +{ + int rc; + + ext4_filesystem_t *fs = inode_ref->fs; + + /* 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... */ + goto finish; + } + + /* Release all indirect (no data) blocks */ + + /* 1) Single indirect */ + uint32_t fblock = ext4_inode_get_indirect_block(inode_ref->inode, 0); + if (fblock != 0) { + rc = ext4_balloc_free_block(inode_ref, fblock); + if (rc != EOK) { + return rc; + } + + ext4_inode_set_indirect_block(inode_ref->inode, 0, 0); + } + + block_t *block; + uint32_t block_size = ext4_superblock_get_block_size(fs->superblock); + uint32_t count = block_size / sizeof(uint32_t); + + /* 2) Double indirect */ + fblock = ext4_inode_get_indirect_block(inode_ref->inode, 1); + if (fblock != 0) { + rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + uint32_t ind_block; + for (uint32_t offset = 0; offset < count; ++offset) { + ind_block = uint32_t_le2host(((uint32_t*)block->data)[offset]); + + if (ind_block != 0) { + rc = ext4_balloc_free_block(inode_ref, ind_block); + if (rc != EOK) { + block_put(block); + return rc; + } + } + } + + block_put(block); + rc = ext4_balloc_free_block(inode_ref, fblock); + if (rc != EOK) { + return rc; + } + + ext4_inode_set_indirect_block(inode_ref->inode, 1, 0); + } + + + /* 3) Tripple indirect */ + block_t *subblock; + fblock = ext4_inode_get_indirect_block(inode_ref->inode, 2); + if (fblock != 0) { + rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + uint32_t ind_block; + for (uint32_t offset = 0; offset < count; ++offset) { + ind_block = uint32_t_le2host(((uint32_t*)block->data)[offset]); + + if (ind_block != 0) { + rc = block_get(&subblock, fs->device, ind_block, BLOCK_FLAGS_NONE); + if (rc != EOK) { + block_put(block); + return rc; + } + + uint32_t ind_subblock; + for (uint32_t suboffset = 0; suboffset < count; ++suboffset) { + ind_subblock = uint32_t_le2host(((uint32_t*)subblock->data)[suboffset]); + + if (ind_subblock != 0) { + rc = ext4_balloc_free_block(inode_ref, ind_subblock); + if (rc != EOK) { + block_put(subblock); + block_put(block); + return rc; + } + } + + } + block_put(subblock); + + } + + rc = ext4_balloc_free_block(inode_ref, ind_block); + if (rc != EOK) { + block_put(block); + return rc; + } + + + } + + block_put(block); + rc = ext4_balloc_free_block(inode_ref, fblock); + if (rc != EOK) { + return rc; + } + + ext4_inode_set_indirect_block(inode_ref->inode, 2, 0); + } + +finish: + + /* Mark inode dirty for writing to the physical device */ + inode_ref->dirty = true; + + /* Free block with extended attributes if present */ + uint32_t xattr_block = ext4_inode_get_file_acl( + inode_ref->inode, fs->superblock); + if (xattr_block) { + rc = ext4_balloc_free_block(inode_ref, xattr_block); + if (rc != EOK) { + return rc; + } + + ext4_inode_set_file_acl(inode_ref->inode, fs->superblock, 0); + } + + /* Free inode by allocator */ + if (ext4_inode_is_type(fs->superblock, inode_ref->inode, + EXT4_INODE_MODE_DIRECTORY)) { + rc = ext4_ialloc_free_inode(fs, inode_ref->index, true); + } else { + rc = ext4_ialloc_free_inode(fs, inode_ref->index, false); + } + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** Truncate i-node data blocks. + * + * @param inode_ref i-node to be truncated + * @param new_size new size of inode (must be < current size) + * @return error code + */ +int ext4_filesystem_truncate_inode( + ext4_inode_ref_t *inode_ref, aoff64_t new_size) +{ + int rc; + + ext4_superblock_t *sb = inode_ref->fs->superblock; + + /* 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. */ + aoff64_t old_size = ext4_inode_get_size(sb, inode_ref->inode); + if (old_size == new_size) { + return EOK; + } + + /* 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 */ + aoff64_t size_diff = old_size - new_size; + uint32_t block_size = ext4_superblock_get_block_size(sb); + uint32_t diff_blocks_count = size_diff / block_size; + if (size_diff % block_size != 0) { + diff_blocks_count++; + } + + uint32_t old_blocks_count = old_size / block_size; + if (old_size % block_size != 0) { + old_blocks_count++; + } + + if (ext4_superblock_has_feature_incompatible( + inode_ref->fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS) && + ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS)) { + + /* Extents require special operation */ + + rc = ext4_extent_release_blocks_from(inode_ref, + old_blocks_count - diff_blocks_count); + if (rc != EOK) { + return rc; + } + } else { + + /* 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); + if (rc != EOK) { + return rc; + } + } + } + + /* Update i-node */ + ext4_inode_set_size(inode_ref->inode, new_size); + inode_ref->dirty = true; + + return EOK; +} + +/** Get physical block address by logical index of the block. + * + * @param inode_ref i-node to read block address from + * @param iblock logical index of block + * @param fblock output pointer for return physical block address + * @return error code + */ +int ext4_filesystem_get_inode_data_block_index(ext4_inode_ref_t *inode_ref, + aoff64_t iblock, uint32_t *fblock) +{ + int rc; + + ext4_filesystem_t *fs = inode_ref->fs; + + /* For empty file is situation simple */ + if (ext4_inode_get_size(fs->superblock, inode_ref->inode) == 0) { + *fblock = 0; + return EOK; + } + + uint32_t current_block; + + /* 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)) { + + rc = ext4_extent_find_block(inode_ref, iblock, ¤t_block); + + if (rc != EOK) { + return rc; + } + + *fblock = current_block; + return EOK; + + } + + ext4_inode_t *inode = inode_ref->inode; + + /* 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); + *fblock = current_block; + return EOK; + } + + /* Determine indirection level of the target block */ + int level = -1; + for (int i = 1; i < 4; i++) { + if (iblock < fs->inode_block_limits[i]) { + level = i; + break; + } + } + + if (level == -1) { + return EIO; + } + + /* 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 */ + if (current_block == 0) { + *fblock = 0; + return EOK; + } + + block_t *block; + + /* Navigate through other levels, until we find the block number + * or find null reference meaning we are dealing with sparse file + */ + while (level > 0) { + + /* Load indirect block */ + rc = block_get(&block, fs->device, current_block, 0); + if (rc != EOK) { + return rc; + } + + /* Read block address from indirect block */ + current_block = uint32_t_le2host(((uint32_t*)block->data)[offset_in_block]); + + /* Put back indirect block untouched */ + rc = block_put(block); + if (rc != EOK) { + return rc; + } + + /* Check for sparse file */ + if (current_block == 0) { + *fblock = 0; + return EOK; + } + + /* Jump to the next level */ + level -= 1; + + /* Termination condition - we have address of data block loaded */ + if (level == 0) { + break; + } + + /* 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]; + } + + *fblock = current_block; + + return EOK; +} + +/** Set physical block address for the block logical address into the i-node. + * + * @param inode_ref i-node to set block address to + * @param iblock logical index of block + * @param fblock physical block address + * @return error code + */ +int ext4_filesystem_set_inode_data_block_index(ext4_inode_ref_t *inode_ref, + aoff64_t iblock, uint32_t fblock) +{ + int rc; + + ext4_filesystem_t *fs = inode_ref->fs; + + /* 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 !!! */ + return ENOTSUP; + } + + /* 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); + inode_ref->dirty = true; + return EOK; + } + + /* Determine the indirection level needed to get the desired block */ + int level = -1; + for (int i = 1; i < 4; i++) { + if (iblock < fs->inode_block_limits[i]) { + level = i; + break; + } + } + + if (level == -1) { + return EIO; + } + + uint32_t block_size = ext4_superblock_get_block_size(fs->superblock); + + /* 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); + uint32_t offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1]; + + uint32_t new_block_addr; + block_t *block, *new_block; + + /* Is needed to allocate indirect block on the i-node level */ + if (current_block == 0) { + + /* Allocate new indirect block */ + rc = ext4_balloc_alloc_block(inode_ref, &new_block_addr); + if (rc != EOK) { + return rc; + } + + /* Update i-node */ + ext4_inode_set_indirect_block(inode_ref->inode, level - 1, new_block_addr); + inode_ref->dirty = true; + + /* Load newly allocated block */ + rc = block_get(&new_block, fs->device, new_block_addr, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + ext4_balloc_free_block(inode_ref, new_block_addr); + return rc; + } + + /* Initialize new block */ + memset(new_block->data, 0, block_size); + new_block->dirty = true; + + /* Put back the allocated block */ + rc = block_put(new_block); + if (rc != EOK) { + return rc; + } + + current_block = new_block_addr; + } + + /* Navigate through other levels, until we find the block number + * or find null reference meaning we are dealing with sparse file + */ + while (level > 0) { + + rc = block_get(&block, fs->device, current_block, 0); + if (rc != EOK) { + return rc; + } + + current_block = uint32_t_le2host(((uint32_t*)block->data)[offset_in_block]); + + if ((level > 1) && (current_block == 0)) { + + /* Allocate new block */ + rc = ext4_balloc_alloc_block(inode_ref, &new_block_addr); + if (rc != EOK) { + block_put(block); + return rc; + } + + /* Load newly allocated block */ + rc = block_get(&new_block, fs->device, new_block_addr, BLOCK_FLAGS_NOREAD); + if (rc != EOK) { + block_put(block); + return rc; + } + + /* Initialize allocated block */ + memset(new_block->data, 0, block_size); + new_block->dirty = true; + + rc = block_put(new_block); + if (rc != EOK) { + block_put(block); + return rc; + } + + /* Write block address to the parent */ + ((uint32_t*)block->data)[offset_in_block] = host2uint32_t_le(new_block_addr); + block->dirty = true; + current_block = new_block_addr; + } + + /* Will be finished, write the fblock address */ + if (level == 1) { + ((uint32_t*)block->data)[offset_in_block] = host2uint32_t_le(fblock); + block->dirty = true; + } + + rc = block_put(block); + if (rc != EOK) { + return rc; + } + + level -= 1; + + /* If we are on the last level, break here as + * there is no next level to visit + */ + if (level == 0) { + break; + } + + /* 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]; + } + + return EOK; +} + +/** Release data block from i-node + * + * @param inode_ref i-node to release block from + * @param iblock logical block to be released + * @return error code + */ +int ext4_filesystem_release_inode_block( + ext4_inode_ref_t *inode_ref, uint32_t iblock) +{ + int rc; + + uint32_t fblock; + + ext4_filesystem_t *fs = inode_ref->fs; + + /* EXTENTS are handled otherwise = there is not support in this function */ + assert(! (ext4_superblock_has_feature_incompatible(fs->superblock, + EXT4_FEATURE_INCOMPAT_EXTENTS) && + ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))); + + ext4_inode_t *inode = inode_ref->inode; + + /* 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 */ + if (fblock == 0) { + return EOK; + } + + ext4_inode_set_direct_block(inode, iblock, 0); + return ext4_balloc_free_block(inode_ref, fblock); + } + + + /* Determine the indirection level needed to get the desired block */ + int level = -1; + for (int i = 1; i < 4; i++) { + if (iblock < fs->inode_block_limits[i]) { + level = i; + break; + } + } + + if (level == -1) { + return EIO; + } + + /* 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); + uint32_t offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1]; + + /* Navigate through other levels, until we find the block number + * or find null reference meaning we are dealing with sparse file + */ + block_t *block; + while (level > 0) { + rc = block_get(&block, fs->device, current_block, 0); + if (rc != EOK) { + return rc; + } + + current_block = uint32_t_le2host(((uint32_t*)block->data)[offset_in_block]); + + /* Set zero if physical data block address found */ + if (level == 1) { + ((uint32_t*)block->data)[offset_in_block] = host2uint32_t_le(0); + block->dirty = true; + } + + rc = block_put(block); + if (rc != EOK) { + return rc; + } + + level -= 1; + + /* If we are on the last level, break here as + * there is no next level to visit + */ + if (level == 0) { + break; + } + + /* 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]; + } + + fblock = current_block; + + if (fblock == 0) { + return EOK; + } + + /* Physical block is not referenced, it can be released */ + + return ext4_balloc_free_block(inode_ref, fblock); + +} + +/** Append following logical block to the i-node. + * + * @param inode_ref i-node to append block to + * @param fblock output physical block address of newly allocated block + * @param iblock output logical number of newly allocated block + * @return error code + */ +int ext4_filesystem_append_inode_block(ext4_inode_ref_t *inode_ref, + uint32_t *fblock, uint32_t *iblock) +{ + int rc; + + /* Handle extents separately */ + if (ext4_superblock_has_feature_incompatible( + inode_ref->fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS) && + ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS)) { + + return ext4_extent_append_block(inode_ref, iblock, fblock, true); + + } + + ext4_superblock_t *sb = inode_ref->fs->superblock; + + /* 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 */ + if ((inode_size % block_size) != 0) { + inode_size += block_size - (inode_size % block_size); + } + + /* Logical blocks are numbered from 0 */ + uint32_t new_block_idx = inode_size / block_size; + + /* Allocate new physical block */ + uint32_t phys_block; + rc = ext4_balloc_alloc_block(inode_ref, &phys_block); + if (rc != EOK) { + return rc; + } + + /* 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) { + ext4_balloc_free_block(inode_ref, phys_block); + return rc; + } + + /* Update i-node */ + ext4_inode_set_size(inode_ref->inode, inode_size + block_size); + inode_ref->dirty = true; + + *fblock = phys_block; + *iblock = new_block_idx; + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/ext4/libext4_filesystem.h =================================================================== --- uspace/lib/ext4/libext4_filesystem.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_filesystem.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_FILESYSTEM_H_ +#define LIBEXT4_LIBEXT4_FILESYSTEM_H_ + +#include +#include "libext4_types.h" + +extern int ext4_filesystem_init(ext4_filesystem_t *, + service_id_t, enum cache_mode); +extern int ext4_filesystem_fini(ext4_filesystem_t *fs); +extern int ext4_filesystem_check_sanity(ext4_filesystem_t *fs); +extern int ext4_filesystem_check_features(ext4_filesystem_t *, bool *); +extern uint32_t ext4_filesystem_blockaddr2_index_in_group(ext4_superblock_t *, + uint32_t); +extern uint32_t ext4_filesystem_index_in_group2blockaddr(ext4_superblock_t *, + uint32_t, uint32_t); +extern int ext4_filesystem_get_block_group_ref(ext4_filesystem_t *, uint32_t, + ext4_block_group_ref_t **); +extern int ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *); +extern int ext4_filesystem_get_inode_ref(ext4_filesystem_t *, uint32_t, + ext4_inode_ref_t **); +extern int ext4_filesystem_put_inode_ref(ext4_inode_ref_t *); +extern int ext4_filesystem_alloc_inode(ext4_filesystem_t *, + ext4_inode_ref_t **, int); +extern int ext4_filesystem_free_inode(ext4_inode_ref_t *); +extern int ext4_filesystem_truncate_inode(ext4_inode_ref_t *, aoff64_t); +extern int ext4_filesystem_get_inode_data_block_index(ext4_inode_ref_t *, + aoff64_t iblock, uint32_t *); +extern int ext4_filesystem_set_inode_data_block_index(ext4_inode_ref_t *, + aoff64_t, uint32_t); +extern int ext4_filesystem_release_inode_block( + ext4_inode_ref_t *, uint32_t); +extern int ext4_filesystem_append_inode_block(ext4_inode_ref_t *, + uint32_t *, uint32_t *); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_hash.c =================================================================== --- uspace/lib/ext4/libext4_hash.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_hash.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,325 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_hash.c + * @brief Hashing algorithms for ext4 HTree. + */ + +#include +#include + +#include "libext4.h" + +#define TEA_DELTA 0x9E3779B9 + + +/* F, G and H are basic MD4 functions: selection, majority, parity */ +#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) +#define G(x, y, z) (((x) & (y)) + (((x) ^ (y)) & (z))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) + + +/* + * The generic round function. The application is so specific that + * we don't bother protecting all the arguments with parens, as is generally + * good macro practice, in favor of extra legibility. + * Rotation is separate from addition to prevent recomputation + */ +#define ROUND(f, a, b, c, d, x, s) \ + (a += f(b, c, d) + x, a = (a << s) | (a >> (32 - s))) +#define K1 0 +#define K2 013240474631UL +#define K3 015666365641UL + + +static void tea_transform(uint32_t buf[4], uint32_t const in[]) +{ + uint32_t sum = 0; + uint32_t b0 = buf[0], b1 = buf[1]; + uint32_t a = in[0], b = in[1], c = in[2], d = in[3]; + int n = 16; + + do { + sum += TEA_DELTA; + b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b); + b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d); + } while (--n); + + buf[0] += b0; + buf[1] += b1; +} + + +static void half_md4_transform(uint32_t buf[4], const uint32_t in[8]) +{ + uint32_t a = buf[0], b = buf[1], c = buf[2], d = buf[3]; + + /* Round 1 */ + ROUND(F, a, b, c, d, in[0] + K1, 3); + ROUND(F, d, a, b, c, in[1] + K1, 7); + ROUND(F, c, d, a, b, in[2] + K1, 11); + ROUND(F, b, c, d, a, in[3] + K1, 19); + ROUND(F, a, b, c, d, in[4] + K1, 3); + ROUND(F, d, a, b, c, in[5] + K1, 7); + ROUND(F, c, d, a, b, in[6] + K1, 11); + ROUND(F, b, c, d, a, in[7] + K1, 19); + + /* Round 2 */ + ROUND(G, a, b, c, d, in[1] + K2, 3); + ROUND(G, d, a, b, c, in[3] + K2, 5); + ROUND(G, c, d, a, b, in[5] + K2, 9); + ROUND(G, b, c, d, a, in[7] + K2, 13); + ROUND(G, a, b, c, d, in[0] + K2, 3); + ROUND(G, d, a, b, c, in[2] + K2, 5); + ROUND(G, c, d, a, b, in[4] + K2, 9); + ROUND(G, b, c, d, a, in[6] + K2, 13); + + /* Round 3 */ + ROUND(H, a, b, c, d, in[3] + K3, 3); + ROUND(H, d, a, b, c, in[7] + K3, 9); + ROUND(H, c, d, a, b, in[2] + K3, 11); + ROUND(H, b, c, d, a, in[6] + K3, 15); + ROUND(H, a, b, c, d, in[1] + K3, 3); + ROUND(H, d, a, b, c, in[5] + K3, 9); + ROUND(H, c, d, a, b, in[0] + K3, 11); + ROUND(H, b, c, d, a, in[4] + K3, 15); + + buf[0] += a; + buf[1] += b; + buf[2] += c; + buf[3] += d; + +} + +static uint32_t hash_unsigned(const char *name, int len) +{ + uint32_t hash, hash0 = 0x12a3fe2d, hash1 = 0x37abe8f9; + const unsigned char *ucp = (const unsigned char *) name; + + while (len--) { + hash = hash1 + (hash0 ^ (((int) *ucp++) * 7152373)); + + if (hash & 0x80000000) { + hash -= 0x7fffffff; + } + hash1 = hash0; + hash0 = hash; + } + return hash0 << 1; +} + +static uint32_t hash_signed(const char *name, int len) +{ + uint32_t hash, hash0 = 0x12a3fe2d, hash1 = 0x37abe8f9; + const signed char *scp = (const signed char *) name; + + while (len--) { + hash = hash1 + (hash0 ^ (((int) *scp++) * 7152373)); + + if (hash & 0x80000000) { + hash -= 0x7fffffff; + } + hash1 = hash0; + hash0 = hash; + } + return hash0 << 1; +} + +static void str2hashbuf_signed(const char *msg, int len, uint32_t *buf, int num) +{ + uint32_t pad, val; + int i; + const signed char *scp = (const signed char *) msg; + + pad = (uint32_t)len | ((uint32_t)len << 8); + pad |= pad << 16; + + val = pad; + if (len > num*4) { + len = num * 4; + } + + for (i = 0; i < len; i++) { + if ((i % 4) == 0) { + val = pad; + } + val = ((int) scp[i]) + (val << 8); + if ((i % 4) == 3) { + *buf++ = val; + val = pad; + num--; + } + } + + if (--num >= 0) { + *buf++ = val; + } + + while (--num >= 0) { + *buf++ = pad; + } +} + + +static void str2hashbuf_unsigned(const char *msg, int len, uint32_t *buf, int num) +{ + uint32_t pad, val; + int i; + const unsigned char *ucp = (const unsigned char *) msg; + + pad = (uint32_t)len | ((uint32_t)len << 8); + pad |= pad << 16; + + val = pad; + if (len > num*4) { + len = num * 4; + } + + for (i = 0; i < len; i++) { + if ((i % 4) == 0) { + val = pad; + } + val = ((int) ucp[i]) + (val << 8); + if ((i % 4) == 3) { + *buf++ = val; + val = pad; + num--; + } + } + + if (--num >= 0) { + *buf++ = val; + } + + while (--num >= 0) { + *buf++ = pad; + } +} + + +/** Compute hash value of the string. + * + * @param hinfo hash info structure with information about + * the algorithm, hash seed and with the place + * for the output hash value + * @param len length of the name + * @param name name to be hashed + * @return error code + */ +int ext4_hash_string(ext4_hash_info_t *hinfo, int len, const char *name) +{ + uint32_t hash = 0; + uint32_t minor_hash = 0; + const char *p; + int i; + uint32_t in[8], buf[4]; + void (*str2hashbuf)(const char *, int, uint32_t *, int) = str2hashbuf_signed; + + /* Initialize the default seed for the hash checksum functions */ + buf[0] = 0x67452301; + buf[1] = 0xefcdab89; + buf[2] = 0x98badcfe; + buf[3] = 0x10325476; + + /* Check if the seed is all zero's */ + if (hinfo->seed) { + for (i = 0; i < 4; i++) { + if (hinfo->seed[i] != 0) { + break; + } + } + if (i < 4) { + memcpy(buf, hinfo->seed, sizeof(buf)); + } + } + + switch (hinfo->hash_version) { + case EXT4_HASH_VERSION_LEGACY_UNSIGNED: + hash = hash_unsigned(name, len); + break; + + case EXT4_HASH_VERSION_LEGACY: + hash = hash_signed(name, len); + break; + + + case EXT4_HASH_VERSION_HALF_MD4_UNSIGNED: + str2hashbuf = str2hashbuf_unsigned; + + case EXT4_HASH_VERSION_HALF_MD4: + p = name; + while (len > 0) { + (*str2hashbuf)(p, len, in, 8); + half_md4_transform(buf, in); + len -= 32; + p += 32; + } + minor_hash = buf[2]; + hash = buf[1]; + break; + + + case EXT4_HASH_VERSION_TEA_UNSIGNED: + str2hashbuf = str2hashbuf_unsigned; + + case EXT4_HASH_VERSION_TEA: + p = name; + while (len > 0) { + (*str2hashbuf)(p, len, in, 4); + tea_transform(buf, in); + len -= 16; + p += 16; + } + hash = buf[0]; + minor_hash = buf[1]; + break; + + default: + hinfo->hash = 0; + return EINVAL; + } + + hash = hash & ~1; + if (hash == (EXT4_DIRECTORY_HTREE_EOF << 1)) { + hash = (EXT4_DIRECTORY_HTREE_EOF-1) << 1; + } + + hinfo->hash = hash; + hinfo->minor_hash = minor_hash; + + return EOK; +} + +/** + * @} + */ Index: uspace/lib/ext4/libext4_hash.h =================================================================== --- uspace/lib/ext4/libext4_hash.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_hash.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_HASH_H_ +#define LIBEXT4_LIBEXT4_HASH_H_ + +#include +#include "libext4_types.h" + +extern int ext4_hash_string(ext4_hash_info_t *, int, const char *); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_ialloc.c =================================================================== --- uspace/lib/ext4/libext4_ialloc.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_ialloc.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,270 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_ialloc.c + * @brief Inode (de)allocation operations. + */ + +#include +#include +#include "libext4.h" + + +/** Convert i-node number to relative index in block group. + * + * @param sb superblock + * @param inode i-node number to be converted + * @return index of the i-node in the block group + */ +static uint32_t ext4_ialloc_inode2index_in_group(ext4_superblock_t *sb, + uint32_t inode) +{ + uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb); + return (inode - 1) % inodes_per_group; +} + +/** Convert relative index of i-node to absolute i-node number. + * + * @param sb superblock + * @param inode index to be converted + * @return absolute number of the i-node + */ +static uint32_t ext4_ialloc_index_in_group2inode(ext4_superblock_t *sb, + uint32_t index, uint32_t bgid) +{ + uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb); + return bgid * inodes_per_group + (index + 1); +} + +/** Compute block group number from the i-node number. + * + * @param sb superblock + * @param inode i-node number to be found the block group for + * @return block group number computed from i-node number + */ +static uint32_t ext4_ialloc_get_bgid_of_inode(ext4_superblock_t *sb, + uint32_t inode) +{ + uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb); + return (inode - 1) / inodes_per_group; + +} + + +/** Free i-node number and modify filesystem data structers. + * + * @param fs filesystem, where the i-node is located + * @param index index of i-node to be release + * @param is_dir flag us for information whether i-node is directory or not + */ +int ext4_ialloc_free_inode(ext4_filesystem_t *fs, uint32_t index, bool is_dir) +{ + int rc; + + ext4_superblock_t *sb = fs->superblock; + + /* Compute index of block group and load it */ + uint32_t block_group = ext4_ialloc_get_bgid_of_inode(sb, index); + + ext4_block_group_ref_t *bg_ref; + rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref); + if (rc != EOK) { + return rc; + } + + /* Load i-node bitmap */ + uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap( + bg_ref->block_group, sb); + block_t *bitmap_block; + rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + /* 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 */ + rc = block_put(bitmap_block); + if (rc != EOK) { + /* 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 (is_dir) { + uint32_t bg_used_dirs = ext4_block_group_get_used_dirs_count( + bg_ref->block_group, sb); + bg_used_dirs--; + ext4_block_group_set_used_dirs_count( + bg_ref->block_group, sb, bg_used_dirs); + } + + /* Update block group free inodes count */ + uint32_t free_inodes = ext4_block_group_get_free_inodes_count( + bg_ref->block_group, sb); + free_inodes++; + ext4_block_group_set_free_inodes_count(bg_ref->block_group, + sb, free_inodes); + + bg_ref->dirty = true; + + /* Put back the modified block group */ + rc = ext4_filesystem_put_block_group_ref(bg_ref); + if (rc != EOK) { + return rc; + } + + /* Update superblock free inodes count */ + uint32_t sb_free_inodes = ext4_superblock_get_free_inodes_count(sb); + sb_free_inodes++; + ext4_superblock_set_free_inodes_count(sb, sb_free_inodes); + + return EOK; +} + +/** I-node allocation algorithm. + * + * This is more simple algorithm, than Orlov allocator used in the Linux kernel + * + * @param fs filesystem to allocate i-node on + * @param index output value - allocated i-node number + * @param is_dir flag if allocated i-node will be file or directory + * @return error code + */ +int ext4_ialloc_alloc_inode(ext4_filesystem_t *fs, uint32_t *index, bool is_dir) +{ + int rc; + + ext4_superblock_t *sb = fs->superblock; + + uint32_t bgid = 0; + uint32_t bg_count = ext4_superblock_get_block_group_count(sb); + uint32_t sb_free_inodes = ext4_superblock_get_free_inodes_count(sb); + uint32_t avg_free_inodes = sb_free_inodes / bg_count; + + /* Try to find free i-node in all block groups */ + while (bgid < bg_count) { + + /* Load block group to check */ + ext4_block_group_ref_t *bg_ref; + rc = ext4_filesystem_get_block_group_ref(fs, bgid, &bg_ref); + if (rc != EOK) { + return rc; + } + + ext4_block_group_t *bg = bg_ref->block_group; + + /* 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 */ + if ((free_inodes >= avg_free_inodes) && (free_blocks > 0)) { + + /* Load block with bitmap */ + uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap( + bg_ref->block_group, sb); + + block_t *bitmap_block; + rc = block_get(&bitmap_block, fs->device, + bitmap_block_addr, BLOCK_FLAGS_NONE); + if (rc != EOK) { + return rc; + } + + /* 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; + rc = ext4_bitmap_find_free_bit_and_set( + bitmap_block->data, 0, &index_in_group, inodes_in_group); + + /* Block group has not any free i-node */ + if (rc == ENOSPC) { + block_put(bitmap_block); + ext4_filesystem_put_block_group_ref(bg_ref); + continue; + } + + /* Free i-node found, save the bitmap */ + bitmap_block->dirty = true; + + rc = block_put(bitmap_block); + if (rc != EOK) { + return rc; + } + + /* Modify filesystem counters */ + free_inodes--; + ext4_block_group_set_free_inodes_count(bg, sb, free_inodes); + + /* Increment used directories counter */ + if (is_dir) { + used_dirs++; + ext4_block_group_set_used_dirs_count(bg, sb, used_dirs); + } + + /* Save modified block group */ + bg_ref->dirty = true; + + rc = ext4_filesystem_put_block_group_ref(bg_ref); + if (rc != EOK) { + return rc; + } + + /* Update superblock */ + sb_free_inodes--; + ext4_superblock_set_free_inodes_count(sb, sb_free_inodes); + + /* Compute the absolute i-nodex number */ + *index = ext4_ialloc_index_in_group2inode(sb, index_in_group, bgid); + + return EOK; + + } + + /* Block group not modified, put it and jump to the next block group */ + ext4_filesystem_put_block_group_ref(bg_ref); + ++bgid; + } + + return ENOSPC; +} + +/** + * @} + */ Index: uspace/lib/ext4/libext4_ialloc.h =================================================================== --- uspace/lib/ext4/libext4_ialloc.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_ialloc.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_IALLOC_H_ +#define LIBEXT4_LIBEXT4_IALLOC_H_ + +#include "libext4_types.h" + +extern int ext4_ialloc_free_inode(ext4_filesystem_t *, uint32_t, bool); +extern int ext4_ialloc_alloc_inode(ext4_filesystem_t *, uint32_t *, bool); +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_inode.c =================================================================== --- uspace/lib/ext4/libext4_inode.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_inode.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,531 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_inode.c + * @brief Ext4 inode structure operations. + */ + +#include +#include +#include +#include "libext4.h" + +/** Compute number of bits for block count. + * + * @param block_size filesystem block_size + * @return number of bits + */ +static uint32_t ext4_inode_block_bits_count(uint32_t block_size) +{ + uint32_t bits = 8; + uint32_t size = block_size; + + do { + bits++; + size = size >> 1; + } while (size > 256); + + return bits; +} + +/** Get mode of the i-node. + * + * @param sb superblock + * @param inode i-node to load mode from + * @return mode of the i-node + */ +uint32_t ext4_inode_get_mode(ext4_superblock_t *sb, ext4_inode_t *inode) +{ + if (ext4_superblock_get_creator_os(sb) == EXT4_SUPERBLOCK_OS_HURD) { + return ((uint32_t)uint16_t_le2host(inode->osd2.hurd2.mode_high)) << 16 | + ((uint32_t)uint16_t_le2host(inode->mode)); + } + return uint16_t_le2host(inode->mode); +} + +/** Set mode of the i-node. + * + * @param sb superblock + * @param inode i-node to set mode to + * @param mode mode to set to i-node + */ +void ext4_inode_set_mode(ext4_superblock_t *sb, ext4_inode_t *inode, uint32_t mode) +{ + inode->mode = host2uint16_t_le((mode << 16) >> 16); + + if (ext4_superblock_get_creator_os(sb) == EXT4_SUPERBLOCK_OS_HURD) { + inode->osd2.hurd2.mode_high = host2uint16_t_le(mode >> 16); + } +} + +/** Get ID of the i-node owner (user id). + * + * @param inode i-node to load uid from + * @return user ID of the i-node owner + */ +uint32_t ext4_inode_get_uid(ext4_inode_t *inode) +{ + return uint32_t_le2host(inode->uid); +} + +/** Set ID of the i-node owner. + * + * @param inode i-node to set uid to + * @param uid ID of the i-node owner + */ +void ext4_inode_set_uid(ext4_inode_t *inode, uint32_t uid) +{ + inode->uid = host2uint32_t_le(uid); +} + +/** Get real i-node size. + * + * @param sb superblock + * @param inode i-node to load size from + * @return real size of i-node + */ +uint64_t ext4_inode_get_size(ext4_superblock_t *sb, ext4_inode_t *inode) +{ + uint32_t major_rev = ext4_superblock_get_rev_level(sb); + + if ((major_rev > 0) && ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_FILE)) { + return ((uint64_t)uint32_t_le2host(inode->size_hi)) << 32 | + ((uint64_t)uint32_t_le2host(inode->size_lo)); + } + return uint32_t_le2host(inode->size_lo); +} + +/** Set real i-node size. + * + * @param inode inode to set size to + * @param size size of the i-node + */ +void ext4_inode_set_size(ext4_inode_t *inode, uint64_t size) { + inode->size_lo = host2uint32_t_le((size << 32) >> 32); + inode->size_hi = host2uint32_t_le(size >> 32); +} + +/** Get time, when i-node was last accessed. + * + * @param inode i-node + * @return time of the last access (POSIX) + */ +uint32_t ext4_inode_get_access_time(ext4_inode_t *inode) +{ + return uint32_t_le2host(inode->access_time); +} + +/** Set time, when i-node was last accessed. + * + * @param inode i-node + * @param time time of the last access (POSIX) + */ +void ext4_inode_set_access_time(ext4_inode_t *inode, uint32_t time) +{ + inode->access_time = host2uint32_t_le(time); +} + +/** Get time, when i-node was last changed. + * + * @param inode i-node + * @return time of the last change (POSIX) + */ +uint32_t ext4_inode_get_change_inode_time(ext4_inode_t *inode) +{ + return uint32_t_le2host(inode->change_inode_time); +} + +/** Set time, when i-node was last changed. + * + * @param inode i-node + * @param time time of the last change (POSIX) + */ +void ext4_inode_set_change_inode_time(ext4_inode_t *inode, uint32_t time) +{ + inode->change_inode_time = host2uint32_t_le(time); +} + +/** Get time, when i-node content was last modified. + * + * @param inode i-node + * @return time of the last content modification (POSIX) + */ +uint32_t ext4_inode_get_modification_time(ext4_inode_t *inode) +{ + return uint32_t_le2host(inode->modification_time); +} + +/** Set time, when i-node content was last modified. + * + * @param inode i-node + * @param time time of the last content modification (POSIX) + */ +void ext4_inode_set_modification_time(ext4_inode_t *inode, uint32_t time) +{ + inode->modification_time = host2uint32_t_le(time); +} + +/** Get time, when i-node was deleted. + * + * @param inode i-node + * @return time of the delete action (POSIX) + */ +uint32_t ext4_inode_get_deletion_time(ext4_inode_t *inode) +{ + return uint32_t_le2host(inode->deletion_time); +} + +/** Set time, when i-node was deleted. + * + * @param inode i-node + * @param time time of the delete action (POSIX) + */ +void ext4_inode_set_deletion_time(ext4_inode_t *inode, uint32_t time) +{ + inode->deletion_time = host2uint32_t_le(time); +} + +/** Get ID of the i-node owner's group. + * + * @param inode i-node to load gid from + * @return group ID of the i-node owner + */ +uint32_t ext4_inode_get_gid(ext4_inode_t *inode) +{ + return uint32_t_le2host(inode->gid); +} + +/** Set ID ot the i-node owner's group. + * + * @param inode i-node to set gid to + * @param gid group ID of the i-node owner + */ +void ext4_inode_set_gid(ext4_inode_t *inode, uint32_t gid) +{ + inode->gid = host2uint32_t_le(gid); +} + +/** Get number of links to i-node. + * + * @param inode i-node to load number of links from + * @return number of links to i-node + */ +uint16_t ext4_inode_get_links_count(ext4_inode_t *inode) +{ + return uint16_t_le2host(inode->links_count); +} + +/** Set number of links to i-node. + * + * @param inode i-node to set number of links to + * @param count number of links to i-node + */ +void ext4_inode_set_links_count(ext4_inode_t *inode, uint16_t count) +{ + inode->links_count = host2uint16_t_le(count); +} + +/** Get number of 512-bytes blocks used for i-node. + * + * @param sb superblock + * @param inode i-node + * @return number of 512-bytes blocks + */ +uint64_t ext4_inode_get_blocks_count(ext4_superblock_t *sb, ext4_inode_t *inode) +{ + if (ext4_superblock_has_feature_read_only(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) { + + /* 48-bit field */ + uint64_t count = ((uint64_t)uint16_t_le2host(inode->osd2.linux2.blocks_high)) << 32 | + uint32_t_le2host(inode->blocks_count_lo); + + if (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_HUGE_FILE)) { + uint32_t block_size = ext4_superblock_get_block_size(sb); + uint32_t block_bits = ext4_inode_block_bits_count(block_size); + return count << (block_bits - 9); + } else { + return count; + } + } else { + return uint32_t_le2host(inode->blocks_count_lo); + } +} + +/** Set number of 512-bytes blocks used for i-node. + * + * @param sb superblock + * @param inode i-node + * @param count number of 512-bytes blocks + * @return error code + */ +int ext4_inode_set_blocks_count(ext4_superblock_t *sb, ext4_inode_t *inode, + uint64_t count) +{ + /* 32-bit maximum */ + uint64_t max = 0; + max = ~max >> 32; + + if (count <= max) { + inode->blocks_count_lo = host2uint32_t_le(count); + inode->osd2.linux2.blocks_high = 0; + ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE); + return EOK; + } + + /* 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 */ + max = 0; + max = ~max >> 16; + + if (count <= max) { + inode->blocks_count_lo = host2uint32_t_le(count); + inode->osd2.linux2.blocks_high = host2uint16_t_le(count >> 32); + ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE); + } else { + uint32_t block_size = ext4_superblock_get_block_size(sb); + uint32_t block_bits = ext4_inode_block_bits_count(block_size); + ext4_inode_set_flag(inode, EXT4_INODE_FLAG_HUGE_FILE); + count = count >> (block_bits - 9); + inode->blocks_count_lo = host2uint32_t_le(count); + inode->osd2.linux2.blocks_high = host2uint16_t_le(count >> 32); + } + return EOK; +} + +/** Get flags (features) of i-node. + * + * @param inode i-node to get flags from + * @return flags (bitmap) + */ +uint32_t ext4_inode_get_flags(ext4_inode_t *inode) { + return uint32_t_le2host(inode->flags); +} + +/** Set flags (features) of i-node. + * + * @param inode i-node to set flags to + * @param flags flags to set to i-node + */ +void ext4_inode_set_flags(ext4_inode_t *inode, uint32_t flags) { + inode->flags = host2uint32_t_le(flags); +} + +/** Get file generation (used by NFS). + * + * @param inode i-node + * @return file generation + */ +uint32_t ext4_inode_get_generation(ext4_inode_t *inode) +{ + return uint32_t_le2host(inode->generation); +} + +/** Set file generation (used by NFS). + * + * @param inode i-node + * @param generation file generation + */ +void ext4_inode_set_generation(ext4_inode_t *inode, uint32_t generation) +{ + inode->generation = host2uint32_t_le(generation); +} + +/** Get address of block, where are extended attributes located. + * + * @param inode i-node + * @param sb superblock + * @return block address + */ +uint64_t ext4_inode_get_file_acl(ext4_inode_t *inode, ext4_superblock_t *sb) +{ + if (ext4_superblock_get_creator_os(sb) == EXT4_SUPERBLOCK_OS_LINUX) { + return ((uint32_t)uint16_t_le2host(inode->osd2.linux2.file_acl_high)) << 16 | + (uint32_t_le2host(inode->file_acl_lo)); + } + + return uint32_t_le2host(inode->file_acl_lo); +} + +/** Set address of block, where are extended attributes located. + * + * @param inode i-node + * @param sb superblock + * @param file_acl block address + */ +void ext4_inode_set_file_acl(ext4_inode_t *inode, ext4_superblock_t *sb, + uint64_t file_acl) +{ + inode->file_acl_lo = host2uint32_t_le((file_acl << 32) >> 32); + + if (ext4_superblock_get_creator_os(sb) == EXT4_SUPERBLOCK_OS_LINUX) { + inode->osd2.linux2.file_acl_high = host2uint16_t_le(file_acl >> 32); + } +} + +/***********************************************************************/ + +/** Get block address of specified direct block. + * + * @param inode i-node to load block from + * @param idx index of logical block + * @return physical block address + */ +uint32_t ext4_inode_get_direct_block(ext4_inode_t *inode, uint32_t idx) +{ + assert(idx < EXT4_INODE_DIRECT_BLOCK_COUNT); + return uint32_t_le2host(inode->blocks[idx]); +} + +/** Set block address of specified direct block. + * + * @param inode i-node to set block address to + * @param idx index of logical block + * @param fblock physical block address + */ +void ext4_inode_set_direct_block(ext4_inode_t *inode, uint32_t idx, uint32_t fblock) +{ + assert(idx < EXT4_INODE_DIRECT_BLOCK_COUNT); + inode->blocks[idx] = host2uint32_t_le(fblock); +} + +/** Get block address of specified indirect block. + * + * @param inode i-node to get block address from + * @param idx index of indirect block + * @return physical block address + */ +uint32_t ext4_inode_get_indirect_block(ext4_inode_t *inode, uint32_t idx) +{ + return uint32_t_le2host(inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK]); +} + +/** Set block address of specified indirect block. + * + * @param inode i-node to set block address to + * @param idx index of indirect block + * @param fblock physical block address + */ +void ext4_inode_set_indirect_block(ext4_inode_t *inode, uint32_t idx, uint32_t fblock) +{ + inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK] = host2uint32_t_le(fblock); +} + +/** Check if i-node has specified type. + * + * @param sb superblock + * @param inode i-node to check type of + * @param type type to check + * @return result of check operation + */ +bool ext4_inode_is_type(ext4_superblock_t *sb, ext4_inode_t *inode, uint32_t type) +{ + uint32_t mode = ext4_inode_get_mode(sb, inode); + return (mode & EXT4_INODE_MODE_TYPE_MASK) == type; +} + +/** Get extent header from the root of the extent tree. + * + * @param inode i-node to get extent header from + * @return pointer to extent header of the root node + */ +ext4_extent_header_t * ext4_inode_get_extent_header(ext4_inode_t *inode) +{ + return (ext4_extent_header_t *)inode->blocks; +} + +/** Check if i-node has specified flag. + * + * @param inode i-node to check flags of + * @param flag flag to check + * @return result of check operation + */ +bool ext4_inode_has_flag(ext4_inode_t *inode, uint32_t flag) +{ + if (ext4_inode_get_flags(inode) & flag) { + return true; + } + return false; +} + +/** Remove specified flag from i-node. + * + * @param inode i-node to clear flag on + * @param clear_flag flag to be cleared + */ +void ext4_inode_clear_flag(ext4_inode_t *inode, uint32_t clear_flag) +{ + uint32_t flags = ext4_inode_get_flags(inode); + flags = flags & (~clear_flag); + ext4_inode_set_flags(inode, flags); +} + +/** Set specified flag to i-node. + * + * @param inode i-node to set flag on + * @param set_flag falt to be set + */ +void ext4_inode_set_flag(ext4_inode_t *inode, uint32_t set_flag) +{ + uint32_t flags = ext4_inode_get_flags(inode); + flags = flags | set_flag; + ext4_inode_set_flags(inode, flags); +} + +/** Check if i-node can be truncated. + * + * @param sb superblock + * @param inode i-node to check + * @return result of the check operation + */ +bool ext4_inode_can_truncate(ext4_superblock_t *sb, ext4_inode_t *inode) +{ + if (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_APPEND) + || ext4_inode_has_flag(inode, EXT4_INODE_FLAG_IMMUTABLE)) { + return false; + } + + if (ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_FILE) + || ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_DIRECTORY)) { + return true; + } + + return false; +} + +/** + * @} + */ Index: uspace/lib/ext4/libext4_inode.h =================================================================== --- uspace/lib/ext4/libext4_inode.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_inode.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_INODE_H_ +#define LIBEXT4_LIBEXT4_INODE_H_ + +#include +#include +#include "libext4_types.h" + +extern uint32_t ext4_inode_get_mode(ext4_superblock_t *, ext4_inode_t *); +extern void ext4_inode_set_mode(ext4_superblock_t *, ext4_inode_t *, uint32_t); +extern uint32_t ext4_inode_get_uid(ext4_inode_t *); +extern void ext4_inode_set_uid(ext4_inode_t *, uint32_t); +extern uint64_t ext4_inode_get_size(ext4_superblock_t *, ext4_inode_t *); +extern void ext4_inode_set_size(ext4_inode_t *, uint64_t); +extern uint32_t ext4_inode_get_access_time(ext4_inode_t *); +extern void ext4_inode_set_access_time(ext4_inode_t *, uint32_t); +extern uint32_t ext4_inode_get_change_inode_time(ext4_inode_t *); +extern void ext4_inode_set_change_inode_time(ext4_inode_t *, uint32_t); +extern uint32_t ext4_inode_get_modification_time(ext4_inode_t *); +extern void ext4_inode_set_modification_time(ext4_inode_t *, uint32_t); +extern uint32_t ext4_inode_get_deletion_time(ext4_inode_t *); +extern void ext4_inode_set_deletion_time(ext4_inode_t *, uint32_t); +extern uint32_t ext4_inode_get_gid(ext4_inode_t *); +extern void ext4_inode_set_gid(ext4_inode_t *, uint32_t); +extern uint16_t ext4_inode_get_links_count(ext4_inode_t *); +extern void ext4_inode_set_links_count(ext4_inode_t *, uint16_t); +extern uint64_t ext4_inode_get_blocks_count(ext4_superblock_t *, ext4_inode_t *); +extern int ext4_inode_set_blocks_count(ext4_superblock_t *, ext4_inode_t *, uint64_t); +extern uint32_t ext4_inode_get_flags(ext4_inode_t *); +extern void ext4_inode_set_flags(ext4_inode_t *, uint32_t); +extern uint32_t ext4_inode_get_generation(ext4_inode_t *); +extern void ext4_inode_set_generation(ext4_inode_t *, uint32_t); +extern uint64_t ext4_inode_get_file_acl(ext4_inode_t *, ext4_superblock_t *); +extern void ext4_inode_set_file_acl(ext4_inode_t *, ext4_superblock_t *, uint64_t); +/* +uint16_t extra_isize; +uint32_t ctime_extra; // Extra change time (nsec << 2 | epoch) +uint32_t mtime_extra; // Extra Modification time (nsec << 2 | epoch) +uint32_t atime_extra; // Extra Access time (nsec << 2 | epoch) +uint32_t crtime; // File creation time +uint32_t crtime_extra; // Extra file creation time (nsec << 2 | epoch) +uint32_t version_hi; // High 32 bits for 64-bit version +*/ + +/******************************************/ + +extern uint32_t ext4_inode_get_direct_block(ext4_inode_t *, uint32_t); +extern void ext4_inode_set_direct_block(ext4_inode_t *, uint32_t, uint32_t); +extern uint32_t ext4_inode_get_indirect_block(ext4_inode_t *, uint32_t); +extern void ext4_inode_set_indirect_block(ext4_inode_t *, uint32_t, uint32_t); +extern ext4_extent_header_t * ext4_inode_get_extent_header(ext4_inode_t *); +extern bool ext4_inode_is_type(ext4_superblock_t *, ext4_inode_t *, uint32_t); +extern bool ext4_inode_has_flag(ext4_inode_t *, uint32_t); +extern void ext4_inode_clear_flag(ext4_inode_t *, uint32_t); +extern void ext4_inode_set_flag(ext4_inode_t *, uint32_t); +extern bool ext4_inode_can_truncate(ext4_superblock_t *, ext4_inode_t *); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_superblock.c =================================================================== --- uspace/lib/ext4/libext4_superblock.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_superblock.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,1148 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +/** + * @file libext4_superblock.c + * @brief Ext4 superblock operations. + */ + +#include +#include +#include +#include +#include "libext4.h" + +/** Get number of i-nodes in the whole filesystem. + * + * @param sb superblock + * @return number of i-nodes + */ +uint32_t ext4_superblock_get_inodes_count(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->inodes_count); +} + +/** Set number of i-nodes in the whole filesystem. + * + * @param sb superblock + * @param count number of i-nodes + */ +void ext4_superblock_set_inodes_count(ext4_superblock_t *sb, uint32_t count) +{ + sb->inodes_count = host2uint32_t_le(count); +} + +/** Get number of data blocks in the whole filesystem. + * + * @param sb superblock + * @return number of data blocks + */ +uint64_t ext4_superblock_get_blocks_count(ext4_superblock_t *sb) +{ + return ((uint64_t)uint32_t_le2host(sb->blocks_count_hi) << 32) | + uint32_t_le2host(sb->blocks_count_lo); +} + +/** Set number of data blocks in the whole filesystem. + * + * @param sb superblock + * @param count number of data blocks + */ +void ext4_superblock_set_blocks_count(ext4_superblock_t *sb, uint64_t count) +{ + sb->blocks_count_lo = host2uint32_t_le((count << 32) >> 32); + sb->blocks_count_hi = host2uint32_t_le(count >> 32); +} + +/** Get number of reserved data blocks in the whole filesystem. + * + * @param sb superblock + * @return number of reserved data blocks + */ +uint64_t ext4_superblock_get_reserved_blocks_count(ext4_superblock_t *sb) +{ + return ((uint64_t)uint32_t_le2host(sb->reserved_blocks_count_hi) << 32) | + uint32_t_le2host(sb->reserved_blocks_count_lo); +} + +/** Set number of reserved data blocks in the whole filesystem. + * + * @param sb superblock + * @param count number of reserved data blocks + */ +void ext4_superblock_set_reserved_blocks_count(ext4_superblock_t *sb, uint64_t count) +{ + sb->reserved_blocks_count_lo = host2uint32_t_le((count << 32) >> 32); + sb->reserved_blocks_count_hi = host2uint32_t_le(count >> 32); +} + +/** Get number of free data blocks in the whole filesystem. + * + * @param sb superblock + * @return number of free data blocks + */ +uint64_t ext4_superblock_get_free_blocks_count(ext4_superblock_t *sb) +{ + return ((uint64_t)uint32_t_le2host(sb->free_blocks_count_hi) << 32) | + uint32_t_le2host(sb->free_blocks_count_lo); +} + +/** Set number of free data blocks in the whole filesystem. + * + * @param sb superblock + * @param count number of free data blocks + */ +void ext4_superblock_set_free_blocks_count(ext4_superblock_t *sb, uint64_t count) +{ + sb->free_blocks_count_lo = host2uint32_t_le((count << 32) >> 32); + sb->free_blocks_count_hi = host2uint32_t_le(count >> 32); +} + +/** Get number of free i-nodes in the whole filesystem. + * + * @param sb superblock + * @return number of free i-nodes + */ +uint32_t ext4_superblock_get_free_inodes_count(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->free_inodes_count); +} + +/** Set number of free i-nodes in the whole filesystem. + * + * @param sb superblock + * @param count number of free i-nodes + */ +void ext4_superblock_set_free_inodes_count(ext4_superblock_t *sb, uint32_t count) +{ + sb->free_inodes_count = host2uint32_t_le(count); +} + +/** Get index of first data block (block, where is located superblock) + * + * @param sb superblock + * @return index of the first data block + */ +uint32_t ext4_superblock_get_first_data_block(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->first_data_block); +} + +/** Set index of first data block (block, where is located superblock) + * + * @param sb superblock + * @param first index of the first data block + */ +void ext4_superblock_set_first_data_block(ext4_superblock_t *sb, uint32_t first) +{ + sb->first_data_block = host2uint32_t_le(first); +} + +/** Get logarithmic block size (1024 << size == block_size) + * + * @param sb superblock + * @return logarithmic block size + */ +uint32_t ext4_superblock_get_log_block_size(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->log_block_size); +} + +/** Set logarithmic block size (1024 << size == block_size) + * + * @param sb superblock + * @return logarithmic block size + */ +void ext4_superblock_set_log_block_size(ext4_superblock_t *sb, uint32_t log_size) +{ + sb->log_block_size = host2uint32_t_le(log_size); +} + +/** Get size of data block (in bytes). + * + * @param sb superblock + * @return size of data block + */ +uint32_t ext4_superblock_get_block_size(ext4_superblock_t *sb) +{ + return 1024 << ext4_superblock_get_log_block_size(sb); +} + +/** Set size of data block (in bytes). + * + * @param sb superblock + * @param size size of data block (must be power of 2, at least 1024) + */ +void ext4_superblock_set_block_size(ext4_superblock_t *sb, uint32_t size) +{ + uint32_t log = 0; + uint32_t tmp = size / EXT4_MIN_BLOCK_SIZE; + + tmp >>= 1; + while (tmp) { + log++; + tmp >>= 1; + } + + ext4_superblock_set_log_block_size(sb, log); +} + +/** Get logarithmic fragment size (1024 << size) + * + * @param sb superblock + * @return logarithmic fragment size + */ +uint32_t ext4_superblock_get_log_frag_size(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->log_frag_size); +} + +/** Set logarithmic fragment size (1024 << size) + * + * @param sb superblock + * @return logarithmic fragment size + */ + +void ext4_superblock_set_log_frag_size(ext4_superblock_t *sb, uint32_t frag_size) +{ + sb->log_frag_size = host2uint32_t_le(frag_size); +} + +/** Get size of fragment (in bytes). + * + * @param sb superblock + * @return size of fragment + */ +uint32_t ext4_superblock_get_frag_size(ext4_superblock_t *sb) +{ + return 1024 << ext4_superblock_get_log_frag_size(sb); +} + +/** Set size of fragment (in bytes). + * + * @param sb superblock + * @param size size of fragment (must be power of 2, at least 1024) + */ +void ext4_superblock_set_frag_size(ext4_superblock_t *sb, uint32_t size) +{ + uint32_t log = 0; + uint32_t tmp = size / EXT4_MIN_BLOCK_SIZE; + + tmp >>= 1; + while (tmp) { + log++; + tmp >>= 1; + } + + ext4_superblock_set_log_frag_size(sb, log); +} + +/** Get number of data blocks per block group (except last BG) + * + * @param sb superblock + * @return data blocks per block group + */ +uint32_t ext4_superblock_get_blocks_per_group(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->blocks_per_group); +} + +/** Set number of data blocks per block group (except last BG) + * + * @param sb superblock + * @param blocks data blocks per block group + */ +void ext4_superblock_set_blocks_per_group(ext4_superblock_t *sb, uint32_t blocks) +{ + sb->blocks_per_group = host2uint32_t_le(blocks); +} + +/** Get number of fragments per block group (except last BG) + * + * @param sb superblock + * @return fragments per block group + */ +uint32_t ext4_superblock_get_frags_per_group(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->frags_per_group); +} + +/** Set number of fragment per block group (except last BG) + * + * @param sb superblock + * @param frags fragments per block group + */ +void ext4_superblock_set_frags_per_group(ext4_superblock_t *sb, uint32_t frags) +{ + sb->frags_per_group = host2uint32_t_le(frags); +} + + +/** Get number of i-nodes per block group (except last BG) + * + * @param sb superblock + * @return i-nodes per block group + */ +uint32_t ext4_superblock_get_inodes_per_group(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->inodes_per_group); +} + +/** Set number of i-nodes per block group (except last BG) + * + * @param sb superblock + * @param inodes i-nodes per block group + */ +void ext4_superblock_set_inodes_per_group(ext4_superblock_t *sb, uint32_t inodes) +{ + sb->inodes_per_group = host2uint32_t_le(inodes); +} + +/** Get time when filesystem was mounted (POSIX time). + * + * @param sb superblock + * @return mount time + */ +uint32_t ext4_superblock_get_mount_time(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->mount_time); +} + +/** Set time when filesystem was mounted (POSIX time). + * + * @param sb superblock + * @param time mount time + */ +void ext4_superblock_set_mount_time(ext4_superblock_t *sb, uint32_t time) +{ + sb->mount_time = host2uint32_t_le(time); +} + +/** Get time when filesystem was last accesed by write operation (POSIX time). + * + * @param sb superblock + * @return write time + */ +uint32_t ext4_superblock_get_write_time(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->write_time); +} + +/** Set time when filesystem was last accesed by write operation (POSIX time). + * + * @param sb superblock + * @param time write time + */ +void ext4_superblock_set_write_time(ext4_superblock_t *sb, uint32_t time) +{ + sb->write_time = host2uint32_t_le(time); +} + +/** Get number of mount from last filesystem check. + * + * @param sb superblock + * @return number of mounts + */ +uint16_t ext4_superblock_get_mount_count(ext4_superblock_t *sb) +{ + return uint16_t_le2host(sb->mount_count); +} + +/** Set number of mount from last filesystem check. + * + * @param sb superblock + * @param count number of mounts + */ +void ext4_superblock_set_mount_count(ext4_superblock_t *sb, uint16_t count) +{ + sb->mount_count = host2uint16_t_le(count); +} + +/** Get maximum number of mount from last filesystem check. + * + * @param sb superblock + * @return maximum number of mounts + */ +uint16_t ext4_superblock_get_max_mount_count(ext4_superblock_t *sb) +{ + return uint16_t_le2host(sb->max_mount_count); +} + +/** Set maximum number of mount from last filesystem check. + * + * @param sb superblock + * @param count maximum number of mounts + */ +void ext4_superblock_set_max_mount_count(ext4_superblock_t *sb, uint16_t count) +{ + sb->max_mount_count = host2uint16_t_le(count); +} + +/** Get superblock magic value. + * + * @param sb superblock + * @return magic value + */ +uint16_t ext4_superblock_get_magic(ext4_superblock_t *sb) +{ + return uint16_t_le2host(sb->magic); +} + +/** Set superblock magic value. + * + * @param sb superblock + * @param magic value + */ +void ext4_superblock_set_magic(ext4_superblock_t *sb, uint16_t magic) +{ + sb->magic = host2uint16_t_le(magic); +} + +/** Get filesystem state. + * + * @param sb superblock + * @return filesystem state + */ +uint16_t ext4_superblock_get_state(ext4_superblock_t *sb) +{ + return uint16_t_le2host(sb->state); +} + +/** Set filesystem state. + * + * @param sb superblock + * @param state filesystem state + */ +void ext4_superblock_set_state(ext4_superblock_t *sb, uint16_t state) +{ + sb->state = host2uint16_t_le(state); +} + +/** Get behavior code when errors detected. + * + * @param sb superblock + * @return behavior code + */ +uint16_t ext4_superblock_get_errors(ext4_superblock_t *sb) +{ + return uint16_t_le2host(sb->errors); +} + +/** Set behavior code when errors detected. + * + * @param sb superblock + * @param errors behavior code + */ +void ext4_superblock_set_errors(ext4_superblock_t *sb, uint16_t errors) +{ + sb->errors = host2uint16_t_le(errors); +} + +/** Get minor revision level of the filesystem. + * + * @param sb superblock + * @return minor revision level + */ +uint16_t ext4_superblock_get_minor_rev_level(ext4_superblock_t *sb) +{ + return uint16_t_le2host(sb->minor_rev_level); +} + +/** Set minor revision level of the filesystem. + * + * @param sb superblock + * @param level minor revision level + */ +void ext4_superblock_set_minor_rev_level(ext4_superblock_t *sb, uint16_t level) +{ + sb->minor_rev_level = host2uint16_t_le(level); +} + +/** Get time of the last filesystem check. + * + * @param sb superblock + * @return time of the last check (POSIX) + */ +uint32_t ext4_superblock_get_last_check_time(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->last_check_time); +} + +/** Set time of the last filesystem check. + * + * @param sb superblock + * @param time time of the last check (POSIX) + */ +void ext4_superblock_set_last_check_time(ext4_superblock_t *sb, uint32_t time) +{ + sb->state = host2uint32_t_le(time); +} + +/** Get maximum time interval between two filesystem checks. + * + * @param sb superblock + * @return time interval between two check (POSIX) + */ +uint32_t ext4_superblock_get_check_interval(ext4_superblock_t *sb){ + return uint32_t_le2host(sb->check_interval); +} + +/** Set maximum time interval between two filesystem checks. + * + * @param sb superblock + * @param interval time interval between two check (POSIX) + */ +void ext4_superblock_set_check_interval(ext4_superblock_t *sb, uint32_t interval) +{ + sb->check_interval = host2uint32_t_le(interval); +} + +/** Get operation system identifier, on which the filesystem was created. + * + * @param sb superblock + * @return operation system identifier + */ +uint32_t ext4_superblock_get_creator_os(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->creator_os); +} + +/** Set operation system identifier, on which the filesystem was created. + * + * @param sb superblock + * @param os operation system identifier + */ +void ext4_superblock_set_creator_os(ext4_superblock_t *sb, uint32_t os) +{ + sb->creator_os = host2uint32_t_le(os); +} + +/** Get revision level of the filesystem. + * + * @param sb superblock + * @return revision level + */ +uint32_t ext4_superblock_get_rev_level(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->rev_level); +} + +/** Set revision level of the filesystem. + * + * @param sb superblock + * @param level revision level + */ +void ext4_superblock_set_rev_level(ext4_superblock_t *sb, uint32_t level) +{ + sb->rev_level = host2uint32_t_le(level); +} + +/** Get default user id for reserved blocks. + * + * @param sb superblock + * @return default user id for reserved blocks. + */ +uint16_t ext4_superblock_get_def_resuid(ext4_superblock_t *sb) +{ + return uint16_t_le2host(sb->def_resuid); +} + +/** Set default user id for reserved blocks. + * + * @param sb superblock + * @param uid default user id for reserved blocks. + */ +void ext4_superblock_set_def_resuid(ext4_superblock_t *sb, uint16_t uid) +{ + sb->def_resuid = host2uint16_t_le(uid); +} + +/** Get default group id for reserved blocks. + * + * @param sb superblock + * @return default group id for reserved blocks. + */ +uint16_t ext4_superblock_get_def_resgid(ext4_superblock_t *sb) +{ + return uint16_t_le2host(sb->def_resgid); +} + +/** Set default group id for reserved blocks. + * + * @param sb superblock + * @param gid default group id for reserved blocks. + */ +void ext4_superblock_set_def_resgid(ext4_superblock_t *sb, uint16_t gid) +{ + sb->def_resgid = host2uint16_t_le(gid); +} + +/** Get index of the first i-node, which can be used for allocation. + * + * @param sb superblock + * @return i-node index + */ +uint32_t ext4_superblock_get_first_inode(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->first_inode); +} + +/** Set index of the first i-node, which can be used for allocation. + * + * @param sb superblock + * @param first_inode i-node index + */ +void ext4_superblock_set_first_inode(ext4_superblock_t *sb, uint32_t first_inode) +{ + sb->first_inode = host2uint32_t_le(first_inode); +} + +/** Get size of i-node structure. + * + * For the oldest revision return constant number. + * + * @param sb superblock + * @return size of i-node structure + */ +uint16_t ext4_superblock_get_inode_size(ext4_superblock_t *sb) +{ + if (ext4_superblock_get_rev_level(sb) == 0) { + return EXT4_REV0_INODE_SIZE; + } + return uint16_t_le2host(sb->inode_size); +} + +/** Set size of i-node structure. + * + * @param sb superblock + * @param size size of i-node structure + */ +void ext4_superblock_set_inode_size(ext4_superblock_t *sb, uint16_t size) +{ + sb->inode_size = host2uint16_t_le(size); +} + +/** Get index of block group, where superblock copy is located. + * + * @param sb superblock + * @return block group index + */ +uint16_t ext4_superblock_get_block_group_index(ext4_superblock_t *sb) +{ + return uint16_t_le2host(sb->block_group_index); +} + +/** Set index of block group, where superblock copy is located. + * + * @param sb superblock + * @param bgid block group index + */ +void ext4_superblock_set_block_group_index(ext4_superblock_t *sb, uint16_t bgid) +{ + sb->block_group_index = host2uint16_t_le(bgid); +} + +/** Get compatible features supported by the filesystem. + * + * @param sb superblock + * @return compatible features bitmap + */ +uint32_t ext4_superblock_get_features_compatible(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->features_compatible); +} + +/** Set compatible features supported by the filesystem. + * + * @param sb superblock + * @param features compatible features bitmap + */ +void ext4_superblock_set_features_compatible(ext4_superblock_t *sb, uint32_t features) +{ + sb->features_compatible = host2uint32_t_le(features); +} + +/** Get incompatible features supported by the filesystem. + * + * @param sb superblock + * @return incompatible features bitmap + */ +uint32_t ext4_superblock_get_features_incompatible(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->features_incompatible); +} + +/** Set incompatible features supported by the filesystem. + * + * @param sb superblock + * @param features incompatible features bitmap + */ +void ext4_superblock_set_features_incompatible(ext4_superblock_t *sb, uint32_t features) +{ + sb->features_incompatible = host2uint32_t_le(features); +} + +/** Get compatible features supported by the filesystem. + * + * @param sb superblock + * @return read-only compatible features bitmap + */ +uint32_t ext4_superblock_get_features_read_only(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->features_read_only); +} + +/** Set compatible features supported by the filesystem. + * + * @param sb superblock + * @param feature read-only compatible features bitmap + */ +void ext4_superblock_set_features_read_only(ext4_superblock_t *sb, uint32_t features) +{ + sb->features_read_only = host2uint32_t_le(features); +} + +/** Get UUID of the filesystem. + * + * @param sb superblock + * @return pointer to UUID array + */ +const uint8_t * ext4_superblock_get_uuid(ext4_superblock_t *sb) +{ + return sb->uuid; +} + +/** Set UUID of the filesystem. + * + * @param sb superblock + * @param uuid pointer to UUID array + */ +void ext4_superblock_set_uuid(ext4_superblock_t *sb, const uint8_t *uuid) +{ + memcpy(sb->uuid, uuid, sizeof(sb->uuid)); +} + +/** Get name of the filesystem volume. + * + * @param sb superblock + * @return name of the volume + */ +const char * ext4_superblock_get_volume_name(ext4_superblock_t *sb) +{ + return sb->volume_name; +} + +/** Set name of the filesystem volume. + * + * @param sb superblock + * @param name new name of the volume + */ +void ext4_superblock_set_volume_name(ext4_superblock_t *sb, const char *name) +{ + memcpy(sb->volume_name, name, sizeof(sb->volume_name)); +} + +/** Get name of the directory, where this filesystem was mounted at last. + * + * @param sb superblock + * @return directory name + */ +const char * ext4_superblock_get_last_mounted(ext4_superblock_t *sb) +{ + return sb->last_mounted; +} + +/** Set name of the directory, where this filesystem was mounted at last. + * + * @param sb superblock + * @param last directory name + */ +void ext4_superblock_set_last_mounted(ext4_superblock_t *sb, const char *last) +{ + memcpy(sb->last_mounted, last, sizeof(sb->last_mounted)); +} + +/** Get last orphaned i-node index. + * + * Orphans are stored in linked list. + * + * @param sb superblock + * @return last orphaned i-node index + */ +uint32_t ext4_superblock_get_last_orphan(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->last_orphan); +} + +/** Set last orphaned i-node index. + * + * Orphans are stored in linked list. + * + * @param sb superblock + * @param last_orphan last orphaned i-node index + */ +void ext4_superblock_set_last_orphan(ext4_superblock_t *sb, uint32_t last_orphan) +{ + sb->last_orphan = host2uint32_t_le(last_orphan); +} + +/** Get hash seed for directory index hash function. + * + * @param sb superblock + * @return hash seed pointer + */ +const uint32_t * ext4_superblock_get_hash_seed(ext4_superblock_t *sb) +{ + return sb->hash_seed; +} + +/** Set hash seed for directory index hash function. + * + * @param sb superblock + * @param seed hash seed pointer + */ +void ext4_superblock_set_hash_seed(ext4_superblock_t *sb, const uint32_t *seed) +{ + memcpy(sb->hash_seed, seed, sizeof(sb->hash_seed)); +} + +/** Get default version of the hash algorithm version for directory index. + * + * @param sb superblock + * @return default hash version + */ +uint8_t ext4_superblock_get_default_hash_version(ext4_superblock_t *sb) +{ + return sb->default_hash_version; +} + +/** Set default version of the hash algorithm version for directory index. + * + * @param sb superblock + * @param version default hash version + */ +void ext4_superblock_set_default_hash_version(ext4_superblock_t *sb, uint8_t version) +{ + sb->default_hash_version = version; +} + +/** Get size of block group descriptor structure. + * + * Output value is checked for minimal size. + * + * @param sb superblock + * @return size of block group descriptor + */ +uint16_t ext4_superblock_get_desc_size(ext4_superblock_t *sb) +{ + uint16_t size = uint16_t_le2host(sb->desc_size); + + if (size < EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + size = EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE; + } + + return size; +} + +/** Set size of block group descriptor structure. + * + * Input value is checked for minimal size. + * + * @param sb superblock + * @param size size of block group descriptor + */ +void ext4_superblock_set_desc_size(ext4_superblock_t *sb, uint16_t size) +{ + if (size < EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + sb->desc_size = host2uint16_t_le(EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE); + } + + sb->desc_size = host2uint16_t_le(size); +} + +/** Get superblock flags. + * + * @param sb superblock + * @return flags from the superblock + */ +uint32_t ext4_superblock_get_flags(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->flags); +} + +/** Set superblock flags. + * + * @param sb superblock + * @param flags flags for the superblock + */ +void ext4_superblock_set_flags(ext4_superblock_t *sb, uint32_t flags) +{ + sb->flags = host2uint32_t_le(flags); +} + +/* + * More complex superblock operations + */ + +/** Check if superblock has specified flag. + * + * @param sb superblock + * @param flag flag to be checked + * @return true, if superblock has the flag + */ +bool ext4_superblock_has_flag(ext4_superblock_t *sb, uint32_t flag) +{ + if (ext4_superblock_get_flags(sb) & flag) { + return true; + } + return false; +} + +/** Check if filesystem supports compatible feature. + * + * @param sb superblock + * @param feature feature to be checked + * @return true, if filesystem supports the feature + */ +bool ext4_superblock_has_feature_compatible(ext4_superblock_t *sb, uint32_t feature) +{ + if (ext4_superblock_get_features_compatible(sb) & feature) { + return true; + } + return false; +} + +/** Check if filesystem supports incompatible feature. + * + * @param sb superblock + * @param feature feature to be checked + * @return true, if filesystem supports the feature + */ +bool ext4_superblock_has_feature_incompatible(ext4_superblock_t *sb, uint32_t feature) +{ + if (ext4_superblock_get_features_incompatible(sb) & feature) { + return true; + } + return false; +} + +/** Check if filesystem supports read-only compatible feature. + * + * @param sb superblock + * @param feature feature to be checked + * @return true, if filesystem supports the feature + */ +bool ext4_superblock_has_feature_read_only(ext4_superblock_t *sb, uint32_t feature) +{ + if (ext4_superblock_get_features_read_only(sb) & feature) { + return true; + } + return false; +} + +/** Read superblock directly from block device. + * + * @param service_id block device identifier + * @param sb output pointer to memory structure + * @return error code. + */ +int ext4_superblock_read_direct(service_id_t service_id, + ext4_superblock_t **sb) +{ + int rc; + + /* Allocated memory for superblock structure */ + void *data = malloc(EXT4_SUPERBLOCK_SIZE); + if (data == NULL) { + return ENOMEM; + } + + /* Read data from block device */ + rc = block_read_bytes_direct(service_id, EXT4_SUPERBLOCK_OFFSET, + EXT4_SUPERBLOCK_SIZE, data); + + if (rc != EOK) { + free(data); + return rc; + } + + /* Set output value */ + (*sb) = data; + + return EOK; +} + +/** Write superblock structure directly to block device. + * + * @param service_id block device identifier + * @param sb superblock to be written + * @return error code + */ +int ext4_superblock_write_direct(service_id_t service_id, + ext4_superblock_t *sb) +{ + int rc; + size_t phys_block_size; + + /* Load physical block size from block device */ + rc = block_get_bsize(service_id, &phys_block_size); + if (rc != EOK) { + return rc; + } + + /* Compute address of the first block */ + uint64_t first_block = EXT4_SUPERBLOCK_OFFSET / phys_block_size; + /* Compute number of block to write */ + size_t block_count = EXT4_SUPERBLOCK_SIZE / phys_block_size; + + /* Check alignment */ + if (EXT4_SUPERBLOCK_SIZE % phys_block_size) { + block_count++; + } + + /* Write data */ + return block_write_direct(service_id, first_block, block_count, sb); + +} + +/** Check sanity of the superblock. + * + * This check is performed at mount time. + * Checks are described by one-line comments in the code. + * + * @param sb superblock to check + * @return error code + */ +int ext4_superblock_check_sanity(ext4_superblock_t *sb) +{ + if (ext4_superblock_get_magic(sb) != EXT4_SUPERBLOCK_MAGIC) { + return ENOTSUP; + } + + if (ext4_superblock_get_inodes_count(sb) == 0) { + return ENOTSUP; + } + + if (ext4_superblock_get_blocks_count(sb) == 0) { + return ENOTSUP; + } + + if (ext4_superblock_get_blocks_per_group(sb) == 0) { + return ENOTSUP; + } + + if (ext4_superblock_get_inodes_per_group(sb) == 0) { + return ENOTSUP; + } + + if (ext4_superblock_get_inode_size(sb) < 128) { + return ENOTSUP; + } + + if (ext4_superblock_get_first_inode(sb) < 11) { + return ENOTSUP; + } + + if (ext4_superblock_get_desc_size(sb) < EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) { + return ENOTSUP; + } + + if (ext4_superblock_get_desc_size(sb) > EXT4_MAX_BLOCK_GROUP_DESCRIPTOR_SIZE) { + return ENOTSUP; + } + + return EOK; +} + +/** Compute number of block groups in the filesystem. + * + * @param sb superblock + * @return number of block groups + */ +uint32_t ext4_superblock_get_block_group_count(ext4_superblock_t *sb) +{ + uint64_t blocks_count = ext4_superblock_get_blocks_count(sb); + uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb); + + uint32_t block_groups_count = blocks_count / blocks_per_group; + + if (blocks_count % blocks_per_group) { + block_groups_count++; + } + + return block_groups_count; + +} + +/** Compute number of blocks in specified block group. + * + * @param sb superblock + * @param bgid block group index + * @return number of blocks + */ +uint32_t ext4_superblock_get_blocks_in_group(ext4_superblock_t *sb, uint32_t bgid) +{ + uint32_t block_group_count = ext4_superblock_get_block_group_count(sb); + uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb); + uint64_t total_blocks = ext4_superblock_get_blocks_count(sb); + + if (bgid < block_group_count - 1) { + return blocks_per_group; + } else { + return (total_blocks - ((block_group_count - 1) * blocks_per_group)); + } + +} + +/** Compute number of i-nodes in specified block group. + * + * @param sb superblock + * @param bgid block group index + * @return number of i-nodes + */ +uint32_t ext4_superblock_get_inodes_in_group(ext4_superblock_t *sb, uint32_t bgid) +{ + uint32_t block_group_count = ext4_superblock_get_block_group_count(sb); + uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb); + uint32_t total_inodes = ext4_superblock_get_inodes_count(sb); + + if (bgid < block_group_count - 1) { + return inodes_per_group; + } else { + return (total_inodes - ((block_group_count - 1) * inodes_per_group)); + } + +} + +/** + * @} + */ Index: uspace/lib/ext4/libext4_superblock.h =================================================================== --- uspace/lib/ext4/libext4_superblock.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_superblock.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_SUPERBLOCK_H_ +#define LIBEXT4_LIBEXT4_SUPERBLOCK_H_ + +#include +#include + +#include "libext4_types.h" + +extern uint32_t ext4_superblock_get_inodes_count(ext4_superblock_t *); +extern void ext4_superblock_set_inodes_count(ext4_superblock_t *, uint32_t); +extern uint64_t ext4_superblock_get_blocks_count(ext4_superblock_t *); +extern void ext4_superblock_set_blocks_count(ext4_superblock_t *, uint64_t); +extern uint64_t ext4_superblock_get_reserved_blocks_count(ext4_superblock_t *); +extern void ext4_superblock_set_reserved_blocks_count(ext4_superblock_t *, uint64_t); +extern uint64_t ext4_superblock_get_free_blocks_count(ext4_superblock_t *); +extern void ext4_superblock_set_free_blocks_count(ext4_superblock_t *, uint64_t); +extern uint32_t ext4_superblock_get_free_inodes_count(ext4_superblock_t *); +extern void ext4_superblock_set_free_inodes_count(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_first_data_block(ext4_superblock_t *); +extern void ext4_superblock_set_first_data_block(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_log_block_size(ext4_superblock_t *); +extern void ext4_superblock_set_log_block_size(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_block_size(ext4_superblock_t *); +extern void ext4_superblock_set_block_size(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_log_frag_size(ext4_superblock_t *); +extern void ext4_superblock_set_log_frag_size(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_frag_size(ext4_superblock_t *); +extern void ext4_superblock_set_frag_size(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_blocks_per_group(ext4_superblock_t *); +extern void ext4_superblock_set_blocks_per_group(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_frags_per_group(ext4_superblock_t *); +extern void ext4_superblock_set_frags_per_group(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_inodes_per_group(ext4_superblock_t *); +extern void ext4_superblock_set_inodes_per_group(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_mount_time(ext4_superblock_t *); +extern void ext4_superblock_set_mount_time(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_write_time(ext4_superblock_t *); +extern void ext4_superblock_set_write_time(ext4_superblock_t *, uint32_t); +extern uint16_t ext4_superblock_get_mount_count(ext4_superblock_t *); +extern void ext4_superblock_set_mount_count(ext4_superblock_t *, uint16_t); +extern uint16_t ext4_superblock_get_max_mount_count(ext4_superblock_t *); +extern void ext4_superblock_set_max_mount_count(ext4_superblock_t *, uint16_t); +extern uint16_t ext4_superblock_get_magic(ext4_superblock_t *); +extern void ext4_superblock_set_magic(ext4_superblock_t *sb, uint16_t magic); +extern uint16_t ext4_superblock_get_state(ext4_superblock_t *); +extern void ext4_superblock_set_state(ext4_superblock_t *, uint16_t); +extern uint16_t ext4_superblock_get_errors(ext4_superblock_t *); +extern void ext4_superblock_set_errors(ext4_superblock_t *, uint16_t); +extern uint16_t ext4_superblock_get_minor_rev_level(ext4_superblock_t *); +extern void ext4_superblock_set_minor_rev_level(ext4_superblock_t *, uint16_t); +extern uint32_t ext4_superblock_get_last_check_time(ext4_superblock_t *); +extern void ext4_superblock_set_last_check_time(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_check_interval(ext4_superblock_t *); +extern void ext4_superblock_set_check_interval(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_creator_os(ext4_superblock_t *); +extern void ext4_superblock_set_creator_os(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_rev_level(ext4_superblock_t *); +extern void ext4_superblock_set_rev_level(ext4_superblock_t *, uint32_t); +extern uint16_t ext4_superblock_get_def_resuid(ext4_superblock_t *); +extern void ext4_superblock_set_def_resuid(ext4_superblock_t *, uint16_t); +extern uint16_t ext4_superblock_get_def_resgid(ext4_superblock_t *); +extern void ext4_superblock_set_def_resgid(ext4_superblock_t *, uint16_t); +extern uint32_t ext4_superblock_get_first_inode(ext4_superblock_t *); +extern void ext4_superblock_set_first_inode(ext4_superblock_t *, uint32_t); +extern uint16_t ext4_superblock_get_inode_size(ext4_superblock_t *); +extern void ext4_superblock_set_inode_size(ext4_superblock_t *, uint16_t); +extern uint16_t ext4_superblock_get_block_group_index(ext4_superblock_t *); +extern void ext4_superblock_set_block_group_index(ext4_superblock_t *, uint16_t); +extern uint32_t ext4_superblock_get_features_compatible(ext4_superblock_t *); +extern void ext4_superblock_set_features_compatible(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_features_incompatible(ext4_superblock_t *); +extern void ext4_superblock_set_features_incompatible(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_features_read_only(ext4_superblock_t *); +extern void ext4_superblock_set_features_read_only(ext4_superblock_t *, uint32_t); + +extern const uint8_t * ext4_superblock_get_uuid(ext4_superblock_t *); +extern void ext4_superblock_set_uuid(ext4_superblock_t *, const uint8_t *); +extern const char * ext4_superblock_get_volume_name(ext4_superblock_t *); +extern void ext4_superblock_set_volume_name(ext4_superblock_t *, const char *); +extern const char * ext4_superblock_get_last_mounted(ext4_superblock_t *); +extern void ext4_superblock_set_last_mounted(ext4_superblock_t *, const char *); + +/* +uint32_t s_algorithm_usage_bitmap; // For compression +uint8_t s_prealloc_blocks; // Number of blocks to try to preallocate +uint8_t s_prealloc_dir_blocks; // Number to preallocate for dirs +uint16_t s_reserved_gdt_blocks; // Per group desc for online growth +uint8_t s_journal_uuid[16]; // UUID of journal superblock +uint32_t s_journal_inum; // Inode number of journal file +uint32_t s_journal_dev; // Device number of journal file +*/ +extern uint32_t ext4_superblock_get_last_orphan(ext4_superblock_t *); +extern void ext4_superblock_set_last_orphan(ext4_superblock_t *, uint32_t); +extern const uint32_t * ext4_superblock_get_hash_seed(ext4_superblock_t *); +extern void ext4_superblock_set_hash_seed(ext4_superblock_t *, const uint32_t *); +extern uint8_t ext4_superblock_get_default_hash_version(ext4_superblock_t *); +extern void ext4_superblock_set_default_hash_version(ext4_superblock_t *, uint8_t); +/* +uint8_t s_jnl_backup_type; +*/ + +extern uint16_t ext4_superblock_get_desc_size(ext4_superblock_t *); +extern void ext4_superblock_set_desc_size(ext4_superblock_t *, uint16_t); + +/* +uint32_t s_default_mount_opts; // Default mount options +uint32_t s_first_meta_bg; // First metablock block group +uint32_t s_mkfs_time; // When the filesystem was created +uint32_t s_jnl_blocks[17]; // Backup of the journal inode +uint16_t s_min_extra_isize; // All inodes have at least # bytes +uint16_t s_want_extra_isize; // New inodes should reserve # bytes +*/ +extern uint32_t ext4_superblock_get_flags(ext4_superblock_t *); +extern void ext4_superblock_set_flags(ext4_superblock_t *, uint32_t); +/* +uint16_t s_raid_stride; // RAID stride +uint16_t s_mmp_interval; // # seconds to wait in MMP checking +uint64_t s_mmp_block; // Block for multi-mount protection +uint32_t s_raid_stripe_width; // blocks on all data disks (N*stride) +uint8_t s_log_groups_per_flex; // FLEX_BG group size +uint8_t s_reserved_char_pad; +uint16_t s_reserved_pad; +uint64_t s_kbytes_written; // Number of lifetime kilobytes written +uint32_t s_snapshot_inum; // Inode number of active snapshot +uint32_t s_snapshot_id; // Sequential ID of active snapshot +uint64_t s_snapshot_r_blocks_count; // reserved blocks for active snapshot's future use +uint32_t s_snapshot_list; // inode number of the head of the on-disk snapshot list +uint32_t s_error_count; // number of fs errors +uint32_t s_first_error_time; // First time an error happened +uint32_t s_first_error_ino; // Inode involved in first error +uint64_t s_first_error_block; // block involved of first error +uint8_t s_first_error_func[32]; // Function where the error happened +uint32_t s_first_error_line; // Line number where error happened +uint32_t s_last_error_time; // Most recent time of an error +uint32_t s_last_error_ino; // Inode involved in last error +uint32_t s_last_error_line; // Line number where error happened +uint64_t s_last_error_block; // block involved of last error +uint8_t s_last_error_func[32]; // function where the error happened +uint8_t s_mount_opts[64]; +*/ + +/* More complex superblock functions */ +extern bool ext4_superblock_has_flag(ext4_superblock_t *, uint32_t); +extern bool ext4_superblock_has_feature_compatible(ext4_superblock_t *, uint32_t); +extern bool ext4_superblock_has_feature_incompatible(ext4_superblock_t *, uint32_t); +extern bool ext4_superblock_has_feature_read_only(ext4_superblock_t *, uint32_t); +extern int ext4_superblock_read_direct(service_id_t, ext4_superblock_t **); +extern int ext4_superblock_write_direct(service_id_t, ext4_superblock_t *); +extern int ext4_superblock_check_sanity(ext4_superblock_t *); + +extern uint32_t ext4_superblock_get_block_group_count(ext4_superblock_t *); +extern uint32_t ext4_superblock_get_blocks_in_group(ext4_superblock_t *, uint32_t); +extern uint32_t ext4_superblock_get_inodes_in_group(ext4_superblock_t *, uint32_t); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/libext4_types.h =================================================================== --- uspace/lib/ext4/libext4_types.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/lib/ext4/libext4_types.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,553 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libext4 + * @{ + */ + +#ifndef LIBEXT4_LIBEXT4_TYPES_H_ +#define LIBEXT4_LIBEXT4_TYPES_H_ + +#include + +/* + * Structure of the super block + */ +typedef struct ext4_superblock { + uint32_t inodes_count; // Inodes count + uint32_t blocks_count_lo; // Blocks count + uint32_t reserved_blocks_count_lo; // Reserved blocks count + uint32_t free_blocks_count_lo; // Free blocks count + uint32_t free_inodes_count; // Free inodes count + uint32_t first_data_block; // First Data Block + uint32_t log_block_size; // Block size + uint32_t log_frag_size; // Obsoleted fragment size + uint32_t blocks_per_group; // Number of blocks per group + uint32_t frags_per_group; // Obsoleted fragments per group + uint32_t inodes_per_group; // Number of inodes per group + uint32_t mount_time; // Mount time + uint32_t write_time; // Write time + uint16_t mount_count; // Mount count + uint16_t max_mount_count; // Maximal mount count + uint16_t magic; // Magic signature + uint16_t state; // Filesystem state + uint16_t errors; // Behaviour when detecting errors + uint16_t minor_rev_level; // Minor revision level + uint32_t last_check_time; // Time of last check + uint32_t check_interval; // Maximum time between checks + uint32_t creator_os; // Creator OS + uint32_t rev_level; // Revision level + uint16_t def_resuid; // Default uid for reserved blocks + uint16_t def_resgid; // Default gid for reserved blocks + + // Fields for EXT4_DYNAMIC_REV superblocks only. + uint32_t first_inode; // First non-reserved inode + uint16_t inode_size; // Size of inode structure + uint16_t block_group_index; // Block group index of this superblock + uint32_t features_compatible; // Compatible feature set + uint32_t features_incompatible; // Incompatible feature set + uint32_t features_read_only; // Readonly-compatible feature set + uint8_t uuid[16]; // 128-bit uuid for volume + char volume_name[16]; // Volume name + char last_mounted[64]; // Directory where last mounted + uint32_t algorithm_usage_bitmap; // For compression + + /* + * Performance hints. Directory preallocation should only + * happen if the EXT4_FEATURE_COMPAT_DIR_PREALLOC flag is on. + */ + uint8_t s_prealloc_blocks; // Number of blocks to try to preallocate + uint8_t s_prealloc_dir_blocks; // Number to preallocate for dirs + uint16_t s_reserved_gdt_blocks; // Per group desc for online growth + + /* + * Journaling support valid if EXT4_FEATURE_COMPAT_HAS_JOURNAL set. + */ + uint8_t journal_uuid[16]; // UUID of journal superblock + uint32_t journal_inode_number; // Inode number of journal file + uint32_t journal_dev; // Device number of journal file + uint32_t last_orphan; // Head of list of inodes to delete + uint32_t hash_seed[4]; // HTREE hash seed + uint8_t default_hash_version; // Default hash version to use + uint8_t journal_backup_type; + uint16_t desc_size; // Size of group descriptor + uint32_t default_mount_opts; // Default mount options + uint32_t first_meta_bg; // First metablock block group + uint32_t mkfs_time; // When the filesystem was created + uint32_t journal_blocks[17]; // Backup of the journal inode + + /* 64bit support valid if EXT4_FEATURE_COMPAT_64BIT */ + uint32_t blocks_count_hi; // Blocks count + uint32_t reserved_blocks_count_hi; // Reserved blocks count + uint32_t free_blocks_count_hi; // Free blocks count + uint16_t min_extra_isize; // All inodes have at least # bytes + uint16_t want_extra_isize; // New inodes should reserve # bytes + uint32_t flags; // Miscellaneous flags + uint16_t raid_stride; // RAID stride + uint16_t mmp_interval; // # seconds to wait in MMP checking + uint64_t mmp_block; // Block for multi-mount protection + uint32_t raid_stripe_width; // blocks on all data disks (N*stride) + uint8_t log_groups_per_flex; // FLEX_BG group size + uint8_t reserved_char_pad; + uint16_t reserved_pad; + uint64_t kbytes_written; // Number of lifetime kilobytes written + uint32_t snapshot_inum; // Inode number of active snapshot + uint32_t snapshot_id; // Sequential ID of active snapshot + uint64_t snapshot_r_blocks_count; /* reserved blocks for active snapshot's future use */ + uint32_t snapshot_list; // inode number of the head of the on-disk snapshot list + uint32_t error_count; // number of fs errors + uint32_t first_error_time; // First time an error happened + uint32_t first_error_ino; // Inode involved in first error + uint64_t first_error_block; // block involved of first error + uint8_t first_error_func[32]; // Function where the error happened + uint32_t first_error_line; // Line number where error happened + uint32_t last_error_time; // Most recent time of an error + uint32_t last_error_ino; // Inode involved in last error + uint32_t last_error_line; // Line number where error happened + uint64_t last_error_block; // Block involved of last error + uint8_t last_error_func[32]; // Function where the error happened + uint8_t mount_opts[64]; + uint32_t padding[112]; // Padding to the end of the block +} __attribute__((packed)) ext4_superblock_t; + + +#define EXT4_SUPERBLOCK_MAGIC 0xEF53 +#define EXT4_SUPERBLOCK_SIZE 1024 +#define EXT4_SUPERBLOCK_OFFSET 1024 + +#define EXT4_SUPERBLOCK_OS_LINUX 0 +#define EXT4_SUPERBLOCK_OS_HURD 1 + +/* + * Misc. filesystem flags + */ +#define EXT4_SUPERBLOCK_FLAGS_SIGNED_HASH 0x0001 // Signed dirhash in use +#define EXT4_SUPERBLOCK_FLAGS_UNSIGNED_HASH 0x0002 // Unsigned dirhash in use +#define EXT4_SUPERBLOCK_FLAGS_TEST_FILESYS 0x0004 // to test development code + +/* + * Filesystem states + */ +#define EXT4_SUPERBLOCK_STATE_VALID_FS 0x0001 // Unmounted cleanly +#define EXT4_SUPERBLOCK_STATE_ERROR_FS 0x0002 // Errors detected +#define EXT4_SUPERBLOCK_STATE_ORPHAN_FS 0x0004 // Orphans being recovered + +/* + * Behaviour when errors detected + */ +#define EXT4_SUPERBLOCK_ERRORS_CONTINUE 1 // Continue execution +#define EXT4_SUPERBLOCK_ERRORS_RO 2 // Remount fs read-only +#define EXT4_SUPERBLOCK_ERRORS_PANIC 3 // Panic +#define EXT4_SUPERBLOCK_ERRORS_DEFAULT EXT4_ERRORS_CONTINUE + +/* + * Compatible features + */ +#define EXT4_FEATURE_COMPAT_DIR_PREALLOC 0x0001 +#define EXT4_FEATURE_COMPAT_IMAGIC_INODES 0x0002 +#define EXT4_FEATURE_COMPAT_HAS_JOURNAL 0x0004 +#define EXT4_FEATURE_COMPAT_EXT_ATTR 0x0008 +#define EXT4_FEATURE_COMPAT_RESIZE_INODE 0x0010 +#define EXT4_FEATURE_COMPAT_DIR_INDEX 0x0020 + +/* + * Read-only compatible features + */ +#define EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001 +#define EXT4_FEATURE_RO_COMPAT_LARGE_FILE 0x0002 +#define EXT4_FEATURE_RO_COMPAT_BTREE_DIR 0x0004 +#define EXT4_FEATURE_RO_COMPAT_HUGE_FILE 0x0008 +#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010 +#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020 +#define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE 0x0040 + +/* + * Incompatible features + */ +#define EXT4_FEATURE_INCOMPAT_COMPRESSION 0x0001 +#define EXT4_FEATURE_INCOMPAT_FILETYPE 0x0002 +#define EXT4_FEATURE_INCOMPAT_RECOVER 0x0004 /* Needs recovery */ +#define EXT4_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 /* Journal device */ +#define EXT4_FEATURE_INCOMPAT_META_BG 0x0010 +#define EXT4_FEATURE_INCOMPAT_EXTENTS 0x0040 /* extents support */ +#define EXT4_FEATURE_INCOMPAT_64BIT 0x0080 +#define EXT4_FEATURE_INCOMPAT_MMP 0x0100 +#define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200 +#define EXT4_FEATURE_INCOMPAT_EA_INODE 0x0400 /* EA in inode */ +#define EXT4_FEATURE_INCOMPAT_DIRDATA 0x1000 /* data in dirent */ + +#define EXT4_FEATURE_COMPAT_SUPP (EXT4_FEATURE_COMPAT_DIR_INDEX) + +#define EXT4_FEATURE_INCOMPAT_SUPP (EXT4_FEATURE_INCOMPAT_FILETYPE | \ + EXT4_FEATURE_INCOMPAT_EXTENTS | \ + EXT4_FEATURE_INCOMPAT_64BIT) + +#define EXT4_FEATURE_RO_COMPAT_SUPP (EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER | \ + EXT4_FEATURE_RO_COMPAT_DIR_NLINK | \ + EXT4_FEATURE_RO_COMPAT_HUGE_FILE | \ + EXT4_FEATURE_RO_COMPAT_LARGE_FILE | \ + EXT4_FEATURE_RO_COMPAT_GDT_CSUM | \ + EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE) + + +/*****************************************************************************/ + +typedef struct ext4_filesystem { + service_id_t device; + ext4_superblock_t * superblock; + aoff64_t inode_block_limits[4]; + aoff64_t inode_blocks_per_level[4]; +} ext4_filesystem_t; + + +/*****************************************************************************/ + +#define EXT4_BLOCK_GROUP_INODE_UNINIT 0x0001 /* Inode table/bitmap not in use */ +#define EXT4_BLOCK_GROUP_BLOCK_UNINIT 0x0002 /* Block bitmap not in use */ +#define EXT4_BLOCK_GROUP_ITABLE_ZEROED 0x0004 /* On-disk itable initialized to zero */ + +/* + * Structure of a blocks group descriptor + */ +typedef struct ext4_block_group { + uint32_t block_bitmap_lo; // Blocks bitmap block + uint32_t inode_bitmap_lo; // Inodes bitmap block + uint32_t inode_table_first_block_lo; // Inodes table block + uint16_t free_blocks_count_lo; // Free blocks count + uint16_t free_inodes_count_lo; // Free inodes count + uint16_t used_dirs_count_lo; // Directories count + uint16_t flags; // EXT4_BG_flags (INODE_UNINIT, etc) + uint32_t reserved[2]; // Likely block/inode bitmap checksum + uint16_t itable_unused_lo; // Unused inodes count + uint16_t checksum; // crc16(sb_uuid+group+desc) + /* -------------- */ + uint32_t block_bitmap_hi; // Blocks bitmap block MSB + uint32_t inode_bitmap_hi; // Inodes bitmap block MSB + uint32_t inode_table_first_block_hi; // Inodes table block MSB + uint16_t free_blocks_count_hi; // Free blocks count MSB + uint16_t free_inodes_count_hi; // Free inodes count MSB + uint16_t used_dirs_count_hi; // Directories count MSB + uint16_t itable_unused_hi; // Unused inodes count MSB + uint32_t reserved2[3]; // Padding +} ext4_block_group_t; + +typedef struct ext4_block_group_ref { + block_t *block; // Reference to a block containing this block group descr + ext4_block_group_t *block_group; + ext4_filesystem_t *fs; + uint32_t index; + bool dirty; +} ext4_block_group_ref_t; + + +#define EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE 32 +#define EXT4_MAX_BLOCK_GROUP_DESCRIPTOR_SIZE 64 + +/*****************************************************************************/ + + +#define EXT4_MIN_BLOCK_SIZE 1024 //1 KiB +#define EXT4_MAX_BLOCK_SIZE 65536 //64 KiB +#define EXT4_REV0_INODE_SIZE 128 + +#define EXT4_INODE_BLOCK_SIZE 512 + +#define EXT4_INODE_DIRECT_BLOCK_COUNT 12 +#define EXT4_INODE_INDIRECT_BLOCK EXT4_INODE_DIRECT_BLOCK_COUNT +#define EXT4_INODE_DOUBLE_INDIRECT_BLOCK (EXT4_INODE_INDIRECT_BLOCK + 1) +#define EXT4_INODE_TRIPPLE_INDIRECT_BLOCK (EXT4_INODE_DOUBLE_INDIRECT_BLOCK + 1) +#define EXT4_INODE_BLOCKS (EXT4_INODE_TRIPPLE_INDIRECT_BLOCK + 1) +#define EXT4_INODE_INDIRECT_BLOCK_COUNT (EXT4_INODE_BLOCKS - EXT4_INODE_DIRECT_BLOCK_COUNT) + +/* + * Structure of an inode on the disk + */ +typedef struct ext4_inode { + uint16_t mode; // File mode + uint16_t uid; // Low 16 bits of owner uid + uint32_t size_lo; // Size in bytes + uint32_t access_time; // Access time + uint32_t change_inode_time; // Inode change time + uint32_t modification_time; // Modification time + uint32_t deletion_time; // Deletion time + uint16_t gid; // Low 16 bits of group id + uint16_t links_count; // Links count + uint32_t blocks_count_lo; // Blocks count + uint32_t flags; // File flags + uint32_t unused_osd1; // OS dependent - not used in HelenOS + uint32_t blocks[EXT4_INODE_BLOCKS]; // Pointers to blocks + uint32_t generation; // File version (for NFS) + uint32_t file_acl_lo; // File ACL + uint32_t size_hi; + uint32_t obso_faddr; // Obsoleted fragment address + union { + struct { + uint16_t blocks_high; /* were l_i_reserved1 */ + uint16_t file_acl_high; + uint16_t uid_high; /* these 2 fields */ + uint16_t gid_high; /* were reserved2[0] */ + uint32_t reserved2; + } linux2; + struct { + uint16_t reserved1; /* Obsoleted fragment number/size which are removed in ext4 */ + uint16_t mode_high; + uint16_t uid_high; + uint16_t gid_high; + uint32_t author; + } hurd2; + } __attribute__ ((packed)) osd2; + + uint16_t extra_isize; + uint16_t pad1; + uint32_t ctime_extra; // Extra change time (nsec << 2 | epoch) + uint32_t mtime_extra; // Extra Modification time (nsec << 2 | epoch) + uint32_t atime_extra; // Extra Access time (nsec << 2 | epoch) + uint32_t crtime; // File creation time + uint32_t crtime_extra; // Extra file creation time (nsec << 2 | epoch) + uint32_t version_hi; // High 32 bits for 64-bit version +} __attribute__ ((packed)) ext4_inode_t; + +#define EXT4_INODE_MODE_FIFO 0x1000 +#define EXT4_INODE_MODE_CHARDEV 0x2000 +#define EXT4_INODE_MODE_DIRECTORY 0x4000 +#define EXT4_INODE_MODE_BLOCKDEV 0x6000 +#define EXT4_INODE_MODE_FILE 0x8000 +#define EXT4_INODE_MODE_SOFTLINK 0xA000 +#define EXT4_INODE_MODE_SOCKET 0xC000 +#define EXT4_INODE_MODE_TYPE_MASK 0xF000 + +/* + * Inode flags + */ +#define EXT4_INODE_FLAG_SECRM 0x00000001 // Secure deletion +#define EXT4_INODE_FLAG_UNRM 0x00000002 // Undelete +#define EXT4_INODE_FLAG_COMPR 0x00000004 // Compress file +#define EXT4_INODE_FLAG_SYNC 0x00000008 // Synchronous updates +#define EXT4_INODE_FLAG_IMMUTABLE 0x00000010 // Immutable file +#define EXT4_INODE_FLAG_APPEND 0x00000020 // writes to file may only append +#define EXT4_INODE_FLAG_NODUMP 0x00000040 // do not dump file +#define EXT4_INODE_FLAG_NOATIME 0x00000080 // do not update atime +/* Compression flags */ +#define EXT4_INODE_FLAG_DIRTY 0x00000100 +#define EXT4_INODE_FLAG_COMPRBLK 0x00000200 // One or more compressed clusters +#define EXT4_INODE_FLAG_NOCOMPR 0x00000400 // Don't compress +#define EXT4_INODE_FLAG_ECOMPR 0x00000800 // Compression error +/* End compression flags --- maybe not all used */ +#define EXT4_INODE_FLAG_INDEX 0x00001000 // hash-indexed directory +#define EXT4_INODE_FLAG_IMAGIC 0x00002000 // AFS directory */ +#define EXT4_INODE_FLAG_JOURNAL_DATA 0x00004000 // File data should be journaled +#define EXT4_INODE_FLAG_NOTAIL 0x00008000 // File tail should not be merged +#define EXT4_INODE_FLAG_DIRSYNC 0x00010000 // Dirsync behaviour (directories only) +#define EXT4_INODE_FLAG_TOPDIR 0x00020000 // Top of directory hierarchies +#define EXT4_INODE_FLAG_HUGE_FILE 0x00040000 // Set to each huge file +#define EXT4_INODE_FLAG_EXTENTS 0x00080000 // Inode uses extents +#define EXT4_INODE_FLAG_EA_INODE 0x00200000 // Inode used for large EA +#define EXT4_INODE_FLAG_EOFBLOCKS 0x00400000 // Blocks allocated beyond EOF +#define EXT4_INODE_FLAG_RESERVED 0x80000000 // reserved for ext4 lib + +#define EXT4_INODE_ROOT_INDEX 2 + +typedef struct ext4_inode_ref { + block_t *block; // Reference to a block containing this inode + ext4_inode_t *inode; + ext4_filesystem_t *fs; + uint32_t index; // Index number of this inode + bool dirty; +} ext4_inode_ref_t; + +/*****************************************************************************/ + +#define EXT4_DIRECTORY_FILENAME_LEN 255 + +#define EXT4_DIRECTORY_FILETYPE_UNKNOWN 0 +#define EXT4_DIRECTORY_FILETYPE_REG_FILE 1 +#define EXT4_DIRECTORY_FILETYPE_DIR 2 +#define EXT4_DIRECTORY_FILETYPE_CHRDEV 3 +#define EXT4_DIRECTORY_FILETYPE_BLKDEV 4 +#define EXT4_DIRECTORY_FILETYPE_FIFO 5 +#define EXT4_DIRECTORY_FILETYPE_SOCK 6 +#define EXT4_DIRECTORY_FILETYPE_SYMLINK 7 + +/** + * Linked list directory entry structure + */ +typedef struct ext4_directory_entry_ll { + uint32_t inode; // Inode for the entry + uint16_t entry_length; // Distance to the next directory entry + uint8_t name_length; // Lower 8 bits of name length + union { + uint8_t name_length_high; // Higher 8 bits of name length + uint8_t inode_type; // Type of referenced inode (in rev >= 0.5) + } __attribute__ ((packed)); + uint8_t name[EXT4_DIRECTORY_FILENAME_LEN]; // Entry name +} __attribute__ ((packed)) ext4_directory_entry_ll_t; + +typedef struct ext4_directory_iterator { + ext4_inode_ref_t *inode_ref; + block_t *current_block; + aoff64_t current_offset; + ext4_directory_entry_ll_t *current; +} ext4_directory_iterator_t; + +typedef struct ext4_directory_search_result { + block_t *block; + ext4_directory_entry_ll_t *dentry; +} ext4_directory_search_result_t; + + +/*****************************************************************************/ + +/* Structures for indexed directory */ + +typedef struct ext4_directory_dx_countlimit { + uint16_t limit; + uint16_t count; +} ext4_directory_dx_countlimit_t; + +typedef struct ext4_directory_dx_dot_entry { + uint32_t inode; + uint16_t entry_length; + uint8_t name_length; + uint8_t inode_type; + uint8_t name[4]; +} ext4_directory_dx_dot_entry_t; + +typedef struct ext4_directory_dx_root_info { + uint32_t reserved_zero; + uint8_t hash_version; + uint8_t info_length; + uint8_t indirect_levels; + uint8_t unused_flags; +} ext4_directory_dx_root_info_t; + +typedef struct ext4_directory_dx_entry { + uint32_t hash; + uint32_t block; +} ext4_directory_dx_entry_t; + +typedef struct ext4_directory_dx_root { + ext4_directory_dx_dot_entry_t dots[2]; + ext4_directory_dx_root_info_t info; + ext4_directory_dx_entry_t entries[0]; +} ext4_directory_dx_root_t; + +typedef struct ext4_fake_directory_entry { + uint32_t inode; + uint16_t entry_length; + uint8_t name_length; + uint8_t inode_type; +} ext4_fake_directory_entry_t; + +typedef struct ext4_directory_dx_node { + ext4_fake_directory_entry_t fake; + ext4_directory_dx_entry_t entries[0]; +} ext4_directory_dx_node_t; + + +typedef struct ext4_directory_dx_block { + block_t *block; + ext4_directory_dx_entry_t *entries; + ext4_directory_dx_entry_t *position; +} ext4_directory_dx_block_t; + + + +#define EXT4_ERR_BAD_DX_DIR (-75000) +#define EXT4_DIRECTORY_HTREE_EOF (uint32_t)0x7fffffff + +/*****************************************************************************/ + +/* + * This is the extent on-disk structure. + * It's used at the bottom of the tree. + */ +typedef struct ext4_extent { + uint32_t first_block; // First logical block extent covers + uint16_t block_count; // Number of blocks covered by extent + uint16_t start_hi; // High 16 bits of physical block + uint32_t start_lo; // Low 32 bits of physical block +} ext4_extent_t; + +/* + * This is index on-disk structure. + * It's used at all the levels except the bottom. + */ +typedef struct ext4_extent_index { + uint32_t first_block; // Index covers logical blocks from 'block' + uint32_t leaf_lo; /* Pointer to the physical block of the next + * level. leaf or next index could be there */ + uint16_t leaf_hi; /* high 16 bits of physical block */ + uint16_t padding; +} ext4_extent_index_t; + +/* + * Each block (leaves and indexes), even inode-stored has header. + */ +typedef struct ext4_extent_header { + uint16_t magic; + uint16_t entries_count; // Number of valid entries + uint16_t max_entries_count; // Capacity of store in entries + uint16_t depth; // Has tree real underlying blocks? + uint32_t generation; // generation of the tree +} ext4_extent_header_t; + +typedef struct ext4_extent_path { + block_t *block; + uint16_t depth; + ext4_extent_header_t *header; + ext4_extent_index_t *index; + ext4_extent_t *extent; +} ext4_extent_path_t; + +#define EXT4_EXTENT_MAGIC 0xF30A +#define EXT4_EXTENT_FIRST(header) \ + ((ext4_extent_t *) (((void *) (header)) + sizeof(ext4_extent_header_t))) +#define EXT4_EXTENT_FIRST_INDEX(header) \ + ((ext4_extent_index_t *) (((void *) (header)) + sizeof(ext4_extent_header_t))) + +/*****************************************************************************/ + +#define EXT4_HASH_VERSION_LEGACY 0 +#define EXT4_HASH_VERSION_HALF_MD4 1 +#define EXT4_HASH_VERSION_TEA 2 +#define EXT4_HASH_VERSION_LEGACY_UNSIGNED 3 +#define EXT4_HASH_VERSION_HALF_MD4_UNSIGNED 4 +#define EXT4_HASH_VERSION_TEA_UNSIGNED 5 + +typedef struct ext4_hash_info { + uint32_t hash; + uint32_t minor_hash; + uint32_t hash_version; + const uint32_t *seed; +} ext4_hash_info_t; + +#endif + +/** + * @} + */ Index: uspace/srv/fs/ext4fs/Makefile =================================================================== --- uspace/srv/fs/ext4fs/Makefile (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/srv/fs/ext4fs/Makefile (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,38 @@ +# +# Copyright (c) 2012 Frantisek Princ +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../../.. +LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBFS_PREFIX)/libfs.a $(LIBEXT4_PREFIX)/libext4.a $(LIBPOSIX_PREFIX)/libposix.a +EXTRA_CFLAGS += -I$(LIBBLOCK_PREFIX) -I$(LIBFS_PREFIX) -I$(LIBEXT4_PREFIX) -I$(LIBPOSIX_PREFIX) +BINARY = ext4fs + +SOURCES = \ + ext4fs.c \ + ext4fs_ops.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/srv/fs/ext4fs/ext4fs.c =================================================================== --- uspace/srv/fs/ext4fs/ext4fs.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/srv/fs/ext4fs/ext4fs.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup fs + * @{ + */ + +/** + * @file ext4fs.c + * @brief EXT4 file system driver for HelenOS. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "ext4fs.h" +#include "../../vfs/vfs.h" + +#define NAME "ext4fs" + +vfs_info_t ext4fs_vfs_info = { + .name = NAME, + .instance = 0, +}; + +/** + * Entry point of ext4fs server. + * Initialize data structures and IPC, then accepts connections in server mode. + */ +int main(int argc, char **argv) +{ + printf(NAME ": HelenOS EXT4 file system server\n"); + + if (argc == 3) { + if (!str_cmp(argv[1], "--instance")) + ext4fs_vfs_info.instance = strtol(argv[2], NULL, 10); + else { + printf(NAME " Unrecognized parameters\n"); + return -1; + } + } + + async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE, + SERVICE_VFS, 0, 0); + if (!vfs_sess) { + printf(NAME ": failed to connect to VFS\n"); + return -1; + } + + int rc = ext4fs_global_init(); + if (rc != EOK) { + printf(NAME ": Failed global initialization\n"); + return 1; + } + + rc = fs_register(vfs_sess, &ext4fs_vfs_info, &ext4fs_ops, + &ext4fs_libfs_ops); + if (rc != EOK) { + fprintf(stdout, NAME ": Failed to register fs (%d)\n", rc); + return 1; + } + + printf(NAME ": Accepting connections\n"); + task_retval(0); + async_manager(); + /* not reached */ + return 0; +} + +/** + * @} + */ Index: uspace/srv/fs/ext4fs/ext4fs.h =================================================================== --- uspace/srv/fs/ext4fs/ext4fs.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/srv/fs/ext4fs/ext4fs.h (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup fs + * @{ + */ + +#ifndef EXT4FS_EXT4FS_H_ +#define EXT4FS_EXT4FS_H_ + +#include + +extern vfs_out_ops_t ext4fs_ops; +extern libfs_ops_t ext4fs_libfs_ops; + +extern int ext4fs_global_init(void); +extern int ext4fs_global_fini(void); + + +#endif + +/** + * @} + */ Index: uspace/srv/fs/ext4fs/ext4fs_ops.c =================================================================== --- uspace/srv/fs/ext4fs/ext4fs_ops.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) +++ uspace/srv/fs/ext4fs/ext4fs_ops.c (revision c1b0c7508c83dc82b13c1bb90db8cef7de9346c9) @@ -0,0 +1,1510 @@ +/* + * Copyright (c) 2012 Frantisek Princ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup fs + * @{ + */ + +/** + * @file ext4fs_ops.c + * @brief VFS operations for EXT4 filesystem. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ext4fs.h" +#include "../../vfs/vfs.h" + +#define EXT4FS_NODE(node) ((node) ? (ext4fs_node_t *) (node)->data : NULL) + +#define OPEN_NODES_KEYS 2 +#define OPEN_NODES_DEV_HANDLE_KEY 0 +#define OPEN_NODES_INODE_KEY 1 +#define OPEN_NODES_BUCKETS 256 + +/** + * Type for holding an instance of mounted partition. + */ +typedef struct ext4fs_instance { + link_t link; + service_id_t service_id; + ext4_filesystem_t *filesystem; + unsigned int open_nodes_count; +} ext4fs_instance_t; + +/** + * Type for wrapping common fs_node and add some useful pointers. + */ +typedef struct ext4fs_node { + ext4fs_instance_t *instance; + ext4_inode_ref_t *inode_ref; + fs_node_t *fs_node; + link_t link; + unsigned int references; +} ext4fs_node_t; + +/* Forward declarations of auxiliary functions */ + +static int ext4fs_read_directory(ipc_callid_t, aoff64_t, size_t, + ext4fs_instance_t *, ext4_inode_ref_t *, size_t *); +static int ext4fs_read_file(ipc_callid_t, aoff64_t, size_t, ext4fs_instance_t *, + ext4_inode_ref_t *, size_t *); +static bool ext4fs_is_dots(const uint8_t *, size_t); +static int ext4fs_instance_get(service_id_t, ext4fs_instance_t **); +static int ext4fs_node_get_core(fs_node_t **, ext4fs_instance_t *, fs_index_t); +static int ext4fs_node_put_core(ext4fs_node_t *); + +/* Forward declarations of EXT4 libfs operations. */ + +static int ext4fs_root_get(fs_node_t **, service_id_t); +static int ext4fs_match(fs_node_t **, fs_node_t *, const char *); +static int ext4fs_node_get(fs_node_t **, service_id_t, fs_index_t); +static int ext4fs_node_open(fs_node_t *); +static int ext4fs_node_put(fs_node_t *); +static int ext4fs_create_node(fs_node_t **, service_id_t, int); +static int ext4fs_destroy_node(fs_node_t *); +static int ext4fs_link(fs_node_t *, fs_node_t *, const char *); +static int ext4fs_unlink(fs_node_t *, fs_node_t *, const char *); +static int ext4fs_has_children(bool *, fs_node_t *); +static fs_index_t ext4fs_index_get(fs_node_t *); +static aoff64_t ext4fs_size_get(fs_node_t *); +static unsigned ext4fs_lnkcnt_get(fs_node_t *); +static bool ext4fs_is_directory(fs_node_t *); +static bool ext4fs_is_file(fs_node_t *node); +static service_id_t ext4fs_service_get(fs_node_t *node); + +/* Static variables */ + +static LIST_INITIALIZE(instance_list); +static FIBRIL_MUTEX_INITIALIZE(instance_list_mutex); +static hash_table_t open_nodes; +static FIBRIL_MUTEX_INITIALIZE(open_nodes_lock); + +/* Hash table interface for open nodes hash table */ +static hash_index_t open_nodes_hash(unsigned long key[]) +{ + /* TODO: This is very simple and probably can be improved */ + return key[OPEN_NODES_INODE_KEY] % OPEN_NODES_BUCKETS; +} + +/** Compare given item with values in hash table. + * + * @return bool result of compare operation + */ +static int open_nodes_compare(unsigned long key[], hash_count_t keys, + link_t *item) +{ + ext4fs_node_t *enode = hash_table_get_instance(item, ext4fs_node_t, link); + assert(keys > 0); + if (enode->instance->service_id != + ((service_id_t) key[OPEN_NODES_DEV_HANDLE_KEY])) { + return false; + } + if (keys == 1) { + return true; + } + assert(keys == 2); + return (enode->inode_ref->index == key[OPEN_NODES_INODE_KEY]); +} + +/** Empty callback to correct hash table initialization. + * + */ +static void open_nodes_remove_cb(link_t *link) +{ + /* We don't use remove callback for this hash table */ +} + +static hash_table_operations_t open_nodes_ops = { + .hash = open_nodes_hash, + .compare = open_nodes_compare, + .remove_callback = open_nodes_remove_cb, +}; + + +/** Basic initialization of the driver. + * + * There is only needed to create hash table for storing open nodes. + * + * @return error code + */ +int ext4fs_global_init(void) +{ + if (!hash_table_create(&open_nodes, OPEN_NODES_BUCKETS, + OPEN_NODES_KEYS, &open_nodes_ops)) { + return ENOMEM; + } + return EOK; +} + +/* Finalization of the driver. + * + * There is only needed to destroy hash table. + * + * @return error code + */ +int ext4fs_global_fini(void) +{ + hash_table_destroy(&open_nodes); + return EOK; +} + + +/* + * EXT4 libfs operations. + */ + +/** Get instance from internal table by service_id. + * + * @param service_id device identifier + * @param inst output instance if successful operation + * @return error code + */ +int ext4fs_instance_get(service_id_t service_id, ext4fs_instance_t **inst) +{ + fibril_mutex_lock(&instance_list_mutex); + + if (list_empty(&instance_list)) { + fibril_mutex_unlock(&instance_list_mutex); + return EINVAL; + } + + ext4fs_instance_t *tmp; + list_foreach(instance_list, link) { + tmp = list_get_instance(link, ext4fs_instance_t, link); + + if (tmp->service_id == service_id) { + *inst = tmp; + fibril_mutex_unlock(&instance_list_mutex); + return EOK; + } + } + + fibril_mutex_unlock(&instance_list_mutex); + return EINVAL; +} + + +/** Get root node of filesystem specified by service_id. + * + * @param rfn output pointer to loaded node + * @param service_id device to load root node from + * @return error code + */ +int ext4fs_root_get(fs_node_t **rfn, service_id_t service_id) +{ + return ext4fs_node_get(rfn, service_id, EXT4_INODE_ROOT_INDEX); +} + +/** Check if specified name (component) matches with any directory entry. + * + * If match is found, load and return matching node. + * + * @param rfn output pointer to node if operation successful + * @param pfn parent directory node + * @param component name to check directory for + * @return error code + */ +int ext4fs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component) +{ + int rc; + + ext4fs_node_t *eparent = EXT4FS_NODE(pfn); + ext4_filesystem_t *fs = eparent->instance->filesystem; + + if (!ext4_inode_is_type(fs->superblock, eparent->inode_ref->inode, + EXT4_INODE_MODE_DIRECTORY)) { + return ENOTDIR; + } + + /* Try to find entry */ + ext4_directory_search_result_t result; + rc = ext4_directory_find_entry(&result, eparent->inode_ref, component); + if (rc != EOK) { + if (rc == ENOENT) { + *rfn = NULL; + return EOK; + } + return rc; + } + + /* Load node from search result */ + uint32_t inode = ext4_directory_entry_ll_get_inode(result.dentry); + rc = ext4fs_node_get_core(rfn, eparent->instance, inode); + if (rc != EOK) { + return rc; + } + + /* Destroy search result structure */ + rc = ext4_directory_destroy_result(&result); + if (rc != EOK) { + return rc; + } + + return EOK; +} + +/** Get node specified by index + * + * It's wrapper for node_put_core operation + * + * @param rfn output pointer to loaded node if operation successful + * @param service_id device identifier + * @param index node index (here i-node number) + * @return error code + */ +int ext4fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index) +{ + int rc; + + ext4fs_instance_t *inst; + rc = ext4fs_instance_get(service_id, &inst); + if (rc != EOK) { + return rc; + } + + return ext4fs_node_get_core(rfn, inst, index); +} + +/** Main function for getting node from the filesystem. + * + * @param rfn output point to loaded node if operation successful + * @param inst instance of filesystem + * @param index index of node (i-node number) + * @return error code + */ +int ext4fs_node_get_core(fs_node_t **rfn, ext4fs_instance_t *inst, + fs_index_t index) +{ + int rc; + + fibril_mutex_lock(&open_nodes_lock); + + /* Check if the node is not already open */ + unsigned long key[] = { + [OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id, + [OPEN_NODES_INODE_KEY] = index, + }; + + link_t *already_open = hash_table_find(&open_nodes, key); + ext4fs_node_t *enode = NULL; + if (already_open) { + enode = hash_table_get_instance(already_open, ext4fs_node_t, link); + *rfn = enode->fs_node; + enode->references++; + + fibril_mutex_unlock(&open_nodes_lock); + return EOK; + } + + /* Prepare new enode */ + enode = malloc(sizeof(ext4fs_node_t)); + if (enode == NULL) { + fibril_mutex_unlock(&open_nodes_lock); + return ENOMEM; + } + + /* Prepare new fs_node and initialize */ + fs_node_t *fs_node = malloc(sizeof(fs_node_t)); + if (fs_node == NULL) { + free(enode); + fibril_mutex_unlock(&open_nodes_lock); + return ENOMEM; + } + fs_node_initialize(fs_node); + + /* Load i-node from filesystem */ + ext4_inode_ref_t *inode_ref; + rc = ext4_filesystem_get_inode_ref(inst->filesystem, index, &inode_ref); + if (rc != EOK) { + free(enode); + free(fs_node); + fibril_mutex_unlock(&open_nodes_lock); + return rc; + } + + /* Initialize enode */ + enode->inode_ref = inode_ref; + enode->instance = inst; + enode->references = 1; + enode->fs_node = fs_node; + link_initialize(&enode->link); + + fs_node->data = enode; + *rfn = fs_node; + + hash_table_insert(&open_nodes, key, &enode->link); + inst->open_nodes_count++; + + fibril_mutex_unlock(&open_nodes_lock); + + return EOK; +} + +/** Put previously loaded node. + * + * @param enode node to put back + * @return error code + */ +int ext4fs_node_put_core(ext4fs_node_t *enode) +{ + int rc; + unsigned long key[] = { + [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->service_id, + [OPEN_NODES_INODE_KEY] = enode->inode_ref->index, + }; + + hash_table_remove(&open_nodes, key, OPEN_NODES_KEYS); + assert(enode->instance->open_nodes_count > 0); + enode->instance->open_nodes_count--; + + /* Put inode back in filesystem */ + rc = ext4_filesystem_put_inode_ref(enode->inode_ref); + if (rc != EOK) { + return rc; + } + + /* Destroy data structure */ + free(enode->fs_node); + free(enode); + + return EOK; +} + + +/** Open node. + * + * This operation is stateless in this driver. + * + * @param fn node to open + * @return error code (EOK) + */ +int ext4fs_node_open(fs_node_t *fn) +{ + /* Stateless operation */ + return EOK; +} + + +/** Put previously loaded node. + * + * It's wrapper for node_put_core operation + * + * @param fn node to put back + * @return error code + */ +int ext4fs_node_put(fs_node_t *fn) +{ + int rc; + + fibril_mutex_lock(&open_nodes_lock); + + ext4fs_node_t *enode = EXT4FS_NODE(fn); + assert(enode->references > 0); + enode->references--; + if (enode->references == 0) { + rc = ext4fs_node_put_core(enode); + if (rc != EOK) { + fibril_mutex_unlock(&open_nodes_lock); + return rc; + } + } + + fibril_mutex_unlock(&open_nodes_lock); + + return EOK; +} + + +/** Create new node in filesystem. + * + * @param rfn output pointer to newly created node if successful + * @param service_id device identifier, where the filesystem is + * @param flags flags for specification of new node parameters + * @return error code + */ +int ext4fs_create_node(fs_node_t **rfn, service_id_t service_id, int flags) +{ + int rc; + + /* Allocate enode */ + ext4fs_node_t *enode; + enode = malloc(sizeof(ext4fs_node_t)); + if (enode == NULL) { + return ENOMEM; + } + + /* Allocate fs_node */ + fs_node_t *fs_node; + fs_node = malloc(sizeof(fs_node_t)); + if (fs_node == NULL) { + free(enode); + return ENOMEM; + } + + /* Load instance */ + ext4fs_instance_t *inst; + rc = ext4fs_instance_get(service_id, &inst); + if (rc != EOK) { + free(enode); + free(fs_node); + return rc; + } + + /* Allocate new i-node in filesystem */ + ext4_inode_ref_t *inode_ref; + rc = ext4_filesystem_alloc_inode(inst->filesystem, &inode_ref, flags); + if (rc != EOK) { + free(enode); + free(fs_node); + return rc; + } + + /* Do some interconnections in references */ + enode->inode_ref = inode_ref; + enode->instance = inst; + enode->references = 1; + + link_initialize(&enode->link); + + unsigned long key[] = { + [OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id, + [OPEN_NODES_INODE_KEY] = inode_ref->index, + }; + + fibril_mutex_lock(&open_nodes_lock); + hash_table_insert(&open_nodes, key, &enode->link); + fibril_mutex_unlock(&open_nodes_lock); + inst->open_nodes_count++; + + enode->inode_ref->dirty = true; + + fs_node_initialize(fs_node); + fs_node->data = enode; + enode->fs_node = fs_node; + *rfn = fs_node; + + return EOK; +} + + +/** Destroy existing node. + * + * @param fs node to destroy + * @return error code + */ +int ext4fs_destroy_node(fs_node_t *fn) +{ + int rc; + + /* If directory, check for children */ + bool has_children; + rc = ext4fs_has_children(&has_children, fn); + if (rc != EOK) { + ext4fs_node_put(fn); + return rc; + } + + if (has_children) { + ext4fs_node_put(fn); + return EINVAL; + } + + ext4fs_node_t *enode = EXT4FS_NODE(fn); + ext4_inode_ref_t *inode_ref = enode->inode_ref; + + /* Release data blocks */ + rc = ext4_filesystem_truncate_inode(inode_ref, 0); + if (rc != EOK) { + ext4fs_node_put(fn); + return rc; + } + + // TODO set real deletion time when it will be supported, temporary set fake time +// time_t now = time(NULL); + ext4_inode_set_deletion_time(inode_ref->inode, 0xdeadbeef); + inode_ref->dirty = true; + + /* Free inode */ + rc = ext4_filesystem_free_inode(inode_ref); + if (rc != EOK) { + ext4fs_node_put(fn); + return rc; + } + + return ext4fs_node_put(fn); +} + + +/** Link the specfied node to directory. + * + * @param pfn parent node to link in + * @param cfn node to be linked + * @param name name which will be assigned to directory entry + * @return error code + */ +int ext4fs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name) +{ + int rc; + + /* Check maximum name length */ + if (strlen(name) > EXT4_DIRECTORY_FILENAME_LEN) { + return ENAMETOOLONG; + } + ext4fs_node_t *parent = EXT4FS_NODE(pfn); + ext4fs_node_t *child = EXT4FS_NODE(cfn); + ext4_filesystem_t *fs = parent->instance->filesystem; + + /* Add entry to parent directory */ + rc = ext4_directory_add_entry(parent->inode_ref, name, child->inode_ref); + if (rc != EOK) { + return rc; + } + + /* Fill new dir -> add '.' and '..' entries */ + if (ext4_inode_is_type(fs->superblock, child->inode_ref->inode, EXT4_INODE_MODE_DIRECTORY)) { + + rc = ext4_directory_add_entry(child->inode_ref, ".", child->inode_ref); + if (rc != EOK) { + ext4_directory_remove_entry(parent->inode_ref, name); + return rc; + } + + rc = ext4_directory_add_entry(child->inode_ref, "..", parent->inode_ref); + if (rc != EOK) { + ext4_directory_remove_entry(parent->inode_ref, name); + ext4_directory_remove_entry(child->inode_ref, "."); + return rc; + } + + /* Initialize directory index if supported */ + if (ext4_superblock_has_feature_compatible( + fs->superblock, EXT4_FEATURE_COMPAT_DIR_INDEX)) { + + rc = ext4_directory_dx_init(child->inode_ref); + if (rc != EOK) { + return rc; + } + + ext4_inode_set_flag(child->inode_ref->inode, EXT4_INODE_FLAG_INDEX); + child->inode_ref->dirty = true; + } + + uint16_t parent_links = ext4_inode_get_links_count(parent->inode_ref->inode); + parent_links++; + ext4_inode_set_links_count(parent->inode_ref->inode, parent_links); + + parent->inode_ref->dirty = true; + + } + + uint16_t child_links = ext4_inode_get_links_count(child->inode_ref->inode); + child_links++; + ext4_inode_set_links_count(child->inode_ref->inode, child_links); + + child->inode_ref->dirty = true; + + return EOK; +} + + +/** Unlink node from specified directory. + * + * @param pfn parent node to delete node from + * @param cfn child node to be unlinked from directory + * @param name name of entry that will be removed + * @return error code + */ +int ext4fs_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name) +{ + int rc; + + bool has_children; + rc = ext4fs_has_children(&has_children, cfn); + if (rc != EOK) { + return rc; + } + + /* Cannot unlink non-empty node */ + if (has_children) { + return ENOTEMPTY; + } + + /* Remove entry from parent directory */ + ext4_inode_ref_t *parent = EXT4FS_NODE(pfn)->inode_ref; + rc = ext4_directory_remove_entry(parent, name); + if (rc != EOK) { + return rc; + } + + /* Decrement links count */ + ext4_inode_ref_t * child_inode_ref = EXT4FS_NODE(cfn)->inode_ref; + + uint32_t lnk_count = ext4_inode_get_links_count(child_inode_ref->inode); + lnk_count--; + + /* If directory - handle links from parent */ + if (lnk_count <= 1 && ext4fs_is_directory(cfn)) { + + assert(lnk_count == 1); + lnk_count--; + + ext4_inode_ref_t *parent_inode_ref = EXT4FS_NODE(pfn)->inode_ref; + + uint32_t parent_lnk_count = ext4_inode_get_links_count( + parent_inode_ref->inode); + + parent_lnk_count--; + ext4_inode_set_links_count(parent_inode_ref->inode, parent_lnk_count); + + parent->dirty = true; + } + + // TODO set timestamps for parent (when we have wall-clock time) +// time_t now = time(NULL); +// ext4_inode_set_change_inode_time(parent->inode, (uint32_t)now); +// ext4_inode_set_modification_time(parent->inode, (uint32_t)now); +// parent->dirty = true; + + // TODO set timestamp for inode +// ext4_inode_set_change_inode_time(child_inode_ref->inode, (uint32_t)now); + ext4_inode_set_links_count(child_inode_ref->inode, lnk_count); + child_inode_ref->dirty = true; + + return EOK; +} + + +/** Check if specified node has children. + * + * For files is response allways false and check is executed only for directories. + * + * @param has_children output value for response + * @param fn node to check + * @return error code + */ +int ext4fs_has_children(bool *has_children, fs_node_t *fn) +{ + int rc; + + ext4fs_node_t *enode = EXT4FS_NODE(fn); + ext4_filesystem_t *fs = enode->instance->filesystem; + + /* Check if node is directory */ + if (!ext4_inode_is_type(fs->superblock, enode->inode_ref->inode, + EXT4_INODE_MODE_DIRECTORY)) { + *has_children = false; + return EOK; + } + + ext4_directory_iterator_t it; + rc = ext4_directory_iterator_init(&it, enode->inode_ref, 0); + if (rc != EOK) { + return rc; + } + + /* Find a non-empty directory entry */ + bool found = false; + while (it.current != NULL) { + if (it.current->inode != 0) { + uint16_t name_size = ext4_directory_entry_ll_get_name_length(fs->superblock, + it.current); + if (!ext4fs_is_dots(it.current->name, name_size)) { + found = true; + break; + } + } + + rc = ext4_directory_iterator_next(&it); + if (rc != EOK) { + ext4_directory_iterator_fini(&it); + return rc; + } + } + + rc = ext4_directory_iterator_fini(&it); + if (rc != EOK) { + return rc; + } + + *has_children = found; + + return EOK; +} + + +/** Unpack index number from node. + * + * @param fn node to load index from + * @return index number of i-node + */ +fs_index_t ext4fs_index_get(fs_node_t *fn) +{ + ext4fs_node_t *enode = EXT4FS_NODE(fn); + return enode->inode_ref->index; +} + + +/** Get real size of file / directory. + * + * @param fn node to get size of + * @return real size of node + */ +aoff64_t ext4fs_size_get(fs_node_t *fn) +{ + ext4fs_node_t *enode = EXT4FS_NODE(fn); + ext4_superblock_t *sb = enode->instance->filesystem->superblock; + return ext4_inode_get_size(sb, enode->inode_ref->inode); +} + + +/** Get number of links to specified node. + * + * @param fn node to get links to + * @return number of links + */ +unsigned ext4fs_lnkcnt_get(fs_node_t *fn) +{ + ext4fs_node_t *enode = EXT4FS_NODE(fn); + uint32_t lnkcnt = ext4_inode_get_links_count(enode->inode_ref->inode); + + if (ext4fs_is_directory(fn)) { + if (lnkcnt > 1) { + return 1; + } else { + return 0; + } + } + + /* For regular files return real links count */ + return lnkcnt; +} + + +/** Check if node is directory. + * + * @param fn node to check + * @return result of check + */ +bool ext4fs_is_directory(fs_node_t *fn) +{ + ext4fs_node_t *enode = EXT4FS_NODE(fn); + ext4_superblock_t *sb = enode->instance->filesystem->superblock; + return ext4_inode_is_type( + sb, enode->inode_ref->inode, EXT4_INODE_MODE_DIRECTORY); +} + + +/** Check if node is regular file. + * + * @param fn node to check + * @return result of check + */ +bool ext4fs_is_file(fs_node_t *fn) +{ + ext4fs_node_t *enode = EXT4FS_NODE(fn); + ext4_superblock_t *sb = enode->instance->filesystem->superblock; + return ext4_inode_is_type( + sb, enode->inode_ref->inode, EXT4_INODE_MODE_FILE); +} + +/** Extract device identifier from node. + * + * @param node node to extract id from + * @return id of device, where is the filesystem + */ +service_id_t ext4fs_service_get(fs_node_t *fn) +{ + ext4fs_node_t *enode = EXT4FS_NODE(fn); + return enode->instance->service_id; +} + +/* + * libfs operations. + */ +libfs_ops_t ext4fs_libfs_ops = { + .root_get = ext4fs_root_get, + .match = ext4fs_match, + .node_get = ext4fs_node_get, + .node_open = ext4fs_node_open, + .node_put = ext4fs_node_put, + .create = ext4fs_create_node, + .destroy = ext4fs_destroy_node, + .link = ext4fs_link, + .unlink = ext4fs_unlink, + .has_children = ext4fs_has_children, + .index_get = ext4fs_index_get, + .size_get = ext4fs_size_get, + .lnkcnt_get = ext4fs_lnkcnt_get, + .is_directory = ext4fs_is_directory, + .is_file = ext4fs_is_file, + .service_get = ext4fs_service_get +}; + + +/* + * VFS operations. + */ + +/** Mount operation. + * + * Try to mount specified filesystem from device. + * + * @param service_id identifier of device + * @param opts mount options + * @param index output value - index of root node + * @param size output value - size of root node + * @param lnkcnt output value - link count of root node + * @return error code + */ +static int ext4fs_mounted(service_id_t service_id, const char *opts, + fs_index_t *index, aoff64_t *size, unsigned *lnkcnt) +{ + int rc; + + /* Allocate libext4 filesystem structure */ + ext4_filesystem_t *fs; + fs = (ext4_filesystem_t *) malloc(sizeof(ext4_filesystem_t)); + if (fs == NULL) { + return ENOMEM; + } + + /* Allocate instance structure */ + ext4fs_instance_t *inst; + inst = (ext4fs_instance_t *) malloc(sizeof(ext4fs_instance_t)); + if (inst == NULL) { + free(fs); + return ENOMEM; + } + + enum cache_mode cmode; + if (str_cmp(opts, "wtcache") == 0) { + cmode = CACHE_MODE_WT; + } else { + cmode = CACHE_MODE_WB; + } + + /* Initialize the filesystem */ + rc = ext4_filesystem_init(fs, service_id, cmode); + if (rc != EOK) { + free(fs); + free(inst); + return rc; + } + + /* Do some sanity checking */ + rc = ext4_filesystem_check_sanity(fs); + if (rc != EOK) { + ext4_filesystem_fini(fs); + free(fs); + free(inst); + return rc; + } + + /* Check flags */ + bool read_only; + rc = ext4_filesystem_check_features(fs, &read_only); + if (rc != EOK) { + ext4_filesystem_fini(fs); + free(fs); + free(inst); + return rc; + } + + /* Initialize instance */ + link_initialize(&inst->link); + inst->service_id = service_id; + inst->filesystem = fs; + inst->open_nodes_count = 0; + + /* Read root node */ + fs_node_t *root_node; + rc = ext4fs_node_get_core(&root_node, inst, EXT4_INODE_ROOT_INDEX); + if (rc != EOK) { + ext4_filesystem_fini(fs); + free(fs); + free(inst); + return rc; + } + + /* Add instance to the list */ + fibril_mutex_lock(&instance_list_mutex); + list_append(&inst->link, &instance_list); + fibril_mutex_unlock(&instance_list_mutex); + + ext4fs_node_t *enode = EXT4FS_NODE(root_node); + + *index = EXT4_INODE_ROOT_INDEX; + *size = ext4_inode_get_size(fs->superblock, enode->inode_ref->inode); + *lnkcnt = 1; + + ext4fs_node_put(root_node); + + return EOK; +} + +/** Unmount operation. + * + * Correctly release the filesystem. + * + * @param service_id device to be unmounted + * @return error code + */ +static int ext4fs_unmounted(service_id_t service_id) +{ + int rc; + + ext4fs_instance_t *inst; + rc = ext4fs_instance_get(service_id, &inst); + if (rc != EOK) { + return rc; + } + + fibril_mutex_lock(&open_nodes_lock); + + if (inst->open_nodes_count != 0) { + fibril_mutex_unlock(&open_nodes_lock); + return EBUSY; + } + + /* Remove the instance from the list */ + fibril_mutex_lock(&instance_list_mutex); + list_remove(&inst->link); + fibril_mutex_unlock(&instance_list_mutex); + + fibril_mutex_unlock(&open_nodes_lock); + + return ext4_filesystem_fini(inst->filesystem); +} + + +/** Read bytes from node. + * + * @param service_id device to read data from + * @param index number of node to read from + * @param pos position where the read should be started + * @param rbytes output value, where the real size was returned + * @return error code + */ +static int ext4fs_read(service_id_t service_id, fs_index_t index, + aoff64_t pos, size_t *rbytes) +{ + int rc; + + /* + * Receive the read request. + */ + ipc_callid_t callid; + size_t size; + if (!async_data_read_receive(&callid, &size)) { + async_answer_0(callid, EINVAL); + return EINVAL; + } + + ext4fs_instance_t *inst; + rc = ext4fs_instance_get(service_id, &inst); + if (rc != EOK) { + async_answer_0(callid, rc); + return rc; + } + + /* Load i-node */ + ext4_inode_ref_t *inode_ref; + rc = ext4_filesystem_get_inode_ref(inst->filesystem, index, &inode_ref); + if (rc != EOK) { + async_answer_0(callid, rc); + return rc; + } + + /* Read from i-node by type */ + if (ext4_inode_is_type(inst->filesystem->superblock, inode_ref->inode, + EXT4_INODE_MODE_FILE)) { + rc = ext4fs_read_file(callid, pos, size, inst, inode_ref, + rbytes); + } else if (ext4_inode_is_type(inst->filesystem->superblock, + inode_ref->inode, EXT4_INODE_MODE_DIRECTORY)) { + rc = ext4fs_read_directory(callid, pos, size, inst, inode_ref, + rbytes); + } else { + /* Other inode types not supported */ + async_answer_0(callid, ENOTSUP); + rc = ENOTSUP; + } + + ext4_filesystem_put_inode_ref(inode_ref); + + return rc; +} + +/** Check if filename is dot or dotdot (reserved names). + * + * @param name name to check + * @param name_size length of string name + * @return result of the check + */ +bool ext4fs_is_dots(const uint8_t *name, size_t name_size) +{ + if (name_size == 1 && name[0] == '.') { + return true; + } + + if (name_size == 2 && name[0] == '.' && name[1] == '.') { + return true; + } + + return false; +} + +/** Read data from directory. + * + * @param callid IPC id of call (for communication) + * @param pos position to start reading from + * @param size how many bytes to read + * @param inst filesystem instance + * @param inode_ref node to read data from + * @param rbytes output value to return real number of bytes was read + * @return error code + */ +int ext4fs_read_directory(ipc_callid_t callid, aoff64_t pos, size_t size, + ext4fs_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes) +{ + int rc; + + ext4_directory_iterator_t it; + rc = ext4_directory_iterator_init(&it, inode_ref, pos); + if (rc != EOK) { + async_answer_0(callid, rc); + return rc; + } + + /* Find next interesting directory entry. + * We want to skip . and .. entries + * as these are not used in HelenOS + */ + bool found = false; + while (it.current != NULL) { + + if (it.current->inode == 0) { + goto skip; + } + + uint16_t name_size = ext4_directory_entry_ll_get_name_length( + inst->filesystem->superblock, it.current); + + /* skip . and .. */ + if (ext4fs_is_dots(it.current->name, name_size)) { + goto skip; + } + + /* The on-disk entry does not contain \0 at the end + * end of entry name, so we copy it to new buffer + * and add the \0 at the end + */ + uint8_t *buf = malloc(name_size+1); + if (buf == NULL) { + ext4_directory_iterator_fini(&it); + async_answer_0(callid, ENOMEM); + return ENOMEM; + } + memcpy(buf, &it.current->name, name_size); + *(buf + name_size) = 0; + found = true; + (void) async_data_read_finalize(callid, buf, name_size + 1); + free(buf); + break; + +skip: + rc = ext4_directory_iterator_next(&it); + if (rc != EOK) { + ext4_directory_iterator_fini(&it); + async_answer_0(callid, rc); + return rc; + } + } + + uint64_t next; + if (found) { + rc = ext4_directory_iterator_next(&it); + if (rc != EOK) { + return rc; + } + next = it.current_offset; + } + + rc = ext4_directory_iterator_fini(&it); + if (rc != EOK) { + return rc; + } + + /* Prepare return values */ + if (found) { + *rbytes = next - pos; + return EOK; + } else { + async_answer_0(callid, ENOENT); + return ENOENT; + } +} + + +/** Read data from file. + * + * @param callid IPC id of call (for communication) + * @param pos position to start reading from + * @param size how many bytes to read + * @param inst filesystem instance + * @param inode_ref node to read data from + * @param rbytes output value to return real number of bytes was read + * @return error code + */ +int ext4fs_read_file(ipc_callid_t callid, aoff64_t pos, size_t size, + ext4fs_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes) +{ + int rc; + + ext4_superblock_t *sb = inst->filesystem->superblock; + uint64_t file_size = ext4_inode_get_size(sb, inode_ref->inode); + + if (pos >= file_size) { + /* Read 0 bytes successfully */ + async_data_read_finalize(callid, NULL, 0); + *rbytes = 0; + return EOK; + } + + /* For now, we only read data from one block at a time */ + uint32_t block_size = ext4_superblock_get_block_size(sb); + aoff64_t file_block = pos / block_size; + uint32_t offset_in_block = pos % block_size; + uint32_t bytes = min(block_size - offset_in_block, size); + + /* Handle end of file */ + if (pos + bytes > file_size) { + bytes = file_size - pos; + } + + /* Get the real block number */ + uint32_t fs_block; + rc = ext4_filesystem_get_inode_data_block_index(inode_ref, file_block, &fs_block); + if (rc != EOK) { + async_answer_0(callid, rc); + return rc; + } + + /* Check for sparse file + * If ext4_filesystem_get_inode_data_block_index returned + * fs_block == 0, it means that the given block is not allocated for the + * file and we need to return a buffer of zeros + */ + uint8_t *buffer; + if (fs_block == 0) { + buffer = malloc(bytes); + if (buffer == NULL) { + async_answer_0(callid, ENOMEM); + return ENOMEM; + } + + memset(buffer, 0, bytes); + + async_data_read_finalize(callid, buffer, bytes); + *rbytes = bytes; + + free(buffer); + + return EOK; + } + + /* Usual case - we need to read a block from device */ + block_t *block; + rc = block_get(&block, inst->service_id, fs_block, BLOCK_FLAGS_NONE); + if (rc != EOK) { + async_answer_0(callid, rc); + return rc; + } + + assert(offset_in_block + bytes <= block_size); + async_data_read_finalize(callid, block->data + offset_in_block, bytes); + + rc = block_put(block); + if (rc != EOK) { + return rc; + } + + *rbytes = bytes; + return EOK; +} + + +/** Write bytes to file + * + * @param service_id device identifier + * @param index i-node number of file + * @param pos position in file to start reading from + * @param wbytes output value - real number of written bytes + * @param nsize output value - new size of i-node + * @return error code + */ +static int ext4fs_write(service_id_t service_id, fs_index_t index, + aoff64_t pos, size_t *wbytes, aoff64_t *nsize) +{ + int rc; + + fs_node_t *fn; + rc = ext4fs_node_get(&fn, service_id, index); + if (rc != EOK) { + return rc; + } + + ipc_callid_t callid; + size_t len; + if (!async_data_write_receive(&callid, &len)) { + rc = EINVAL; + ext4fs_node_put(fn); + async_answer_0(callid, rc); + return rc; + } + + + ext4fs_node_t *enode = EXT4FS_NODE(fn); + ext4_filesystem_t *fs = enode->instance->filesystem; + + uint32_t block_size = ext4_superblock_get_block_size(fs->superblock); + + /* Prevent writing to more than one block */ + uint32_t bytes = min(len, block_size - (pos % block_size)); + + int flags = BLOCK_FLAGS_NONE; + if (bytes == block_size) { + flags = BLOCK_FLAGS_NOREAD; + } + + uint32_t iblock = pos / block_size; + uint32_t fblock; + + /* Load inode */ + ext4_inode_ref_t *inode_ref = enode->inode_ref; + rc = ext4_filesystem_get_inode_data_block_index(inode_ref, iblock, &fblock); + if (rc != EOK) { + ext4fs_node_put(fn); + async_answer_0(callid, rc); + return rc; + } + + /* Check for sparse file */ + if (fblock == 0) { + + if (ext4_superblock_has_feature_incompatible( + fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS) && + (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))) { + + uint32_t last_iblock = ext4_inode_get_size(fs->superblock, inode_ref->inode) / block_size; + while (last_iblock < iblock) { + rc = ext4_extent_append_block(inode_ref, &last_iblock, &fblock, true); + if (rc != EOK) { + ext4fs_node_put(fn); + async_answer_0(callid, rc); + return rc; + } + } + + rc = ext4_extent_append_block(inode_ref, &last_iblock, &fblock, false); + if (rc != EOK) { + ext4fs_node_put(fn); + async_answer_0(callid, rc); + return rc; + } + + } else { + rc = ext4_balloc_alloc_block(inode_ref, &fblock); + if (rc != EOK) { + ext4fs_node_put(fn); + async_answer_0(callid, rc); + return rc; + } + + rc = ext4_filesystem_set_inode_data_block_index(inode_ref, iblock, fblock); + if (rc != EOK) { + ext4_balloc_free_block(inode_ref, fblock); + ext4fs_node_put(fn); + async_answer_0(callid, rc); + return rc; + } + } + + flags = BLOCK_FLAGS_NOREAD; + inode_ref->dirty = true; + } + + /* Load target block */ + block_t *write_block; + rc = block_get(&write_block, service_id, fblock, flags); + if (rc != EOK) { + ext4fs_node_put(fn); + async_answer_0(callid, rc); + return rc; + } + + if (flags == BLOCK_FLAGS_NOREAD) { + memset(write_block->data, 0, block_size); + } + + rc = async_data_write_finalize(callid, write_block->data + (pos % block_size), bytes); + if (rc != EOK) { + ext4fs_node_put(fn); + return rc; + } + + write_block->dirty = true; + + rc = block_put(write_block); + if (rc != EOK) { + ext4fs_node_put(fn); + return rc; + } + + /* Do some counting */ + uint32_t old_inode_size = ext4_inode_get_size(fs->superblock, inode_ref->inode); + if (pos + bytes > old_inode_size) { + ext4_inode_set_size(inode_ref->inode, pos + bytes); + inode_ref->dirty = true; + } + + *nsize = ext4_inode_get_size(fs->superblock, inode_ref->inode); + *wbytes = bytes; + + return ext4fs_node_put(fn); +} + + +/** Truncate file. + * + * Only the direction to shorter file is supported. + * + * @param service_id device identifier + * @param index index if node to truncated + * @param new_size new size of file + * @return error code + */ +static int ext4fs_truncate(service_id_t service_id, fs_index_t index, + aoff64_t new_size) +{ + int rc; + + fs_node_t *fn; + rc = ext4fs_node_get(&fn, service_id, index); + if (rc != EOK) { + return rc; + } + + ext4fs_node_t *enode = EXT4FS_NODE(fn); + ext4_inode_ref_t *inode_ref = enode->inode_ref; + + rc = ext4_filesystem_truncate_inode(inode_ref, new_size); + ext4fs_node_put(fn); + + return rc; +} + + +/** Close file. + * + * @param service_id device identifier + * @param index i-node number + * @return error code + */ +static int ext4fs_close(service_id_t service_id, fs_index_t index) +{ + return EOK; +} + + +/** Destroy node specified by index. + * + * @param service_id device identifier + * @param index number of i-node to destroy + * @return error code + */ +static int ext4fs_destroy(service_id_t service_id, fs_index_t index) +{ + int rc; + + fs_node_t *fn; + rc = ext4fs_node_get(&fn, service_id, index); + if (rc != EOK) { + return rc; + } + + /* Destroy the inode */ + return ext4fs_destroy_node(fn); +} + +/** Enforce inode synchronization (write) to device. + * + * @param service_id device identifier + * @param index i-node number. + */ +static int ext4fs_sync(service_id_t service_id, fs_index_t index) +{ + int rc; + + fs_node_t *fn; + rc = ext4fs_node_get(&fn, service_id, index); + if (rc != EOK) { + return rc; + } + + ext4fs_node_t *enode = EXT4FS_NODE(fn); + enode->inode_ref->dirty = true; + + return ext4fs_node_put(fn); +} + +/** VFS operations + * + */ +vfs_out_ops_t ext4fs_ops = { + .mounted = ext4fs_mounted, + .unmounted = ext4fs_unmounted, + .read = ext4fs_read, + .write = ext4fs_write, + .truncate = ext4fs_truncate, + .close = ext4fs_close, + .destroy = ext4fs_destroy, + .sync = ext4fs_sync, +}; + +/** + * @} + */