/* * Copyright (c) 2015 Grzegorz Kostka (kostka.grzegorz@gmail.com) * 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 lwext4 * @{ *//** * @file ext4_mkfs.c * @brief */ #include <ext4_config.h>#include <ext4_types.h>#include <ext4_misc.h>#include <ext4_errno.h>#include <ext4_debug.h> #include <ext4_super.h>#include <ext4_block_group.h>#include <ext4_dir.h>#include <ext4_dir_idx.h>#include <ext4_fs.h>#include <ext4_inode.h>#include <ext4_ialloc.h>#include <ext4_mkfs.h> #include <inttypes.h>#include <string.h>#include <stdlib.h> static inline int log_2(int j){ int i; for (i = 0; j > 0; i++) j >>= 1; return i - 1;} static int sb2info(struct ext4_sblock *sb, struct ext4_mkfs_info *info){ if (to_le16(sb->magic) != EXT4_SUPERBLOCK_MAGIC) return EINVAL; info->block_size = 1024 << to_le32(sb->log_block_size); info->blocks_per_group = to_le32(sb->blocks_per_group); info->inodes_per_group = to_le32(sb->inodes_per_group); info->inode_size = to_le16(sb->inode_size); info->inodes = to_le32(sb->inodes_count); info->feat_ro_compat = to_le32(sb->features_read_only); info->feat_compat = to_le32(sb->features_compatible); info->feat_incompat = to_le32(sb->features_incompatible); info->bg_desc_reserve_blocks = to_le16(sb->s_reserved_gdt_blocks); strncpy(info->label,sb->volume_name,sizeof(info->label)); info->len = (uint64_t)info->block_size * ext4_sb_get_blocks_cnt(sb); info->dsc_size = to_le16(sb->desc_size); memcpy(info->uuid, sb->uuid, UUID_SIZE); return EOK;} static uint32_t compute_blocks_per_group(struct ext4_mkfs_info *info){ return info->block_size * 8;} static uint32_t compute_inodes(struct ext4_mkfs_info *info){ return (uint32_t)EXT4_DIV_ROUND_UP(info->len, info->block_size) / 4;} static uint32_t compute_inodes_per_group(struct ext4_mkfs_info *info){ uint32_t blocks = (uint32_t)EXT4_DIV_ROUND_UP(info->len, info->block_size); uint32_t block_groups = EXT4_DIV_ROUND_UP(blocks, info->blocks_per_group); uint32_t inodes = EXT4_DIV_ROUND_UP(info->inodes, block_groups); inodes = EXT4_ALIGN(inodes, (info->block_size / info->inode_size)); /* After properly rounding up the number of inodes/group, * make sure to update the total inodes field in the info struct. */ info->inodes = inodes * block_groups; return inodes;} static uint32_t compute_journal_blocks(struct ext4_mkfs_info *info){ uint32_t journal_blocks = (uint32_t)EXT4_DIV_ROUND_UP(info->len, info->block_size) / 64; if (journal_blocks < 1024) journal_blocks = 1024; if (journal_blocks > 32768) journal_blocks = 32768; return journal_blocks;} static bool has_superblock(struct ext4_mkfs_info *info, uint32_t bgid){ if (!(info->feat_ro_compat & EXT4_FRO_COM_SPARSE_SUPER)) return true; return ext4_sb_sparse(bgid);} int create_fs_aux_info(struct fs_aux_info *aux_info, struct ext4_mkfs_info *info){ aux_info->first_data_block = (info->block_size > 1024) ? 0 : 1; aux_info->len_blocks = info->len / info->block_size; aux_info->inode_table_blocks = EXT4_DIV_ROUND_UP(info->inodes_per_group * info->inode_size, info->block_size); aux_info->groups = (uint32_t)EXT4_DIV_ROUND_UP(aux_info->len_blocks - aux_info->first_data_block, info->blocks_per_group); aux_info->blocks_per_ind = info->block_size / sizeof(uint32_t); aux_info->blocks_per_dind = aux_info->blocks_per_ind * aux_info->blocks_per_ind; aux_info->blocks_per_tind = aux_info->blocks_per_dind * aux_info->blocks_per_dind; aux_info->bg_desc_blocks = EXT4_DIV_ROUND_UP(aux_info->groups * info->dsc_size, info->block_size); aux_info->default_i_flags = EXT4_INODE_FLAG_NOATIME; uint32_t last_group_size = aux_info->len_blocks % info->blocks_per_group; uint32_t last_header_size = 2 + aux_info->inode_table_blocks; if (has_superblock(info, aux_info->groups - 1)) last_header_size += 1 + aux_info->bg_desc_blocks + info->bg_desc_reserve_blocks; if (last_group_size > 0 && last_group_size < last_header_size) { aux_info->groups--; aux_info->len_blocks -= last_group_size; } aux_info->sb = ext4_calloc(1, EXT4_SUPERBLOCK_SIZE); if (!aux_info->sb) return ENOMEM; aux_info->bg_desc_blk = ext4_calloc(1, info->block_size); if (!aux_info->bg_desc_blk) return ENOMEM; aux_info->xattrs = NULL; ext4_dbg(DEBUG_MKFS, DBG_INFO "create_fs_aux_info\n"); ext4_dbg(DEBUG_MKFS, DBG_NONE "first_data_block: %"PRIu32"\n", aux_info->first_data_block); ext4_dbg(DEBUG_MKFS, DBG_NONE "len_blocks: %"PRIu64"\n", aux_info->len_blocks); ext4_dbg(DEBUG_MKFS, DBG_NONE "inode_table_blocks: %"PRIu32"\n", aux_info->inode_table_blocks); ext4_dbg(DEBUG_MKFS, DBG_NONE "groups: %"PRIu32"\n", aux_info->groups); ext4_dbg(DEBUG_MKFS, DBG_NONE "bg_desc_blocks: %"PRIu32"\n", aux_info->bg_desc_blocks); ext4_dbg(DEBUG_MKFS, DBG_NONE "default_i_flags: %"PRIu32"\n", aux_info->default_i_flags); ext4_dbg(DEBUG_MKFS, DBG_NONE "blocks_per_ind: %"PRIu32"\n", aux_info->blocks_per_ind); ext4_dbg(DEBUG_MKFS, DBG_NONE "blocks_per_dind: %"PRIu32"\n", aux_info->blocks_per_dind); ext4_dbg(DEBUG_MKFS, DBG_NONE "blocks_per_tind: %"PRIu32"\n", aux_info->blocks_per_tind); return EOK;} void release_fs_aux_info(struct fs_aux_info *aux_info){ if (aux_info->sb) ext4_free(aux_info->sb); if (aux_info->bg_desc_blk) ext4_free(aux_info->bg_desc_blk);} /* Fill in the superblock memory buffer based on the filesystem parameters */static void fill_sb(struct fs_aux_info *aux_info, struct ext4_mkfs_info *info){ struct ext4_sblock *sb = aux_info->sb; sb->inodes_count = to_le32(info->inodes_per_group * aux_info->groups); ext4_sb_set_blocks_cnt(sb, aux_info->len_blocks); ext4_sb_set_free_blocks_cnt(sb, aux_info->len_blocks); sb->free_inodes_count = to_le32(info->inodes_per_group * aux_info->groups); sb->reserved_blocks_count_lo = to_le32(0); sb->first_data_block = to_le32(aux_info->first_data_block); sb->log_block_size = to_le32(log_2(info->block_size / 1024)); sb->log_cluster_size = to_le32(log_2(info->block_size / 1024)); sb->blocks_per_group = to_le32(info->blocks_per_group); sb->frags_per_group = to_le32(info->blocks_per_group); sb->inodes_per_group = to_le32(info->inodes_per_group); sb->mount_time = to_le32(0); sb->write_time = to_le32(0); sb->mount_count = to_le16(0); sb->max_mount_count = to_le16(0xFFFF); sb->magic = to_le16(EXT4_SUPERBLOCK_MAGIC); sb->state = to_le16(EXT4_SUPERBLOCK_STATE_VALID_FS); sb->errors = to_le16(EXT4_SUPERBLOCK_ERRORS_RO); sb->minor_rev_level = to_le16(0); sb->last_check_time = to_le32(0); sb->check_interval = to_le32(0); sb->creator_os = to_le32(EXT4_SUPERBLOCK_OS_LINUX); sb->rev_level = to_le32(1); sb->def_resuid = to_le16(0); sb->def_resgid = to_le16(0); sb->first_inode = to_le32(EXT4_GOOD_OLD_FIRST_INO); sb->inode_size = to_le16(info->inode_size); sb->block_group_index = to_le16(0); sb->features_compatible = to_le32(info->feat_compat); sb->features_incompatible = to_le32(info->feat_incompat); sb->features_read_only = to_le32(info->feat_ro_compat); memcpy(sb->uuid, info->uuid, UUID_SIZE); memset(sb->volume_name, 0, sizeof(sb->volume_name)); strncpy(sb->volume_name, info->label, sizeof(sb->volume_name)); memset(sb->last_mounted, 0, sizeof(sb->last_mounted)); sb->algorithm_usage_bitmap = to_le32(0); sb->s_prealloc_blocks = 0; sb->s_prealloc_dir_blocks = 0; sb->s_reserved_gdt_blocks = to_le16(info->bg_desc_reserve_blocks); if (info->feat_compat & EXT4_FCOM_HAS_JOURNAL) sb->journal_inode_number = to_le32(EXT4_JOURNAL_INO); sb->journal_backup_type = 1; sb->journal_dev = to_le32(0); sb->last_orphan = to_le32(0); sb->hash_seed[0] = to_le32(0x11111111); sb->hash_seed[1] = to_le32(0x22222222); sb->hash_seed[2] = to_le32(0x33333333); sb->hash_seed[3] = to_le32(0x44444444); sb->default_hash_version = EXT2_HTREE_HALF_MD4; sb->checksum_type = 1; sb->desc_size = to_le16(info->dsc_size); sb->default_mount_opts = to_le32(0); sb->first_meta_bg = to_le32(0); sb->mkfs_time = to_le32(0); sb->reserved_blocks_count_hi = to_le32(0); sb->min_extra_isize = to_le32(sizeof(struct ext4_inode) - EXT4_GOOD_OLD_INODE_SIZE); sb->want_extra_isize = to_le32(sizeof(struct ext4_inode) - EXT4_GOOD_OLD_INODE_SIZE); sb->flags = to_le32(EXT4_SUPERBLOCK_FLAGS_SIGNED_HASH);} static int write_bgroup_block(struct ext4_blockdev *bd, struct fs_aux_info *aux_info, struct ext4_mkfs_info *info, uint32_t blk){ int r = EOK; uint32_t j; struct ext4_block b; uint32_t block_size = ext4_sb_get_block_size(aux_info->sb); for (j = 0; j < aux_info->groups; j++) { uint64_t bg_start_block = aux_info->first_data_block + j * info->blocks_per_group; uint32_t blk_off = 0; blk_off += aux_info->bg_desc_blocks; if (has_superblock(info, j)) { bg_start_block++; blk_off += info->bg_desc_reserve_blocks; USED(blk_off); } uint64_t dsc_blk = bg_start_block + blk; r = ext4_block_get_noread(bd, &b, dsc_blk); if (r != EOK) return r; memcpy(b.data, aux_info->bg_desc_blk, block_size); ext4_bcache_set_dirty(b.buf); r = ext4_block_set(bd, &b); if (r != EOK) return r; } return r;} static int write_bgroups(struct ext4_blockdev *bd, struct fs_aux_info *aux_info, struct ext4_mkfs_info *info){ int r; struct ext4_block b; struct ext4_bgroup *bg_desc; uint32_t i; uint32_t bg_free_blk; uint64_t sb_free_blk = 0; uint32_t block_size = ext4_sb_get_block_size(aux_info->sb); uint32_t dsc_size = ext4_sb_get_desc_size(aux_info->sb); uint32_t dsc_per_block = block_size / dsc_size; uint32_t k = 0; for (i = 0; i < aux_info->groups; i++) { uint64_t bg_start_block = aux_info->first_data_block + aux_info->first_data_block + i * info->blocks_per_group; uint32_t blk_off = 0; bg_desc = (void *)(aux_info->bg_desc_blk + k * dsc_size); bg_free_blk = info->blocks_per_group - aux_info->inode_table_blocks; bg_free_blk -= 2; blk_off += aux_info->bg_desc_blocks; if (i == (aux_info->groups - 1)) bg_free_blk -= aux_info->first_data_block; if (has_superblock(info, i)) { bg_start_block++; blk_off += info->bg_desc_reserve_blocks; bg_free_blk -= info->bg_desc_reserve_blocks + 1; bg_free_blk -= aux_info->bg_desc_blocks; } ext4_bg_set_block_bitmap(bg_desc, aux_info->sb, bg_start_block + blk_off + 1); ext4_bg_set_inode_bitmap(bg_desc, aux_info->sb, bg_start_block + blk_off + 2); ext4_bg_set_inode_table_first_block(bg_desc, aux_info->sb, bg_start_block + blk_off + 3); ext4_bg_set_free_blocks_count(bg_desc, aux_info->sb, bg_free_blk); ext4_bg_set_free_inodes_count(bg_desc, aux_info->sb, to_le32(aux_info->sb->inodes_per_group)); ext4_bg_set_used_dirs_count(bg_desc, aux_info->sb, 0); ext4_bg_set_flag(bg_desc, EXT4_BLOCK_GROUP_BLOCK_UNINIT | EXT4_BLOCK_GROUP_INODE_UNINIT); sb_free_blk += bg_free_blk; r = ext4_block_get_noread(bd, &b, bg_start_block + blk_off + 1); if (r != EOK) return r; memset(b.data, 0, block_size); ext4_bcache_set_dirty(b.buf); r = ext4_block_set(bd, &b); if (r != EOK) return r; r = ext4_block_get_noread(bd, &b, bg_start_block + blk_off + 2); if (r != EOK) return r; memset(b.data, 0, block_size); ext4_bcache_set_dirty(b.buf); r = ext4_block_set(bd, &b); if (r != EOK) return r; if (++k != dsc_per_block) continue; k = 0; r = write_bgroup_block(bd, aux_info, info, i / dsc_per_block); if (r != EOK) return r; } r = write_bgroup_block(bd, aux_info, info, i / dsc_per_block); if (r != EOK) return r; ext4_sb_set_free_blocks_cnt(aux_info->sb, sb_free_blk); return r;} int write_sblocks(struct ext4_blockdev *bd, struct fs_aux_info *aux_info, struct ext4_mkfs_info *info){ uint64_t offset; uint32_t i; int r; /* write out the backup superblocks */ for (i = 1; i < aux_info->groups; i++) { if (has_superblock(info, i)) { offset = info->block_size * (aux_info->first_data_block + i * info->blocks_per_group); aux_info->sb->block_group_index = to_le16(i); r = ext4_block_writebytes(bd, offset, aux_info->sb, EXT4_SUPERBLOCK_SIZE); if (r != EOK) return r; } } /* write out the primary superblock */ aux_info->sb->block_group_index = to_le16(0); return ext4_block_writebytes(bd, EXT4_SUPERBLOCK_OFFSET, aux_info->sb, EXT4_SUPERBLOCK_SIZE);} int ext4_mkfs_read_info(struct ext4_blockdev *bd, struct ext4_mkfs_info *info){ int r; struct ext4_sblock *sb; r = ext4_block_init(bd); if (r != EOK) return r; sb = ext4_malloc(EXT4_SUPERBLOCK_SIZE); if (!sb) goto Finish; r = ext4_sb_read(bd, sb); if (r != EOK) goto Finish; r = sb2info(sb, info); Finish: if (sb) ext4_free(sb); ext4_block_fini(bd); return r;} static int mkfs_init(struct ext4_blockdev *bd, struct ext4_mkfs_info *info){ int r; struct fs_aux_info aux_info; memset(&aux_info, 0, sizeof(struct fs_aux_info)); r = create_fs_aux_info(&aux_info, info); if (r != EOK) goto Finish; fill_sb(&aux_info, info); r = write_bgroups(bd, &aux_info, info); if (r != EOK) goto Finish; r = write_sblocks(bd, &aux_info, info); if (r != EOK) goto Finish; Finish: release_fs_aux_info(&aux_info); return r;Lines 1–500 of 849. Load more
/* * Copyright (c) 2015 Grzegorz Kostka (kostka.grzegorz@gmail.com) * 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 lwext4 * @{ */ /** * @file ext4_mkfs.c * @brief */ #include <ext4_config.h> #include <ext4_types.h> #include <ext4_misc.h> #include <ext4_errno.h> #include <ext4_debug.h> #include <ext4_super.h> #include <ext4_block_group.h> #include <ext4_dir.h> #include <ext4_dir_idx.h> #include <ext4_fs.h> #include <ext4_inode.h> #include <ext4_ialloc.h> #include <ext4_mkfs.h> #include <inttypes.h> #include <string.h> #include <stdlib.h> static inline int log_2(int j) { int i; for (i = 0; j > 0; i++) j >>= 1; return i - 1; } static int sb2info(struct ext4_sblock *sb, struct ext4_mkfs_info *info) { if (to_le16(sb->magic) != EXT4_SUPERBLOCK_MAGIC) return EINVAL; info->block_size = 1024 << to_le32(sb->log_block_size); info->blocks_per_group = to_le32(sb->blocks_per_group); info->inodes_per_group = to_le32(sb->inodes_per_group); info->inode_size = to_le16(sb->inode_size); info->inodes = to_le32(sb->inodes_count); info->feat_ro_compat = to_le32(sb->features_read_only); info->feat_compat = to_le32(sb->features_compatible); info->feat_incompat = to_le32(sb->features_incompatible); info->bg_desc_reserve_blocks = to_le16(sb->s_reserved_gdt_blocks); strncpy(info->label,sb->volume_name,sizeof(info->label)); info->len = (uint64_t)info->block_size * ext4_sb_get_blocks_cnt(sb); info->dsc_size = to_le16(sb->desc_size); memcpy(info->uuid, sb->uuid, UUID_SIZE); return EOK; } static uint32_t compute_blocks_per_group(struct ext4_mkfs_info *info) { return info->block_size * 8; } static uint32_t compute_inodes(struct ext4_mkfs_info *info) { return (uint32_t)EXT4_DIV_ROUND_UP(info->len, info->block_size) / 4; } static uint32_t compute_inodes_per_group(struct ext4_mkfs_info *info) { uint32_t blocks = (uint32_t)EXT4_DIV_ROUND_UP(info->len, info->block_size); uint32_t block_groups = EXT4_DIV_ROUND_UP(blocks, info->blocks_per_group); uint32_t inodes = EXT4_DIV_ROUND_UP(info->inodes, block_groups); inodes = EXT4_ALIGN(inodes, (info->block_size / info->inode_size)); /* After properly rounding up the number of inodes/group, * make sure to update the total inodes field in the info struct. */ info->inodes = inodes * block_groups; return inodes; } static uint32_t compute_journal_blocks(struct ext4_mkfs_info *info) { uint32_t journal_blocks = (uint32_t)EXT4_DIV_ROUND_UP(info->len, info->block_size) / 64; if (journal_blocks < 1024) journal_blocks = 1024; if (journal_blocks > 32768) journal_blocks = 32768; return journal_blocks; } static bool has_superblock(struct ext4_mkfs_info *info, uint32_t bgid) { if (!(info->feat_ro_compat & EXT4_FRO_COM_SPARSE_SUPER)) return true; return ext4_sb_sparse(bgid); } int create_fs_aux_info(struct fs_aux_info *aux_info, struct ext4_mkfs_info *info) { aux_info->first_data_block = (info->block_size > 1024) ? 0 : 1; aux_info->len_blocks = info->len / info->block_size; aux_info->inode_table_blocks = EXT4_DIV_ROUND_UP(info->inodes_per_group * info->inode_size, info->block_size); aux_info->groups = (uint32_t)EXT4_DIV_ROUND_UP(aux_info->len_blocks - aux_info->first_data_block, info->blocks_per_group); aux_info->blocks_per_ind = info->block_size / sizeof(uint32_t); aux_info->blocks_per_dind = aux_info->blocks_per_ind * aux_info->blocks_per_ind; aux_info->blocks_per_tind = aux_info->blocks_per_dind * aux_info->blocks_per_dind; aux_info->bg_desc_blocks = EXT4_DIV_ROUND_UP(aux_info->groups * info->dsc_size, info->block_size); aux_info->default_i_flags = EXT4_INODE_FLAG_NOATIME; uint32_t last_group_size = aux_info->len_blocks % info->blocks_per_group; uint32_t last_header_size = 2 + aux_info->inode_table_blocks; if (has_superblock(info, aux_info->groups - 1)) last_header_size += 1 + aux_info->bg_desc_blocks + info->bg_desc_reserve_blocks; if (last_group_size > 0 && last_group_size < last_header_size) { aux_info->groups--; aux_info->len_blocks -= last_group_size; } aux_info->sb = ext4_calloc(1, EXT4_SUPERBLOCK_SIZE); if (!aux_info->sb) return ENOMEM; aux_info->bg_desc_blk = ext4_calloc(1, info->block_size); if (!aux_info->bg_desc_blk) return ENOMEM; aux_info->xattrs = NULL; ext4_dbg(DEBUG_MKFS, DBG_INFO "create_fs_aux_info\n"); ext4_dbg(DEBUG_MKFS, DBG_NONE "first_data_block: %"PRIu32"\n", aux_info->first_data_block); ext4_dbg(DEBUG_MKFS, DBG_NONE "len_blocks: %"PRIu64"\n", aux_info->len_blocks); ext4_dbg(DEBUG_MKFS, DBG_NONE "inode_table_blocks: %"PRIu32"\n", aux_info->inode_table_blocks); ext4_dbg(DEBUG_MKFS, DBG_NONE "groups: %"PRIu32"\n", aux_info->groups); ext4_dbg(DEBUG_MKFS, DBG_NONE "bg_desc_blocks: %"PRIu32"\n", aux_info->bg_desc_blocks); ext4_dbg(DEBUG_MKFS, DBG_NONE "default_i_flags: %"PRIu32"\n", aux_info->default_i_flags); ext4_dbg(DEBUG_MKFS, DBG_NONE "blocks_per_ind: %"PRIu32"\n", aux_info->blocks_per_ind); ext4_dbg(DEBUG_MKFS, DBG_NONE "blocks_per_dind: %"PRIu32"\n", aux_info->blocks_per_dind); ext4_dbg(DEBUG_MKFS, DBG_NONE "blocks_per_tind: %"PRIu32"\n", aux_info->blocks_per_tind); return EOK; } void release_fs_aux_info(struct fs_aux_info *aux_info) { if (aux_info->sb) ext4_free(aux_info->sb); if (aux_info->bg_desc_blk) ext4_free(aux_info->bg_desc_blk); } /* Fill in the superblock memory buffer based on the filesystem parameters */ static void fill_sb(struct fs_aux_info *aux_info, struct ext4_mkfs_info *info) { struct ext4_sblock *sb = aux_info->sb; sb->inodes_count = to_le32(info->inodes_per_group * aux_info->groups); ext4_sb_set_blocks_cnt(sb, aux_info->len_blocks); ext4_sb_set_free_blocks_cnt(sb, aux_info->len_blocks); sb->free_inodes_count = to_le32(info->inodes_per_group * aux_info->groups); sb->reserved_blocks_count_lo = to_le32(0); sb->first_data_block = to_le32(aux_info->first_data_block); sb->log_block_size = to_le32(log_2(info->block_size / 1024)); sb->log_cluster_size = to_le32(log_2(info->block_size / 1024)); sb->blocks_per_group = to_le32(info->blocks_per_group); sb->frags_per_group = to_le32(info->blocks_per_group); sb->inodes_per_group = to_le32(info->inodes_per_group); sb->mount_time = to_le32(0); sb->write_time = to_le32(0); sb->mount_count = to_le16(0); sb->max_mount_count = to_le16(0xFFFF); sb->magic = to_le16(EXT4_SUPERBLOCK_MAGIC); sb->state = to_le16(EXT4_SUPERBLOCK_STATE_VALID_FS); sb->errors = to_le16(EXT4_SUPERBLOCK_ERRORS_RO); sb->minor_rev_level = to_le16(0); sb->last_check_time = to_le32(0); sb->check_interval = to_le32(0); sb->creator_os = to_le32(EXT4_SUPERBLOCK_OS_LINUX); sb->rev_level = to_le32(1); sb->def_resuid = to_le16(0); sb->def_resgid = to_le16(0); sb->first_inode = to_le32(EXT4_GOOD_OLD_FIRST_INO); sb->inode_size = to_le16(info->inode_size); sb->block_group_index = to_le16(0); sb->features_compatible = to_le32(info->feat_compat); sb->features_incompatible = to_le32(info->feat_incompat); sb->features_read_only = to_le32(info->feat_ro_compat); memcpy(sb->uuid, info->uuid, UUID_SIZE); memset(sb->volume_name, 0, sizeof(sb->volume_name)); strncpy(sb->volume_name, info->label, sizeof(sb->volume_name)); memset(sb->last_mounted, 0, sizeof(sb->last_mounted)); sb->algorithm_usage_bitmap = to_le32(0); sb->s_prealloc_blocks = 0; sb->s_prealloc_dir_blocks = 0; sb->s_reserved_gdt_blocks = to_le16(info->bg_desc_reserve_blocks); if (info->feat_compat & EXT4_FCOM_HAS_JOURNAL) sb->journal_inode_number = to_le32(EXT4_JOURNAL_INO); sb->journal_backup_type = 1; sb->journal_dev = to_le32(0); sb->last_orphan = to_le32(0); sb->hash_seed[0] = to_le32(0x11111111); sb->hash_seed[1] = to_le32(0x22222222); sb->hash_seed[2] = to_le32(0x33333333); sb->hash_seed[3] = to_le32(0x44444444); sb->default_hash_version = EXT2_HTREE_HALF_MD4; sb->checksum_type = 1; sb->desc_size = to_le16(info->dsc_size); sb->default_mount_opts = to_le32(0); sb->first_meta_bg = to_le32(0); sb->mkfs_time = to_le32(0); sb->reserved_blocks_count_hi = to_le32(0); sb->min_extra_isize = to_le32(sizeof(struct ext4_inode) - EXT4_GOOD_OLD_INODE_SIZE); sb->want_extra_isize = to_le32(sizeof(struct ext4_inode) - EXT4_GOOD_OLD_INODE_SIZE); sb->flags = to_le32(EXT4_SUPERBLOCK_FLAGS_SIGNED_HASH); } static int write_bgroup_block(struct ext4_blockdev *bd, struct fs_aux_info *aux_info, struct ext4_mkfs_info *info, uint32_t blk) { int r = EOK; uint32_t j; struct ext4_block b; uint32_t block_size = ext4_sb_get_block_size(aux_info->sb); for (j = 0; j < aux_info->groups; j++) { uint64_t bg_start_block = aux_info->first_data_block + j * info->blocks_per_group; uint32_t blk_off = 0; blk_off += aux_info->bg_desc_blocks; if (has_superblock(info, j)) { bg_start_block++; blk_off += info->bg_desc_reserve_blocks; USED(blk_off); } uint64_t dsc_blk = bg_start_block + blk; r = ext4_block_get_noread(bd, &b, dsc_blk); if (r != EOK) return r; memcpy(b.data, aux_info->bg_desc_blk, block_size); ext4_bcache_set_dirty(b.buf); r = ext4_block_set(bd, &b); if (r != EOK) return r; } return r; } static int write_bgroups(struct ext4_blockdev *bd, struct fs_aux_info *aux_info, struct ext4_mkfs_info *info) { int r; struct ext4_block b; struct ext4_bgroup *bg_desc; uint32_t i; uint32_t bg_free_blk; uint64_t sb_free_blk = 0; uint32_t block_size = ext4_sb_get_block_size(aux_info->sb); uint32_t dsc_size = ext4_sb_get_desc_size(aux_info->sb); uint32_t dsc_per_block = block_size / dsc_size; uint32_t k = 0; for (i = 0; i < aux_info->groups; i++) { uint64_t bg_start_block = aux_info->first_data_block + aux_info->first_data_block + i * info->blocks_per_group; uint32_t blk_off = 0; bg_desc = (void *)(aux_info->bg_desc_blk + k * dsc_size); bg_free_blk = info->blocks_per_group - aux_info->inode_table_blocks; bg_free_blk -= 2; blk_off += aux_info->bg_desc_blocks; if (i == (aux_info->groups - 1)) bg_free_blk -= aux_info->first_data_block; if (has_superblock(info, i)) { bg_start_block++; blk_off += info->bg_desc_reserve_blocks; bg_free_blk -= info->bg_desc_reserve_blocks + 1; bg_free_blk -= aux_info->bg_desc_blocks; } ext4_bg_set_block_bitmap(bg_desc, aux_info->sb, bg_start_block + blk_off + 1); ext4_bg_set_inode_bitmap(bg_desc, aux_info->sb, bg_start_block + blk_off + 2); ext4_bg_set_inode_table_first_block(bg_desc, aux_info->sb, bg_start_block + blk_off + 3); ext4_bg_set_free_blocks_count(bg_desc, aux_info->sb, bg_free_blk); ext4_bg_set_free_inodes_count(bg_desc, aux_info->sb, to_le32(aux_info->sb->inodes_per_group)); ext4_bg_set_used_dirs_count(bg_desc, aux_info->sb, 0); ext4_bg_set_flag(bg_desc, EXT4_BLOCK_GROUP_BLOCK_UNINIT | EXT4_BLOCK_GROUP_INODE_UNINIT); sb_free_blk += bg_free_blk; r = ext4_block_get_noread(bd, &b, bg_start_block + blk_off + 1); if (r != EOK) return r; memset(b.data, 0, block_size); ext4_bcache_set_dirty(b.buf); r = ext4_block_set(bd, &b); if (r != EOK) return r; r = ext4_block_get_noread(bd, &b, bg_start_block + blk_off + 2); if (r != EOK) return r; memset(b.data, 0, block_size); ext4_bcache_set_dirty(b.buf); r = ext4_block_set(bd, &b); if (r != EOK) return r; if (++k != dsc_per_block) continue; k = 0; r = write_bgroup_block(bd, aux_info, info, i / dsc_per_block); if (r != EOK) return r; } r = write_bgroup_block(bd, aux_info, info, i / dsc_per_block); if (r != EOK) return r; ext4_sb_set_free_blocks_cnt(aux_info->sb, sb_free_blk); return r; } int write_sblocks(struct ext4_blockdev *bd, struct fs_aux_info *aux_info, struct ext4_mkfs_info *info) { uint64_t offset; uint32_t i; int r; /* write out the backup superblocks */ for (i = 1; i < aux_info->groups; i++) { if (has_superblock(info, i)) { offset = info->block_size * (aux_info->first_data_block + i * info->blocks_per_group); aux_info->sb->block_group_index = to_le16(i); r = ext4_block_writebytes(bd, offset, aux_info->sb, EXT4_SUPERBLOCK_SIZE); if (r != EOK) return r; } } /* write out the primary superblock */ aux_info->sb->block_group_index = to_le16(0); return ext4_block_writebytes(bd, EXT4_SUPERBLOCK_OFFSET, aux_info->sb, EXT4_SUPERBLOCK_SIZE); } int ext4_mkfs_read_info(struct ext4_blockdev *bd, struct ext4_mkfs_info *info) { int r; struct ext4_sblock *sb; r = ext4_block_init(bd); if (r != EOK) return r; sb = ext4_malloc(EXT4_SUPERBLOCK_SIZE); if (!sb) goto Finish; r = ext4_sb_read(bd, sb); if (r != EOK) goto Finish; r = sb2info(sb, info); Finish: if (sb) ext4_free(sb); ext4_block_fini(bd); return r; } static int mkfs_init(struct ext4_blockdev *bd, struct ext4_mkfs_info *info) { int r; struct fs_aux_info aux_info; memset(&aux_info, 0, sizeof(struct fs_aux_info)); r = create_fs_aux_info(&aux_info, info); if (r != EOK) goto Finish; fill_sb(&aux_info, info); r = write_bgroups(bd, &aux_info, info); if (r != EOK) goto Finish; r = write_sblocks(bd, &aux_info, info); if (r != EOK) goto Finish; Finish: release_fs_aux_info(&aux_info); return r;