Index: uspace/lib/ext4/Makefile =================================================================== --- uspace/lib/ext4/Makefile (revision f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ uspace/lib/ext4/Makefile (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -29,18 +29,18 @@ USPACE_PREFIX = ../.. LIBRARY = libext4 -EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBCRYPTO_PREFIX) +EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBCRYPTO_PREFIX) -Iinclude SOURCES = \ - libext4_balloc.c \ - libext4_bitmap.c \ - libext4_block_group.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 + src/balloc.c \ + src/bitmap.c \ + src/block_group.c \ + src/directory.c \ + src/directory_index.c \ + src/extent.c \ + src/filesystem.c \ + src/hash.c \ + src/ialloc.c \ + src/inode.c \ + src/superblock.c include $(USPACE_PREFIX)/Makefile.common Index: uspace/lib/ext4/include/ext4/balloc.h =================================================================== --- uspace/lib/ext4/include/ext4/balloc.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/balloc.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,50 @@ +/* + * 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 "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/include/ext4/bitmap.h =================================================================== --- uspace/lib/ext4/include/ext4/bitmap.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/bitmap.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -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/include/ext4/block_group.h =================================================================== --- uspace/lib/ext4/include/ext4/block_group.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/block_group.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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 "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/include/ext4/directory.h =================================================================== --- uspace/lib/ext4/include/ext4/directory.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/directory.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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 "ext4/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/include/ext4/directory_index.h =================================================================== --- uspace/lib/ext4/include/ext4/directory_index.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/directory_index.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,77 @@ +/* + * 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 "ext4/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 *); +extern 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/include/ext4/extent.h =================================================================== --- uspace/lib/ext4/include/ext4/extent.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/extent.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,73 @@ +/* + * 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 "ext4/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/include/ext4/filesystem.h =================================================================== --- uspace/lib/ext4/include/ext4/filesystem.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/filesystem.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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 "ext4/types.h" + +extern int ext4_filesystem_init(ext4_filesystem_t *, service_id_t, + enum cache_mode); +extern int ext4_filesystem_fini(ext4_filesystem_t *); +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 uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *, uint64_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 *); +uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg); +uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb, + ext4_block_group_ref_t *bg_ref); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/include/ext4/hash.h =================================================================== --- uspace/lib/ext4/include/ext4/hash.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/hash.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -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 "ext4/types.h" + +extern int ext4_hash_string(ext4_hash_info_t *, int, const char *); + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/include/ext4/ialloc.h =================================================================== --- uspace/lib/ext4/include/ext4/ialloc.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/ialloc.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -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_IALLOC_H_ +#define LIBEXT4_LIBEXT4_IALLOC_H_ + +#include "ext4/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/include/ext4/inode.h =================================================================== --- uspace/lib/ext4/include/ext4/inode.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/inode.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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 "ext4/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); + +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/include/ext4/libext4.h =================================================================== --- uspace/lib/ext4/include/ext4/libext4.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/libext4.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,58 @@ +/* + * 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 "ext4/balloc.h" +#include "ext4/bitmap.h" +#include "ext4/block_group.h" +#include "ext4/directory.h" +#include "ext4/directory_index.h" +#include "ext4/extent.h" +#include "ext4/filesystem.h" +#include "ext4/hash.h" +#include "ext4/ialloc.h" +#include "ext4/inode.h" +#include "ext4/superblock.h" +#include "ext4/types.h" + +#include +#define EXT4FS_DBG(format, ...) \ + printf("ext4fs: %s: " format "\n", \ + __FUNCTION__, ##__VA_ARGS__) \ + +#endif + +/** + * @} + */ Index: uspace/lib/ext4/include/ext4/superblock.h =================================================================== --- uspace/lib/ext4/include/ext4/superblock.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/superblock.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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 "ext4/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 *); + +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); + +extern uint16_t ext4_superblock_get_desc_size(ext4_superblock_t *); +extern void ext4_superblock_set_desc_size(ext4_superblock_t *, uint16_t); + +extern uint32_t ext4_superblock_get_flags(ext4_superblock_t *); +extern void ext4_superblock_set_flags(ext4_superblock_t *, uint32_t); + +extern void ext4_superblock_get_backup_groups_sparse2(ext4_superblock_t *sb, + uint32_t *g1, uint32_t *g2); +extern void ext4_superblock_set_backup_groups_sparse2(ext4_superblock_t *sb, + uint32_t g1, uint32_t g2); + +extern uint32_t ext4_superblock_get_reserved_gdt_blocks(ext4_superblock_t *sb); +extern void ext4_superblock_set_reserved_gdt_blocks(ext4_superblock_t *sb, + uint32_t n); + +/* 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 void ext4_superblock_release(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/include/ext4/types.h =================================================================== --- uspace/lib/ext4/include/ext4/types.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/include/ext4/types.h (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,554 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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; /* I-nodes 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; /* File system 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 prealloc_blocks; /* Number of blocks to try to preallocate */ + uint8_t prealloc_dir_blocks; /* Number to preallocate for dirs */ + uint16_t 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; /* I-node 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; /* I-node number of the head of the on-disk snapshot list */ + uint32_t error_count; /* Number of file system errors */ + uint32_t first_error_time; /* First time an error happened */ + uint32_t first_error_ino; /* I-node 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; /* I-node 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]; /* String containing the mount options */ + uint32_t usr_quota_inum; /* Inode number of user quota file */ + uint32_t grp_quota_inum; /* Inode number of group quota file */ + uint32_t overhead_blocks; /* Overhead blocks/clusters */ + uint32_t backup_bgs[2]; /* Block groups containing superblock backups (if SPARSE_SUPER2) */ + uint32_t encrypt_algos; /* Encrypt algorithm in use */ + uint32_t padding[105]; /* 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 +#define EXT4_FEATURE_COMPAT_SPARSE_SUPER2 0x0200 + +/* + * 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 | \ + EXT4_FEATURE_INCOMPAT_FLEX_BG) + +#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; /* I-nodes bitmap block MSB */ + uint32_t inode_table_first_block_hi; /* I-nodes table block MSB */ + uint16_t free_blocks_count_hi; /* Free blocks count MSB */ + uint16_t free_inodes_count_hi; /* Free i-nodes 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; /* I-node 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; + uint16_t file_acl_high; + uint16_t uid_high; + uint16_t gid_high; + uint32_t reserved2; + } linux2; + struct { + uint16_t reserved1; + 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 */ + +#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; /* I-node 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_C(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' */ + + /** + * Pointer to the physical block of the next + * level. leaf or next index could be there + * high 16 bits of physical block + */ + uint32_t leaf_lo; + uint16_t leaf_hi; + 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/lib/ext4/libext4.h =================================================================== --- uspace/lib/ext4/libext4.h (revision f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,58 +1,0 @@ -/* - * 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_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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,699 +1,0 @@ -/* - * 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" - -/** 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) -{ - ext4_filesystem_t *fs = inode_ref->fs; - ext4_superblock_t *sb = fs->superblock; - - /* Compute indexes */ - uint32_t block_group = ext4_filesystem_blockaddr2group(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; - int 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) { - ext4_filesystem_put_block_group_ref(bg_ref); - 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 */ - return ext4_filesystem_put_block_group_ref(bg_ref); -} - -static int ext4_balloc_free_blocks_internal(ext4_inode_ref_t *inode_ref, - uint32_t first, uint32_t count) -{ - ext4_filesystem_t *fs = inode_ref->fs; - ext4_superblock_t *sb = fs->superblock; - - /* Compute indexes */ - uint32_t block_group_first = ext4_filesystem_blockaddr2group(sb, - first); - uint32_t block_group_last = ext4_filesystem_blockaddr2group(sb, - first + count - 1); - - assert(block_group_first == block_group_last); - - /* Load block group reference */ - ext4_block_group_ref_t *bg_ref; - int 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) { - ext4_filesystem_put_block_group_ref(bg_ref); - 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 */ - return ext4_filesystem_put_block_group_ref(bg_ref); -} - -/** 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 r; - uint32_t gid; - uint64_t limit; - ext4_filesystem_t *fs = inode_ref->fs; - ext4_superblock_t *sb = fs->superblock; - - while (count) { - gid = ext4_filesystem_blockaddr2group(sb, first); - limit = ext4_filesystem_index_in_group2blockaddr(sb, 0, - gid + 1); - - if ((first + count) >= limit) { - /* This extent spans over 2 or more block groups, - * we'll break it into smaller parts. - */ - uint32_t s = limit - first; - - r = ext4_balloc_free_blocks_internal(inode_ref, - first, s); - if (r != EOK) - return r; - - first = limit; - count -= s; - } else { - return ext4_balloc_free_blocks_internal(inode_ref, - first, count); - } - } - - 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 r; - uint64_t itable = ext4_block_group_get_inode_table_first_block( - bg_ref->block_group, sb); - uint32_t itable_sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref); - - if (!ext4_superblock_has_feature_incompatible(sb, - EXT4_FEATURE_INCOMPAT_FLEX_BG)) { - /* If we are not using FLEX_BG, the first data block - * is always after the inode table. - */ - r = itable + itable_sz; - return ext4_filesystem_blockaddr2_index_in_group(sb, r); - } - - uint64_t bbmap = ext4_block_group_get_block_bitmap(bg_ref->block_group, - sb); - uint64_t ibmap = ext4_block_group_get_inode_bitmap(bg_ref->block_group, - sb); - - r = ext4_filesystem_index_in_group2blockaddr(sb, 0, bg_ref->index); - r += ext4_filesystem_bg_get_backup_blocks(bg_ref); - - if (ext4_filesystem_blockaddr2group(sb, bbmap) != bg_ref->index) - bbmap = -1; /* Invalid */ - - if (ext4_filesystem_blockaddr2group(sb, ibmap) != bg_ref->index) - ibmap = -1; - - while (1) { - if (r == bbmap || r == ibmap) - r++; - else if (r >= itable && r < (itable + itable_sz)) - r = itable + itable_sz; - else - break; - } - - return r; -} - -/** Compute 'goal' for allocation algorithm. - * - * @param inode_ref Reference to inode, to allocate block for - * - * @return Goal block number - * - */ -static int ext4_balloc_find_goal(ext4_inode_ref_t *inode_ref, uint32_t *goal) -{ - *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) { - int rc = ext4_filesystem_get_inode_data_block_index(inode_ref, - inode_block_count - 1, goal); - if (rc != EOK) - return rc; - - if (goal != 0) { - (*goal)++; - return EOK; - } - /* 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; - - /* Load block group reference */ - ext4_block_group_ref_t *bg_ref; - int rc = ext4_filesystem_get_block_group_ref(inode_ref->fs, - block_group, &bg_ref); - if (rc != EOK) - return rc; - - *goal = ext4_balloc_get_first_data_block_in_group(sb, bg_ref); - - return ext4_filesystem_put_block_group_ref(bg_ref); -} - -/** 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) -{ - uint32_t allocated_block = 0; - - uint32_t bitmap_block_addr; - block_t *bitmap_block; - uint32_t rel_block_idx = 0; - uint32_t free_blocks; - uint32_t goal; - - /* Find GOAL */ - int rc = ext4_balloc_find_goal(inode_ref, &goal); - if (rc != EOK) - return rc; - - ext4_superblock_t *sb = inode_ref->fs->superblock; - - /* Load block group number for goal and relative index */ - uint32_t block_group = ext4_filesystem_blockaddr2group(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; - - free_blocks = - ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb); - if (free_blocks == 0) { - /* This group has no free blocks */ - goto goal_failed; - } - - /* 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 */ - rc = block_put(bitmap_block); - if (rc != EOK) { - ext4_filesystem_put_block_group_ref(bg_ref); - return rc; - } - -goal_failed: - - rc = ext4_filesystem_put_block_group_ref(bg_ref); - if (rc != EOK) - return rc; - - /* 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; - - free_blocks = - ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb); - if (free_blocks == 0) { - /* This group has no free blocks */ - goto next_group; - } - - /* 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) { - ext4_filesystem_put_block_group_ref(bg_ref); - 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) { - ext4_filesystem_put_block_group_ref(bg_ref); - return rc; - } - - allocated_block = - ext4_filesystem_index_in_group2blockaddr(sb, rel_block_idx, - bgid); - - goto success; - } - - rc = block_put(bitmap_block); - if (rc != EOK) { - ext4_filesystem_put_block_group_ref(bg_ref); - return rc; - } - -next_group: - rc = ext4_filesystem_put_block_group_ref(bg_ref); - if (rc != EOK) - return rc; - - /* 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; - - rc = ext4_filesystem_put_block_group_ref(bg_ref); - - *fblock = allocated_block; - return rc; -} - -/** 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; - - ext4_filesystem_t *fs = inode_ref->fs; - ext4_superblock_t *sb = fs->superblock; - - /* Compute indexes */ - uint32_t block_group = ext4_filesystem_blockaddr2group(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) { - ext4_filesystem_put_block_group_ref(bg_ref); - 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: - return ext4_filesystem_put_block_group_ref(bg_ref); -} - -/** - * @} - */ Index: uspace/lib/ext4/libext4_balloc.h =================================================================== --- uspace/lib/ext4/libext4_balloc.h (revision f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,50 +1,0 @@ -/* - * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,269 +1,0 @@ -/* - * 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 (equal to 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,51 +1,0 @@ -/* - * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,386 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,84 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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_directory.c =================================================================== --- uspace/lib/ext4/libext4_directory.c (revision f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,762 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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 "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; - - /* Else do nothing */ -} - -/** 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) -{ - assert(it->current != NULL); - - uint16_t 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) -{ - 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) { - int 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) { - int rc = block_put(it->current_block); - it->current_block = NULL; - - if (rc != EOK) - return rc; - } - - uint32_t next_block_phys_idx; - int 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) -{ - it->inode_ref = NULL; - it->current = NULL; - - if (it->current_block) - return block_put(it->current_block); - - return EOK; -} - -/** Write directory entry to concrete data block. - * - * @param sb Superblock - * @param entry Pointer to entry to be written - * @param entry_len Length 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) -{ - 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))) { - int rc = ext4_directory_dx_add_entry(parent, child, name); - - /* Check if index is not corrupted */ - if (rc != EXT4_ERR_BAD_DX_DIR) - return rc; - - /* 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; - uint32_t 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 = str_size(name); - - /* Find block, where is space for new entry and try to add */ - bool success = false; - for (iblock = 0; iblock < total_blocks; ++iblock) { - int 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; - int 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); - - return rc; -} - -/** 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) -{ - uint32_t name_len = str_size(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))) { - int 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; - uint32_t 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 */ - int 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) -{ - /* 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; - int 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 (ext4_directory_entry_ll_get_name_length(sb, dentry) == - name_len) { - /* Compare names */ - if (memcmp((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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,81 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,1167 +1,0 @@ -/* - * 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 "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) -{ - /* Load block 0, where will be index root located */ - uint32_t fblock; - int 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; - - return block_put(block); -} - -/** 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) -{ - 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; - ext4_directory_dx_entry_t *q; - ext4_directory_dx_entry_t *m; - ext4_directory_dx_entry_t *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; - int 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 Array 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) -{ - uint32_t num_handles = 0; - ext4_directory_dx_block_t *p = dx_block; - - /* Try to find data block with next bunch of entries */ - while (true) { - 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 EOK; - - 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; - - int 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) */ - rc = block_put(p->block); - if (rc != EOK) - return rc; - - p->block = block; - p->entries = ((ext4_directory_dx_node_t *) block->data)->entries; - p->position = p->entries; - } - - return ENOENT; -} - -/** 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) -{ - /* Load direct block 0 (index root) */ - uint32_t root_block_addr; - int rc2; - int 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 the Linux driver. - */ - ext4_directory_dx_block_t dx_blocks[2]; - ext4_directory_dx_block_t *dx_block; - ext4_directory_dx_block_t *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 */ - rc2 = block_put(leaf_block); - if (rc2 != EOK) - goto cleanup; - - 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 != EOK) - goto cleanup; - - } while (rc == ENOENT); - - /* Entry not found */ - rc = ENOENT; - -cleanup: - /* The whole path must be released (preventing memory leak) */ - tmp = dx_blocks; - - while (tmp <= dx_block) { - rc2 = block_put(tmp->block); - if (rc == EOK && rc2 != EOK) - rc = rc2; - ++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) -{ - 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) { - size_t 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; - int 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 rc2 = EOK; - - /* Get direct block 0 (index root) */ - uint32_t root_block_addr; - int 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 = str_size(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; - ext4_directory_dx_block_t *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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,77 +1,0 @@ -/* - * 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 *); -extern 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,1112 +1,0 @@ -/* - * 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 Ohysical 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; - ext4_extent_index_t *l; - ext4_extent_index_t *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; - ext4_extent_t *l; - ext4_extent_t *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) { - rc = block_put(block); - if (rc != EOK) - return rc; - } - - 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) - rc = block_put(block); - - return rc; -} - -/** 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) -{ - 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; - int rc; - 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: - ; - - int rc2 = EOK; - - /* - * 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) { - rc2 = block_put(tmp_path[i].block); - if (rc == EOK && rc2 != EOK) - rc = rc2; - } - } - - /* 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) -{ - /* 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); - - return ext4_balloc_free_blocks(inode_ref, start, block_count); -} - -/** 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) -{ - uint32_t fblock = ext4_extent_index_get_leaf(index); - - block_t* block; - int 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; - - return ext4_balloc_free_block(inode_ref, fblock); -} - -/** 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) -{ - /* Find the first extent to modify */ - ext4_extent_path_t *path; - int 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: - ; - - int rc2 = EOK; - - /* - * 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) { - rc2 = block_put(path[i].block); - if (rc == EOK && rc2 != EOK) - rc = rc2; - } - } - - /* 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) -{ - 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; - int 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 */ - rc = block_put(path_ptr->block); - if (rc != EOK) { - ext4_balloc_free_block(inode_ref, fblock); - block_put(block); - return rc; - } - - /* 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; - int 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 is 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) -{ - 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; - int 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_extent: - /* Append new extent to the tree */ - 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: - ; - - int rc2 = EOK; - - /* 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) { - rc2 = block_put(path[i].block); - if (rc == EOK && rc2 != EOK) - rc = rc2; - } - } - - /* Destroy temporary data structure */ - free(path); - - return rc; -} - -/** - * @} - */ Index: uspace/lib/ext4/libext4_extent.h =================================================================== --- uspace/lib/ext4/libext4_extent.h (revision f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,73 +1,0 @@ -/* - * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,1559 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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 -#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; - ext4_superblock_t *temp_superblock = NULL; - - fs->device = service_id; - - /* Initialize block library (4096 is size of communication channel) */ - rc = block_init(fs->device, 4096); - if (rc != EOK) - goto err; - - /* Read superblock from device to memory */ - rc = ext4_superblock_read_direct(fs->device, &temp_superblock); - if (rc != EOK) - goto err_1; - - /* 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) { - rc = ENOTSUP; - goto err_1; - } - - /* Initialize block caching by libblock */ - rc = block_cache_init(service_id, block_size, 0, cmode); - if (rc != EOK) - goto err_1; - - /* 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 (unsigned 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) != - EXT4_SUPERBLOCK_STATE_VALID_FS) || - ((state & EXT4_SUPERBLOCK_STATE_ERROR_FS) == - EXT4_SUPERBLOCK_STATE_ERROR_FS)) { - rc = ENOTSUP; - goto err_2; - } - - rc = ext4_superblock_check_sanity(fs->superblock); - if (rc != EOK) - goto err_2; - - /* 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) - goto err_2; - - uint16_t mnt_count = ext4_superblock_get_mount_count(fs->superblock); - ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1); - - return EOK; - -err_2: - block_cache_fini(fs->device); -err_1: - block_fini(fs->device); -err: - if (temp_superblock) - ext4_superblock_release(temp_superblock); - return rc; -} - -/** Destroy filesystem instance (used by unmount operation). - * - * @param fs Filesystem to be destroyed - * - * @return Error code - * - */ -int ext4_filesystem_fini(ext4_filesystem_t *fs) -{ - /* Write the superblock to the device */ - ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_VALID_FS); - int 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 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 - * - * @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; -} - -/** Convert the absolute block number to group number - * - * @param sb Pointer to the superblock - * @param b Absolute block number - * - * @return Group number - */ -uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *sb, uint64_t b) -{ - uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb); - uint32_t first_block = ext4_superblock_get_first_data_block(sb); - - return (b - first_block) / blocks_per_group; -} - -/** 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) -{ - uint64_t itb; - uint32_t sz; - uint32_t i; - - /* Load bitmap */ - ext4_superblock_t *sb = bg_ref->fs->superblock; - uint64_t bitmap_block_addr = ext4_block_group_get_block_bitmap( - bg_ref->block_group, bg_ref->fs->superblock); - uint64_t bitmap_inode_addr = ext4_block_group_get_inode_bitmap( - bg_ref->block_group, bg_ref->fs->superblock); - - block_t *bitmap_block; - int 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(sb); - memset(bitmap, 0, block_size); - - /* Determine the number of reserved blocks in the group */ - uint32_t reserved_cnt = ext4_filesystem_bg_get_backup_blocks(bg_ref); - - /* Set bits from to first block to first data block - 1 to one (allocated) */ - for (uint32_t block = 0; block < reserved_cnt; ++block) - ext4_bitmap_set_bit(bitmap, block); - - uint32_t bitmap_block_gid = ext4_filesystem_blockaddr2group(sb, - bitmap_block_addr); - if (bitmap_block_gid == bg_ref->index) { - ext4_bitmap_set_bit(bitmap, - ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_block_addr)); - } - - uint32_t bitmap_inode_gid = ext4_filesystem_blockaddr2group(sb, - bitmap_inode_addr); - if (bitmap_inode_gid == bg_ref->index) { - ext4_bitmap_set_bit(bitmap, - ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_inode_addr)); - } - - itb = ext4_block_group_get_inode_table_first_block(bg_ref->block_group, - sb); - sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref); - - for (i = 0; i < sz; ++i, ++itb) { - uint32_t gid = ext4_filesystem_blockaddr2group(sb, itb); - if (gid == bg_ref->index) { - ext4_bitmap_set_bit(bitmap, - ext4_filesystem_blockaddr2_index_in_group(sb, itb)); - } - } - - bitmap_block->dirty = true; - - /* Save bitmap */ - return block_put(bitmap_block); -} - -/** 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) -{ - /* 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; - - int 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 */ - return block_put(bitmap_block); -} - -/** 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) -{ - 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; - int 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) -{ - /* 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 */ - int rc = block_get(&newref->block, fs->device, block_id, 0); - if (rc != EOK) { - free(newref); - return rc; - } - - /* Initialize 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); - - 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. - * - * @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_ibm(~0, sb->uuid, sizeof(sb->uuid)); - - /* Include index of block group */ - crc = crc16_ibm(crc, (uint8_t *) &le_group, sizeof(le_group)); - - /* Compute crc from the first part (stop before checksum field) */ - crc = crc16_ibm(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_ibm(crc, ((uint8_t *) bg) + offset, - ext4_superblock_get_desc_size(sb) - offset); - } - - return crc; -} - -/** Get the size of the block group's inode table - * - * @param sb Pointer to the superblock - * @param bg_ref Pointer to the block group reference - * - * @return Size of the inode table in blocks. - */ -uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb, - ext4_block_group_ref_t *bg_ref) -{ - uint32_t itable_size; - uint32_t block_group_count = ext4_superblock_get_block_group_count(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); - - if (bg_ref->index < block_group_count - 1) { - itable_size = 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); - itable_size = - (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) * - inode_table_item_size; - } - - return ROUND_UP(itable_size, block_size) / block_size; -} - -/* Check if n is a power of p */ -static bool is_power_of(uint32_t n, unsigned p) -{ - if (p == 1 && n != p) - return false; - - while (n != p) { - if (n < p) - return false; - else if ((n % p) != 0) - return false; - - n /= p; - } - - return true; -} - -/** Get the number of blocks used by superblock + gdt + reserved gdt backups - * - * @param bg Pointer to block group - * - * @return Number of blocks - */ -uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg) -{ - uint32_t const idx = bg->index; - uint32_t r = 0; - bool has_backups = false; - ext4_superblock_t *sb = bg->fs->superblock; - - /* First step: determine if the block group contains the backups */ - - if (idx <= 1) - has_backups = true; - else { - if (ext4_superblock_has_feature_compatible(sb, - EXT4_FEATURE_COMPAT_SPARSE_SUPER2)) { - uint32_t g1, g2; - - ext4_superblock_get_backup_groups_sparse2(sb, - &g1, &g2); - - if (idx == g1 || idx == g2) - has_backups = true; - } else if (!ext4_superblock_has_feature_read_only(sb, - EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { - /* Very old fs were all block groups have - * superblock and block descriptors backups. - */ - has_backups = true; - } else { - if ((idx & 1) && (is_power_of(idx, 3) || - is_power_of(idx, 5) || is_power_of(idx, 7))) - has_backups = true; - } - } - - if (has_backups) { - uint32_t bg_count; - uint32_t bg_desc_sz; - uint32_t gdt_table; /* Size of the GDT in blocks */ - uint32_t block_size = ext4_superblock_get_block_size(sb); - - /* Now we know that this block group has backups, - * we have to compute how many blocks are reserved - * for them - */ - - if (idx == 0 && block_size == 1024) { - /* Special case for first group were the boot block - * resides - */ - r++; - } - - /* This accounts for the superblock */ - r++; - - /* Add the number of blocks used for the GDT */ - bg_count = ext4_superblock_get_block_group_count(sb); - bg_desc_sz = ext4_superblock_get_desc_size(sb); - gdt_table = ROUND_UP(bg_count * bg_desc_sz, block_size) / - block_size; - - r += gdt_table; - - /* And now the number of reserved GDT blocks */ - r += ext4_superblock_get_reserved_gdt_blocks(sb); - } - - return r; -} - -/** Put reference to block group. - * - * @param ref Pointer for reference to be put back - * - * @return Error code - * - */ -int ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *ref) -{ - /* 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 */ - int 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) -{ - /* 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; - int 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) -{ - /* 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 */ - int 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) -{ - /* 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; - int 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) -{ - 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) { - int 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) { - int 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; - } - } - } - - rc = block_put(block); - if (rc != EOK) - return rc; - - 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) { - int 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; - } - } - } - - rc = block_put(subblock); - if (rc != EOK) { - block_put(block); - return rc; - } - } - - rc = ext4_balloc_free_block(inode_ref, ind_block); - if (rc != EOK) { - block_put(block); - return rc; - } - } - - rc = block_put(block); - if (rc != EOK) - return rc; - - 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) { - int 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 */ - int rc; - 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); - - return rc; -} - -/** 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) -{ - 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 */ - int 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) { - int 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) -{ - 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))) { - int 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 */ - unsigned int level = 0; - for (unsigned int i = 1; i < 4; i++) { - if (iblock < fs->inode_block_limits[i]) { - level = i; - break; - } - } - - if (level == 0) - 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 */ - int 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--; - - /* 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) -{ - 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 */ - unsigned int level = 0; - for (unsigned int i = 1; i < 4; i++) { - if (iblock < fs->inode_block_limits[i]) { - level = i; - break; - } - } - - if (level == 0) - 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; - block_t *new_block; - - /* Is needed to allocate indirect block on the i-node level */ - if (current_block == 0) { - /* Allocate new indirect block */ - int 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) { - int 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--; - - /* - * 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) -{ - 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 */ - unsigned int level = 0; - for (unsigned int i = 1; i < 4; i++) { - if (iblock < fs->inode_block_limits[i]) { - level = i; - break; - } - } - - if (level == 0) - 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) { - - /* Sparse check */ - if (current_block == 0) - return EOK; - - int 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--; - - /* - * 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) -{ - /* 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; - int 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,74 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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 *); -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 uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *, uint64_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 *); -uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg); -uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb, - ext4_block_group_ref_t *bg_ref); - -#endif - -/** - * @} - */ Index: uspace/lib/ext4/libext4_hash.c =================================================================== --- uspace/lib/ext4/libext4_hash.c (revision f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,49 +1,0 @@ -/* - * 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 "libext4.h" -#include - -int ext4_hash_string(ext4_hash_info_t *hinfo, int len, const char *name) -{ - // TODO - hinfo->hash = 0; - return ENOTSUP; -} - -/** - * @} - */ Index: uspace/lib/ext4/libext4_hash.h =================================================================== --- uspace/lib/ext4/libext4_hash.h (revision f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,45 +1,0 @@ -/* - * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,311 +1,0 @@ -/* - * 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 I-node (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) -{ - 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; - int 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) -{ - 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; - int 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 a good candidate - * for allocation. - * - * The criterion is based on the average number - * of free inodes, unless we examine the last block - * group. In that case the last block group might - * have less than the average number of free inodes, - * but it still needs to be taken as a candidate - * because the previous block groups have zero free - * blocks. - */ - if (((free_inodes >= avg_free_inodes) || (bgid == bg_count - 1)) && - (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) { - ext4_filesystem_put_block_group_ref(bg_ref); - 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) { - rc = block_put(bitmap_block); - if (rc != EOK) { - ext4_filesystem_put_block_group_ref(bg_ref); - return rc; - } - - rc = ext4_filesystem_put_block_group_ref(bg_ref); - if (rc != EOK) - return rc; - - bgid++; - continue; - } - - /* Free i-node found, save the bitmap */ - bitmap_block->dirty = true; - - rc = block_put(bitmap_block); - if (rc != EOK) { - ext4_filesystem_put_block_group_ref(bg_ref); - 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); - } - - /* Decrease unused inodes count */ - if (ext4_block_group_has_flag(bg, - EXT4_BLOCK_GROUP_ITABLE_ZEROED)) { - uint32_t unused = - ext4_block_group_get_itable_unused(bg, sb); - - uint32_t inodes_in_group = - ext4_superblock_get_inodes_in_group(sb, bgid); - - uint32_t free = inodes_in_group - unused; - - if (index_in_group >= free) { - unused = inodes_in_group - (index_in_group + 1); - ext4_block_group_set_itable_unused(bg, sb, unused); - } - } - - /* 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 */ - rc = ext4_filesystem_put_block_group_ref(bg_ref); - if (rc != EOK) - return rc; - - ++bgid; - } - - return ENOSPC; -} - -/** - * @} - */ Index: uspace/lib/ext4/libext4_ialloc.h =================================================================== --- uspace/lib/ext4/libext4_ialloc.h (revision f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,45 +1,0 @@ -/* - * 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,594 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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 i-node 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 I-node 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 Flag 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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,86 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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); - -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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,1350 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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 the superblock is located) - * - * @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 the superblock is located) - * - * @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 - * @param frag_size 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 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 Eerror code. - * - */ -int ext4_superblock_read_direct(service_id_t service_id, ext4_superblock_t **sb) -{ - /* Allocated memory for superblock structure */ - void *data = malloc(EXT4_SUPERBLOCK_SIZE); - if (data == NULL) - return ENOMEM; - - /* Read data from block device */ - int 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) -{ - /* Load physical block size from block device */ - size_t phys_block_size; - int 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); -} - -/** Release the memory allocated for the superblock structure - * - * @param sb Superblock to be freed - * - */ -void ext4_superblock_release(ext4_superblock_t *sb) -{ - free(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)); -} - -/** Get the backup groups used with SPARSE_SUPER2 - * - * @param sb Pointer to the superblock - * @param g1 Output pointer to the first backup group - * @param g2 Output pointer to the second backup group - */ -void ext4_superblock_get_backup_groups_sparse2(ext4_superblock_t *sb, - uint32_t *g1, uint32_t *g2) -{ - *g1 = uint32_t_le2host(sb->backup_bgs[0]); - *g2 = uint32_t_le2host(sb->backup_bgs[1]); -} - -/** Set the backup groups (SPARSE SUPER2) - * - * @param sb Pointer to the superblock - * @param g1 Index of the first group - * @param g2 Index of the second group - */ -void ext4_superblock_set_backup_groups_sparse2(ext4_superblock_t *sb, - uint32_t g1, uint32_t g2) -{ - sb->backup_bgs[0] = host2uint32_t_le(g1); - sb->backup_bgs[1] = host2uint32_t_le(g2); -} - -/** Get the number of blocks (per group) reserved to GDT expansion - * - * @param sb Pointer to the superblock - * - * @return Number of blocks - */ -uint32_t ext4_superblock_get_reserved_gdt_blocks(ext4_superblock_t *sb) -{ - return uint32_t_le2host(sb->reserved_gdt_blocks); -} - -/** Set the number of blocks (per group) reserved to GDT expansion - * - * @param sb Pointer to the superblock - * @param n Number of reserved blocks - */ -void ext4_superblock_set_reserved_gdt_blocks(ext4_superblock_t *sb, - uint32_t n) -{ - sb->reserved_gdt_blocks = host2uint32_t_le(n); -} - -/** - * @} - */ Index: uspace/lib/ext4/libext4_superblock.h =================================================================== --- uspace/lib/ext4/libext4_superblock.h (revision f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,169 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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 *); - -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); - -extern uint16_t ext4_superblock_get_desc_size(ext4_superblock_t *); -extern void ext4_superblock_set_desc_size(ext4_superblock_t *, uint16_t); - -extern uint32_t ext4_superblock_get_flags(ext4_superblock_t *); -extern void ext4_superblock_set_flags(ext4_superblock_t *, uint32_t); - -extern void ext4_superblock_get_backup_groups_sparse2(ext4_superblock_t *sb, - uint32_t *g1, uint32_t *g2); -extern void ext4_superblock_set_backup_groups_sparse2(ext4_superblock_t *sb, - uint32_t g1, uint32_t g2); - -extern uint32_t ext4_superblock_get_reserved_gdt_blocks(ext4_superblock_t *sb); -extern void ext4_superblock_set_reserved_gdt_blocks(ext4_superblock_t *sb, - uint32_t n); - -/* 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 void ext4_superblock_release(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 f066a87844b5b81c924cd3bda3e9afda66937cdf) +++ (revision ) @@ -1,554 +1,0 @@ -/* - * Copyright (c) 2011 Martin Sucha - * 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; /* I-nodes 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; /* File system 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 prealloc_blocks; /* Number of blocks to try to preallocate */ - uint8_t prealloc_dir_blocks; /* Number to preallocate for dirs */ - uint16_t 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; /* I-node 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; /* I-node number of the head of the on-disk snapshot list */ - uint32_t error_count; /* Number of file system errors */ - uint32_t first_error_time; /* First time an error happened */ - uint32_t first_error_ino; /* I-node 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; /* I-node 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]; /* String containing the mount options */ - uint32_t usr_quota_inum; /* Inode number of user quota file */ - uint32_t grp_quota_inum; /* Inode number of group quota file */ - uint32_t overhead_blocks; /* Overhead blocks/clusters */ - uint32_t backup_bgs[2]; /* Block groups containing superblock backups (if SPARSE_SUPER2) */ - uint32_t encrypt_algos; /* Encrypt algorithm in use */ - uint32_t padding[105]; /* 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 -#define EXT4_FEATURE_COMPAT_SPARSE_SUPER2 0x0200 - -/* - * 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 | \ - EXT4_FEATURE_INCOMPAT_FLEX_BG) - -#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; /* I-nodes bitmap block MSB */ - uint32_t inode_table_first_block_hi; /* I-nodes table block MSB */ - uint16_t free_blocks_count_hi; /* Free blocks count MSB */ - uint16_t free_inodes_count_hi; /* Free i-nodes 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; /* I-node 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; - uint16_t file_acl_high; - uint16_t uid_high; - uint16_t gid_high; - uint32_t reserved2; - } linux2; - struct { - uint16_t reserved1; - 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 */ - -#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; /* I-node 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_C(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' */ - - /** - * Pointer to the physical block of the next - * level. leaf or next index could be there - * high 16 bits of physical block - */ - uint32_t leaf_lo; - uint16_t leaf_hi; - 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/lib/ext4/src/balloc.c =================================================================== --- uspace/lib/ext4/src/balloc.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/balloc.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,699 @@ +/* + * 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 "ext4/libext4.h" + +/** 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) +{ + ext4_filesystem_t *fs = inode_ref->fs; + ext4_superblock_t *sb = fs->superblock; + + /* Compute indexes */ + uint32_t block_group = ext4_filesystem_blockaddr2group(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; + int 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) { + ext4_filesystem_put_block_group_ref(bg_ref); + 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 */ + return ext4_filesystem_put_block_group_ref(bg_ref); +} + +static int ext4_balloc_free_blocks_internal(ext4_inode_ref_t *inode_ref, + uint32_t first, uint32_t count) +{ + ext4_filesystem_t *fs = inode_ref->fs; + ext4_superblock_t *sb = fs->superblock; + + /* Compute indexes */ + uint32_t block_group_first = ext4_filesystem_blockaddr2group(sb, + first); + uint32_t block_group_last = ext4_filesystem_blockaddr2group(sb, + first + count - 1); + + assert(block_group_first == block_group_last); + + /* Load block group reference */ + ext4_block_group_ref_t *bg_ref; + int 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) { + ext4_filesystem_put_block_group_ref(bg_ref); + 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 */ + return ext4_filesystem_put_block_group_ref(bg_ref); +} + +/** 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 r; + uint32_t gid; + uint64_t limit; + ext4_filesystem_t *fs = inode_ref->fs; + ext4_superblock_t *sb = fs->superblock; + + while (count) { + gid = ext4_filesystem_blockaddr2group(sb, first); + limit = ext4_filesystem_index_in_group2blockaddr(sb, 0, + gid + 1); + + if ((first + count) >= limit) { + /* This extent spans over 2 or more block groups, + * we'll break it into smaller parts. + */ + uint32_t s = limit - first; + + r = ext4_balloc_free_blocks_internal(inode_ref, + first, s); + if (r != EOK) + return r; + + first = limit; + count -= s; + } else { + return ext4_balloc_free_blocks_internal(inode_ref, + first, count); + } + } + + 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 r; + uint64_t itable = ext4_block_group_get_inode_table_first_block( + bg_ref->block_group, sb); + uint32_t itable_sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref); + + if (!ext4_superblock_has_feature_incompatible(sb, + EXT4_FEATURE_INCOMPAT_FLEX_BG)) { + /* If we are not using FLEX_BG, the first data block + * is always after the inode table. + */ + r = itable + itable_sz; + return ext4_filesystem_blockaddr2_index_in_group(sb, r); + } + + uint64_t bbmap = ext4_block_group_get_block_bitmap(bg_ref->block_group, + sb); + uint64_t ibmap = ext4_block_group_get_inode_bitmap(bg_ref->block_group, + sb); + + r = ext4_filesystem_index_in_group2blockaddr(sb, 0, bg_ref->index); + r += ext4_filesystem_bg_get_backup_blocks(bg_ref); + + if (ext4_filesystem_blockaddr2group(sb, bbmap) != bg_ref->index) + bbmap = -1; /* Invalid */ + + if (ext4_filesystem_blockaddr2group(sb, ibmap) != bg_ref->index) + ibmap = -1; + + while (1) { + if (r == bbmap || r == ibmap) + r++; + else if (r >= itable && r < (itable + itable_sz)) + r = itable + itable_sz; + else + break; + } + + return r; +} + +/** Compute 'goal' for allocation algorithm. + * + * @param inode_ref Reference to inode, to allocate block for + * + * @return Goal block number + * + */ +static int ext4_balloc_find_goal(ext4_inode_ref_t *inode_ref, uint32_t *goal) +{ + *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) { + int rc = ext4_filesystem_get_inode_data_block_index(inode_ref, + inode_block_count - 1, goal); + if (rc != EOK) + return rc; + + if (goal != 0) { + (*goal)++; + return EOK; + } + /* 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; + + /* Load block group reference */ + ext4_block_group_ref_t *bg_ref; + int rc = ext4_filesystem_get_block_group_ref(inode_ref->fs, + block_group, &bg_ref); + if (rc != EOK) + return rc; + + *goal = ext4_balloc_get_first_data_block_in_group(sb, bg_ref); + + return ext4_filesystem_put_block_group_ref(bg_ref); +} + +/** 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) +{ + uint32_t allocated_block = 0; + + uint32_t bitmap_block_addr; + block_t *bitmap_block; + uint32_t rel_block_idx = 0; + uint32_t free_blocks; + uint32_t goal; + + /* Find GOAL */ + int rc = ext4_balloc_find_goal(inode_ref, &goal); + if (rc != EOK) + return rc; + + ext4_superblock_t *sb = inode_ref->fs->superblock; + + /* Load block group number for goal and relative index */ + uint32_t block_group = ext4_filesystem_blockaddr2group(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; + + free_blocks = + ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb); + if (free_blocks == 0) { + /* This group has no free blocks */ + goto goal_failed; + } + + /* 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 */ + rc = block_put(bitmap_block); + if (rc != EOK) { + ext4_filesystem_put_block_group_ref(bg_ref); + return rc; + } + +goal_failed: + + rc = ext4_filesystem_put_block_group_ref(bg_ref); + if (rc != EOK) + return rc; + + /* 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; + + free_blocks = + ext4_block_group_get_free_blocks_count(bg_ref->block_group, sb); + if (free_blocks == 0) { + /* This group has no free blocks */ + goto next_group; + } + + /* 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) { + ext4_filesystem_put_block_group_ref(bg_ref); + 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) { + ext4_filesystem_put_block_group_ref(bg_ref); + return rc; + } + + allocated_block = + ext4_filesystem_index_in_group2blockaddr(sb, rel_block_idx, + bgid); + + goto success; + } + + rc = block_put(bitmap_block); + if (rc != EOK) { + ext4_filesystem_put_block_group_ref(bg_ref); + return rc; + } + +next_group: + rc = ext4_filesystem_put_block_group_ref(bg_ref); + if (rc != EOK) + return rc; + + /* 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; + + rc = ext4_filesystem_put_block_group_ref(bg_ref); + + *fblock = allocated_block; + return rc; +} + +/** 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; + + ext4_filesystem_t *fs = inode_ref->fs; + ext4_superblock_t *sb = fs->superblock; + + /* Compute indexes */ + uint32_t block_group = ext4_filesystem_blockaddr2group(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) { + ext4_filesystem_put_block_group_ref(bg_ref); + 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: + return ext4_filesystem_put_block_group_ref(bg_ref); +} + +/** + * @} + */ Index: uspace/lib/ext4/src/bitmap.c =================================================================== --- uspace/lib/ext4/src/bitmap.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/bitmap.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,269 @@ +/* + * 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 "ext4/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 (equal to 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/src/block_group.c =================================================================== --- uspace/lib/ext4/src/block_group.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/block_group.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,386 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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 "ext4/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/src/directory.c =================================================================== --- uspace/lib/ext4/src/directory.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/directory.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,762 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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 "ext4/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; + + /* Else do nothing */ +} + +/** 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) +{ + assert(it->current != NULL); + + uint16_t 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) +{ + 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) { + int 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) { + int rc = block_put(it->current_block); + it->current_block = NULL; + + if (rc != EOK) + return rc; + } + + uint32_t next_block_phys_idx; + int 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) +{ + it->inode_ref = NULL; + it->current = NULL; + + if (it->current_block) + return block_put(it->current_block); + + return EOK; +} + +/** Write directory entry to concrete data block. + * + * @param sb Superblock + * @param entry Pointer to entry to be written + * @param entry_len Length 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) +{ + 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))) { + int rc = ext4_directory_dx_add_entry(parent, child, name); + + /* Check if index is not corrupted */ + if (rc != EXT4_ERR_BAD_DX_DIR) + return rc; + + /* 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; + uint32_t 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 = str_size(name); + + /* Find block, where is space for new entry and try to add */ + bool success = false; + for (iblock = 0; iblock < total_blocks; ++iblock) { + int 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; + int 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); + + return rc; +} + +/** 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) +{ + uint32_t name_len = str_size(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))) { + int 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; + uint32_t 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 */ + int 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) +{ + /* 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; + int 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 (ext4_directory_entry_ll_get_name_length(sb, dentry) == + name_len) { + /* Compare names */ + if (memcmp((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/src/directory_index.c =================================================================== --- uspace/lib/ext4/src/directory_index.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/directory_index.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,1167 @@ +/* + * 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 "ext4/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) +{ + /* Load block 0, where will be index root located */ + uint32_t fblock; + int 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; + + return block_put(block); +} + +/** 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) +{ + 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; + ext4_directory_dx_entry_t *q; + ext4_directory_dx_entry_t *m; + ext4_directory_dx_entry_t *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; + int 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 Array 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) +{ + uint32_t num_handles = 0; + ext4_directory_dx_block_t *p = dx_block; + + /* Try to find data block with next bunch of entries */ + while (true) { + 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 EOK; + + 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; + + int 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) */ + rc = block_put(p->block); + if (rc != EOK) + return rc; + + p->block = block; + p->entries = ((ext4_directory_dx_node_t *) block->data)->entries; + p->position = p->entries; + } + + return ENOENT; +} + +/** 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) +{ + /* Load direct block 0 (index root) */ + uint32_t root_block_addr; + int rc2; + int 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 the Linux driver. + */ + ext4_directory_dx_block_t dx_blocks[2]; + ext4_directory_dx_block_t *dx_block; + ext4_directory_dx_block_t *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 */ + rc2 = block_put(leaf_block); + if (rc2 != EOK) + goto cleanup; + + 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 != EOK) + goto cleanup; + + } while (rc == ENOENT); + + /* Entry not found */ + rc = ENOENT; + +cleanup: + /* The whole path must be released (preventing memory leak) */ + tmp = dx_blocks; + + while (tmp <= dx_block) { + rc2 = block_put(tmp->block); + if (rc == EOK && rc2 != EOK) + rc = rc2; + ++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) +{ + 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) { + size_t 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; + int 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 rc2 = EOK; + + /* Get direct block 0 (index root) */ + uint32_t root_block_addr; + int 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 = str_size(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; + ext4_directory_dx_block_t *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/src/extent.c =================================================================== --- uspace/lib/ext4/src/extent.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/extent.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,1112 @@ +/* + * 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 "ext4/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 Ohysical 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; + ext4_extent_index_t *l; + ext4_extent_index_t *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; + ext4_extent_t *l; + ext4_extent_t *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) { + rc = block_put(block); + if (rc != EOK) + return rc; + } + + 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) + rc = block_put(block); + + return rc; +} + +/** 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) +{ + 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; + int rc; + 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: + ; + + int rc2 = EOK; + + /* + * 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) { + rc2 = block_put(tmp_path[i].block); + if (rc == EOK && rc2 != EOK) + rc = rc2; + } + } + + /* 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) +{ + /* 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); + + return ext4_balloc_free_blocks(inode_ref, start, block_count); +} + +/** 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) +{ + uint32_t fblock = ext4_extent_index_get_leaf(index); + + block_t* block; + int 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; + + return ext4_balloc_free_block(inode_ref, fblock); +} + +/** 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) +{ + /* Find the first extent to modify */ + ext4_extent_path_t *path; + int 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: + ; + + int rc2 = EOK; + + /* + * 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) { + rc2 = block_put(path[i].block); + if (rc == EOK && rc2 != EOK) + rc = rc2; + } + } + + /* 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) +{ + 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; + int 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 */ + rc = block_put(path_ptr->block); + if (rc != EOK) { + ext4_balloc_free_block(inode_ref, fblock); + block_put(block); + return rc; + } + + /* 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; + int 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 is 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) +{ + 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; + int 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_extent: + /* Append new extent to the tree */ + 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: + ; + + int rc2 = EOK; + + /* 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) { + rc2 = block_put(path[i].block); + if (rc == EOK && rc2 != EOK) + rc = rc2; + } + } + + /* Destroy temporary data structure */ + free(path); + + return rc; +} + +/** + * @} + */ Index: uspace/lib/ext4/src/filesystem.c =================================================================== --- uspace/lib/ext4/src/filesystem.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/filesystem.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,1559 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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 +#include +#include +#include "ext4/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; + ext4_superblock_t *temp_superblock = NULL; + + fs->device = service_id; + + /* Initialize block library (4096 is size of communication channel) */ + rc = block_init(fs->device, 4096); + if (rc != EOK) + goto err; + + /* Read superblock from device to memory */ + rc = ext4_superblock_read_direct(fs->device, &temp_superblock); + if (rc != EOK) + goto err_1; + + /* 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) { + rc = ENOTSUP; + goto err_1; + } + + /* Initialize block caching by libblock */ + rc = block_cache_init(service_id, block_size, 0, cmode); + if (rc != EOK) + goto err_1; + + /* 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 (unsigned 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) != + EXT4_SUPERBLOCK_STATE_VALID_FS) || + ((state & EXT4_SUPERBLOCK_STATE_ERROR_FS) == + EXT4_SUPERBLOCK_STATE_ERROR_FS)) { + rc = ENOTSUP; + goto err_2; + } + + rc = ext4_superblock_check_sanity(fs->superblock); + if (rc != EOK) + goto err_2; + + /* 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) + goto err_2; + + uint16_t mnt_count = ext4_superblock_get_mount_count(fs->superblock); + ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1); + + return EOK; + +err_2: + block_cache_fini(fs->device); +err_1: + block_fini(fs->device); +err: + if (temp_superblock) + ext4_superblock_release(temp_superblock); + return rc; +} + +/** Destroy filesystem instance (used by unmount operation). + * + * @param fs Filesystem to be destroyed + * + * @return Error code + * + */ +int ext4_filesystem_fini(ext4_filesystem_t *fs) +{ + /* Write the superblock to the device */ + ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_VALID_FS); + int 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 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 + * + * @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; +} + +/** Convert the absolute block number to group number + * + * @param sb Pointer to the superblock + * @param b Absolute block number + * + * @return Group number + */ +uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *sb, uint64_t b) +{ + uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb); + uint32_t first_block = ext4_superblock_get_first_data_block(sb); + + return (b - first_block) / blocks_per_group; +} + +/** 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) +{ + uint64_t itb; + uint32_t sz; + uint32_t i; + + /* Load bitmap */ + ext4_superblock_t *sb = bg_ref->fs->superblock; + uint64_t bitmap_block_addr = ext4_block_group_get_block_bitmap( + bg_ref->block_group, bg_ref->fs->superblock); + uint64_t bitmap_inode_addr = ext4_block_group_get_inode_bitmap( + bg_ref->block_group, bg_ref->fs->superblock); + + block_t *bitmap_block; + int 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(sb); + memset(bitmap, 0, block_size); + + /* Determine the number of reserved blocks in the group */ + uint32_t reserved_cnt = ext4_filesystem_bg_get_backup_blocks(bg_ref); + + /* Set bits from to first block to first data block - 1 to one (allocated) */ + for (uint32_t block = 0; block < reserved_cnt; ++block) + ext4_bitmap_set_bit(bitmap, block); + + uint32_t bitmap_block_gid = ext4_filesystem_blockaddr2group(sb, + bitmap_block_addr); + if (bitmap_block_gid == bg_ref->index) { + ext4_bitmap_set_bit(bitmap, + ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_block_addr)); + } + + uint32_t bitmap_inode_gid = ext4_filesystem_blockaddr2group(sb, + bitmap_inode_addr); + if (bitmap_inode_gid == bg_ref->index) { + ext4_bitmap_set_bit(bitmap, + ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_inode_addr)); + } + + itb = ext4_block_group_get_inode_table_first_block(bg_ref->block_group, + sb); + sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref); + + for (i = 0; i < sz; ++i, ++itb) { + uint32_t gid = ext4_filesystem_blockaddr2group(sb, itb); + if (gid == bg_ref->index) { + ext4_bitmap_set_bit(bitmap, + ext4_filesystem_blockaddr2_index_in_group(sb, itb)); + } + } + + bitmap_block->dirty = true; + + /* Save bitmap */ + return block_put(bitmap_block); +} + +/** 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) +{ + /* 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; + + int 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 */ + return block_put(bitmap_block); +} + +/** 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) +{ + 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; + int 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) +{ + /* 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 */ + int rc = block_get(&newref->block, fs->device, block_id, 0); + if (rc != EOK) { + free(newref); + return rc; + } + + /* Initialize 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); + + 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. + * + * @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_ibm(~0, sb->uuid, sizeof(sb->uuid)); + + /* Include index of block group */ + crc = crc16_ibm(crc, (uint8_t *) &le_group, sizeof(le_group)); + + /* Compute crc from the first part (stop before checksum field) */ + crc = crc16_ibm(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_ibm(crc, ((uint8_t *) bg) + offset, + ext4_superblock_get_desc_size(sb) - offset); + } + + return crc; +} + +/** Get the size of the block group's inode table + * + * @param sb Pointer to the superblock + * @param bg_ref Pointer to the block group reference + * + * @return Size of the inode table in blocks. + */ +uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb, + ext4_block_group_ref_t *bg_ref) +{ + uint32_t itable_size; + uint32_t block_group_count = ext4_superblock_get_block_group_count(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); + + if (bg_ref->index < block_group_count - 1) { + itable_size = 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); + itable_size = + (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) * + inode_table_item_size; + } + + return ROUND_UP(itable_size, block_size) / block_size; +} + +/* Check if n is a power of p */ +static bool is_power_of(uint32_t n, unsigned p) +{ + if (p == 1 && n != p) + return false; + + while (n != p) { + if (n < p) + return false; + else if ((n % p) != 0) + return false; + + n /= p; + } + + return true; +} + +/** Get the number of blocks used by superblock + gdt + reserved gdt backups + * + * @param bg Pointer to block group + * + * @return Number of blocks + */ +uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg) +{ + uint32_t const idx = bg->index; + uint32_t r = 0; + bool has_backups = false; + ext4_superblock_t *sb = bg->fs->superblock; + + /* First step: determine if the block group contains the backups */ + + if (idx <= 1) + has_backups = true; + else { + if (ext4_superblock_has_feature_compatible(sb, + EXT4_FEATURE_COMPAT_SPARSE_SUPER2)) { + uint32_t g1, g2; + + ext4_superblock_get_backup_groups_sparse2(sb, + &g1, &g2); + + if (idx == g1 || idx == g2) + has_backups = true; + } else if (!ext4_superblock_has_feature_read_only(sb, + EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { + /* Very old fs were all block groups have + * superblock and block descriptors backups. + */ + has_backups = true; + } else { + if ((idx & 1) && (is_power_of(idx, 3) || + is_power_of(idx, 5) || is_power_of(idx, 7))) + has_backups = true; + } + } + + if (has_backups) { + uint32_t bg_count; + uint32_t bg_desc_sz; + uint32_t gdt_table; /* Size of the GDT in blocks */ + uint32_t block_size = ext4_superblock_get_block_size(sb); + + /* Now we know that this block group has backups, + * we have to compute how many blocks are reserved + * for them + */ + + if (idx == 0 && block_size == 1024) { + /* Special case for first group were the boot block + * resides + */ + r++; + } + + /* This accounts for the superblock */ + r++; + + /* Add the number of blocks used for the GDT */ + bg_count = ext4_superblock_get_block_group_count(sb); + bg_desc_sz = ext4_superblock_get_desc_size(sb); + gdt_table = ROUND_UP(bg_count * bg_desc_sz, block_size) / + block_size; + + r += gdt_table; + + /* And now the number of reserved GDT blocks */ + r += ext4_superblock_get_reserved_gdt_blocks(sb); + } + + return r; +} + +/** Put reference to block group. + * + * @param ref Pointer for reference to be put back + * + * @return Error code + * + */ +int ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *ref) +{ + /* 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 */ + int 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) +{ + /* 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; + int 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) +{ + /* 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 */ + int 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) +{ + /* 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; + int 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) +{ + 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) { + int 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) { + int 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; + } + } + } + + rc = block_put(block); + if (rc != EOK) + return rc; + + 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) { + int 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; + } + } + } + + rc = block_put(subblock); + if (rc != EOK) { + block_put(block); + return rc; + } + } + + rc = ext4_balloc_free_block(inode_ref, ind_block); + if (rc != EOK) { + block_put(block); + return rc; + } + } + + rc = block_put(block); + if (rc != EOK) + return rc; + + 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) { + int 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 */ + int rc; + 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); + + return rc; +} + +/** 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) +{ + 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 */ + int 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) { + int 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) +{ + 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))) { + int 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 */ + unsigned int level = 0; + for (unsigned int i = 1; i < 4; i++) { + if (iblock < fs->inode_block_limits[i]) { + level = i; + break; + } + } + + if (level == 0) + 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 */ + int 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--; + + /* 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) +{ + 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 */ + unsigned int level = 0; + for (unsigned int i = 1; i < 4; i++) { + if (iblock < fs->inode_block_limits[i]) { + level = i; + break; + } + } + + if (level == 0) + 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; + block_t *new_block; + + /* Is needed to allocate indirect block on the i-node level */ + if (current_block == 0) { + /* Allocate new indirect block */ + int 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) { + int 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--; + + /* + * 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) +{ + 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 */ + unsigned int level = 0; + for (unsigned int i = 1; i < 4; i++) { + if (iblock < fs->inode_block_limits[i]) { + level = i; + break; + } + } + + if (level == 0) + 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) { + + /* Sparse check */ + if (current_block == 0) + return EOK; + + int 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--; + + /* + * 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) +{ + /* 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; + int 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/src/hash.c =================================================================== --- uspace/lib/ext4/src/hash.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/hash.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -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 libext4 + * @{ + */ +/** + * @file libext4_hash.c + * @brief Hashing algorithms for ext4 HTree. + */ + +#include "ext4/libext4.h" +#include + +int ext4_hash_string(ext4_hash_info_t *hinfo, int len, const char *name) +{ + // TODO + hinfo->hash = 0; + return ENOTSUP; +} + +/** + * @} + */ Index: uspace/lib/ext4/src/ialloc.c =================================================================== --- uspace/lib/ext4/src/ialloc.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/ialloc.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,311 @@ +/* + * 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 I-node (de)allocation operations. + */ + +#include +#include +#include "ext4/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) +{ + 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; + int 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) +{ + 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; + int 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 a good candidate + * for allocation. + * + * The criterion is based on the average number + * of free inodes, unless we examine the last block + * group. In that case the last block group might + * have less than the average number of free inodes, + * but it still needs to be taken as a candidate + * because the previous block groups have zero free + * blocks. + */ + if (((free_inodes >= avg_free_inodes) || (bgid == bg_count - 1)) && + (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) { + ext4_filesystem_put_block_group_ref(bg_ref); + 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) { + rc = block_put(bitmap_block); + if (rc != EOK) { + ext4_filesystem_put_block_group_ref(bg_ref); + return rc; + } + + rc = ext4_filesystem_put_block_group_ref(bg_ref); + if (rc != EOK) + return rc; + + bgid++; + continue; + } + + /* Free i-node found, save the bitmap */ + bitmap_block->dirty = true; + + rc = block_put(bitmap_block); + if (rc != EOK) { + ext4_filesystem_put_block_group_ref(bg_ref); + 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); + } + + /* Decrease unused inodes count */ + if (ext4_block_group_has_flag(bg, + EXT4_BLOCK_GROUP_ITABLE_ZEROED)) { + uint32_t unused = + ext4_block_group_get_itable_unused(bg, sb); + + uint32_t inodes_in_group = + ext4_superblock_get_inodes_in_group(sb, bgid); + + uint32_t free = inodes_in_group - unused; + + if (index_in_group >= free) { + unused = inodes_in_group - (index_in_group + 1); + ext4_block_group_set_itable_unused(bg, sb, unused); + } + } + + /* 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 */ + rc = ext4_filesystem_put_block_group_ref(bg_ref); + if (rc != EOK) + return rc; + + ++bgid; + } + + return ENOSPC; +} + +/** + * @} + */ Index: uspace/lib/ext4/src/inode.c =================================================================== --- uspace/lib/ext4/src/inode.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/inode.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,594 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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 i-node structure operations. + */ + +#include +#include +#include +#include "ext4/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 I-node 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 Flag 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/src/superblock.c =================================================================== --- uspace/lib/ext4/src/superblock.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) +++ uspace/lib/ext4/src/superblock.c (revision 3345b8643e43d3ed4e6235473b2897c18e8a697c) @@ -0,0 +1,1350 @@ +/* + * Copyright (c) 2011 Martin Sucha + * 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 "ext4/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 the superblock is located) + * + * @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 the superblock is located) + * + * @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 + * @param frag_size 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 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 Eerror code. + * + */ +int ext4_superblock_read_direct(service_id_t service_id, ext4_superblock_t **sb) +{ + /* Allocated memory for superblock structure */ + void *data = malloc(EXT4_SUPERBLOCK_SIZE); + if (data == NULL) + return ENOMEM; + + /* Read data from block device */ + int 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) +{ + /* Load physical block size from block device */ + size_t phys_block_size; + int 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); +} + +/** Release the memory allocated for the superblock structure + * + * @param sb Superblock to be freed + * + */ +void ext4_superblock_release(ext4_superblock_t *sb) +{ + free(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)); +} + +/** Get the backup groups used with SPARSE_SUPER2 + * + * @param sb Pointer to the superblock + * @param g1 Output pointer to the first backup group + * @param g2 Output pointer to the second backup group + */ +void ext4_superblock_get_backup_groups_sparse2(ext4_superblock_t *sb, + uint32_t *g1, uint32_t *g2) +{ + *g1 = uint32_t_le2host(sb->backup_bgs[0]); + *g2 = uint32_t_le2host(sb->backup_bgs[1]); +} + +/** Set the backup groups (SPARSE SUPER2) + * + * @param sb Pointer to the superblock + * @param g1 Index of the first group + * @param g2 Index of the second group + */ +void ext4_superblock_set_backup_groups_sparse2(ext4_superblock_t *sb, + uint32_t g1, uint32_t g2) +{ + sb->backup_bgs[0] = host2uint32_t_le(g1); + sb->backup_bgs[1] = host2uint32_t_le(g2); +} + +/** Get the number of blocks (per group) reserved to GDT expansion + * + * @param sb Pointer to the superblock + * + * @return Number of blocks + */ +uint32_t ext4_superblock_get_reserved_gdt_blocks(ext4_superblock_t *sb) +{ + return uint32_t_le2host(sb->reserved_gdt_blocks); +} + +/** Set the number of blocks (per group) reserved to GDT expansion + * + * @param sb Pointer to the superblock + * @param n Number of reserved blocks + */ +void ext4_superblock_set_reserved_gdt_blocks(ext4_superblock_t *sb, + uint32_t n) +{ + sb->reserved_gdt_blocks = host2uint32_t_le(n); +} + +/** + * @} + */