void inode_attach_resize(struct ext4_inode *inode,
struct block_allocation *alloc)
{
u32 block_len = block_allocation_len(alloc);
u32 superblocks = block_len / info.bg_desc_reserve_blocks;
u32 i, j;
u64 blocks;
u64 size;
if (block_len % info.bg_desc_reserve_blocks)
critical_error("reserved blocks not a multiple of %d",
info.bg_desc_reserve_blocks);
append_oob_allocation(alloc, 1);
u32 dind_block = get_oob_block(alloc, 0);
u32 *dind_block_data = calloc(info.block_size, 1);
if (!dind_block_data)
critical_error_errno("calloc");
queue_data_block((u8 *)dind_block_data, info.block_size, dind_block);
u32 *ind_block_data = calloc(info.block_size, info.bg_desc_reserve_blocks);
if (!ind_block_data)
critical_error_errno("calloc");
queue_data_block((u8 *)ind_block_data,
info.block_size * info.bg_desc_reserve_blocks,
get_block(alloc, 0));
for (i = 0; i < info.bg_desc_reserve_blocks; i++) {
int r = (i - aux_info.bg_desc_blocks) % info.bg_desc_reserve_blocks;
if (r < 0)
r += info.bg_desc_reserve_blocks;
dind_block_data[i] = get_block(alloc, r);
for (j = 1; j < superblocks; j++) {
u32 b = j * info.bg_desc_reserve_blocks + r;
ind_block_data[r * aux_info.blocks_per_ind + j - 1] = get_block(alloc, b);
}
}
u32 last_block = EXT4_NDIR_BLOCKS + aux_info.blocks_per_ind +
aux_info.blocks_per_ind * (info.bg_desc_reserve_blocks - 1) +
superblocks - 2;
blocks = ((u64)block_len + 1) * info.block_size / 512;
size = (u64)last_block * info.block_size;
inode->i_block[EXT4_DIND_BLOCK] = dind_block;
inode->i_flags = 0;
inode->i_blocks_lo = blocks;
inode->osd2.linux2.l_i_blocks_high = blocks >> 32;
inode->i_size_lo = size;
inode->i_size_high = size >> 32;
}
void ext4_queue_sb(void)
{
/* The write_data* functions expect only block aligned calls.
* This is not an issue, except when we write out the super
* block on a system with a block size > 1K. So, we need to
* deal with that here.
*/
if (info.block_size > 1024) {
u8 *buf = calloc(info.block_size, 1);
memcpy(buf + 1024, (u8*)aux_info.sb, 1024);
queue_data_block(buf, info.block_size, 0);
} else {
queue_data_block((u8*)aux_info.sb, 1024, 1);
}
}
/* Creates data buffers for the first backing_len bytes of a block allocation
and queues them to be written */
static u8 *create_backing(struct block_allocation *alloc,
unsigned long backing_len)
{
if (DIV_ROUND_UP(backing_len, info.block_size) > EXT4_NDIR_BLOCKS)
critical_error("indirect backing larger than %d blocks", EXT4_NDIR_BLOCKS);
u8 *data = calloc(backing_len, 1);
if (!data)
critical_error_errno("calloc");
u8 *ptr = data;
for (; alloc != NULL && backing_len > 0; get_next_region(alloc)) {
u32 region_block;
u32 region_len;
u32 len;
get_region(alloc, ®ion_block, ®ion_len);
len = min(region_len * info.block_size, backing_len);
queue_data_block(ptr, len, region_block);
ptr += len;
backing_len -= len;
}
return data;
}
/* Given an allocation, attach as many blocks as possible to triply indirect
blocks, and return the rest.
Assumes that the blocks necessary to hold the indirect, doubly indirect and
triply indirect blocks were included as part of the allocation */
static int inode_attach_tindirect_blocks(struct ext4_inode *inode,
struct block_allocation *alloc, u32 *block_len)
{
int len = min(*block_len, aux_info.blocks_per_tind);
int tind_block = get_oob_block(alloc, 0);
inode->i_block[EXT4_TIND_BLOCK] = tind_block;
if (advance_oob_blocks(alloc, 1)) {
error("failed to advance oob block");
return -1;
}
u32 *tind_block_data = calloc(info.block_size, 1);
queue_data_block((u8*)tind_block_data, info.block_size, tind_block);
fill_tindirect_block(tind_block_data, len, alloc);
if (advance_blocks(alloc, len)) {
error("failed to advance %d blocks", len);
return -1;
}
*block_len -= len;
return 0;
}
static void fill_dindirect_block(u32 *dind_block, int len, struct block_allocation *alloc)
{
int i;
u32 ind_block;
for (i = 0; len > 0; i++) {
ind_block = get_oob_block(alloc, 0);
if (advance_oob_blocks(alloc, 1)) {
error("failed to reserve oob block");
return;
}
dind_block[i] = ind_block;
u32 *ind_block_data = calloc(info.block_size, 1);
queue_data_block((u8*)ind_block_data, info.block_size, ind_block);
int ind_block_len = min((int)aux_info.blocks_per_ind, len);
fill_indirect_block(ind_block_data, ind_block_len, alloc);
if (advance_blocks(alloc, ind_block_len)) {
error("failed to advance %d blocks", ind_block_len);
return;
}
len -= ind_block_len;
}
}
/* Creates data buffers for the first backing_len bytes of a block allocation
and queues them to be written */
static u8 *extent_create_backing(struct block_allocation *alloc,
u64 backing_len)
{
u8 *data = calloc(backing_len, 1);
if (!data)
critical_error_errno("calloc");
u8 *ptr = data;
for (; alloc != NULL && backing_len > 0; get_next_region(alloc)) {
u32 region_block;
u32 region_len;
u32 len;
get_region(alloc, ®ion_block, ®ion_len);
len = min(region_len * info.block_size, backing_len);
queue_data_block(ptr, len, region_block);
ptr += len;
backing_len -= len;
}
return data;
}
/* Fill in the superblock memory buffer based on the filesystem parameters */
void ext4_fill_in_sb()
{
unsigned int i;
struct ext4_super_block *sb = aux_info.sb;
sb->s_inodes_count = info.inodes_per_group * aux_info.groups;
sb->s_blocks_count_lo = aux_info.len_blocks;
sb->s_r_blocks_count_lo = 0;
sb->s_free_blocks_count_lo = 0;
sb->s_free_inodes_count = 0;
sb->s_first_data_block = aux_info.first_data_block;
sb->s_log_block_size = log_2(info.block_size / 1024);
sb->s_obso_log_frag_size = log_2(info.block_size / 1024);
sb->s_blocks_per_group = info.blocks_per_group;
sb->s_obso_frags_per_group = info.blocks_per_group;
sb->s_inodes_per_group = info.inodes_per_group;
sb->s_mtime = 0;
sb->s_wtime = 0;
sb->s_mnt_count = 0;
sb->s_max_mnt_count = 0xFFFF;
sb->s_magic = EXT4_SUPER_MAGIC;
sb->s_state = EXT4_VALID_FS;
sb->s_errors = EXT4_ERRORS_RO;
sb->s_minor_rev_level = 0;
sb->s_lastcheck = 0;
sb->s_checkinterval = 0;
sb->s_creator_os = EXT4_OS_LINUX;
sb->s_rev_level = EXT4_DYNAMIC_REV;
sb->s_def_resuid = EXT4_DEF_RESUID;
sb->s_def_resgid = EXT4_DEF_RESGID;
sb->s_first_ino = EXT4_GOOD_OLD_FIRST_INO;
sb->s_inode_size = info.inode_size;
sb->s_block_group_nr = 0;
sb->s_feature_compat = info.feat_compat;
sb->s_feature_incompat = info.feat_incompat;
sb->s_feature_ro_compat = info.feat_ro_compat;
generate_uuid("extandroid/make_ext4fs", info.label, sb->s_uuid);
memset(sb->s_volume_name, 0, sizeof(sb->s_volume_name));
strncpy(sb->s_volume_name, info.label, sizeof(sb->s_volume_name));
memset(sb->s_last_mounted, 0, sizeof(sb->s_last_mounted));
sb->s_algorithm_usage_bitmap = 0;
sb->s_reserved_gdt_blocks = info.bg_desc_reserve_blocks;
sb->s_prealloc_blocks = 0;
sb->s_prealloc_dir_blocks = 0;
//memcpy(sb->s_journal_uuid, sb->s_uuid, sizeof(sb->s_journal_uuid));
if (info.feat_compat & EXT4_FEATURE_COMPAT_HAS_JOURNAL)
sb->s_journal_inum = EXT4_JOURNAL_INO;
sb->s_journal_dev = 0;
sb->s_last_orphan = 0;
sb->s_hash_seed[0] = 0; /* FIXME */
sb->s_def_hash_version = DX_HASH_TEA;
sb->s_reserved_char_pad = EXT4_JNL_BACKUP_BLOCKS;
sb->s_desc_size = sizeof(struct ext2_group_desc);
sb->s_default_mount_opts = 0; /* FIXME */
sb->s_first_meta_bg = 0;
sb->s_mkfs_time = 0;
//sb->s_jnl_blocks[17]; /* FIXME */
sb->s_blocks_count_hi = aux_info.len_blocks >> 32;
sb->s_r_blocks_count_hi = 0;
sb->s_free_blocks_count_hi = 0;
sb->s_min_extra_isize = sizeof(struct ext4_inode) -
EXT4_GOOD_OLD_INODE_SIZE;
sb->s_want_extra_isize = sizeof(struct ext4_inode) -
EXT4_GOOD_OLD_INODE_SIZE;
sb->s_flags = 0;
sb->s_raid_stride = 0;
sb->s_mmp_interval = 0;
sb->s_mmp_block = 0;
sb->s_raid_stripe_width = 0;
sb->s_log_groups_per_flex = 0;
sb->s_kbytes_written = 0;
for (i = 0; i < aux_info.groups; i++) {
u64 group_start_block = aux_info.first_data_block + i *
info.blocks_per_group;
u32 header_size = 0;
if (ext4_bg_has_super_block(i)) {
if (i != 0) {
aux_info.backup_sb[i] = calloc(info.block_size, 1);
memcpy(aux_info.backup_sb[i], sb, info.block_size);
/* Update the block group nr of this backup superblock */
aux_info.backup_sb[i]->s_block_group_nr = i;
queue_data_block((u8 *)aux_info.backup_sb[i],
info.block_size, group_start_block);
}
queue_data_block((u8 *)aux_info.bg_desc,
aux_info.bg_desc_blocks * info.block_size,
group_start_block + 1);
header_size = 1 + aux_info.bg_desc_blocks + info.bg_desc_reserve_blocks;
}
aux_info.bg_desc[i].bg_block_bitmap = group_start_block + header_size;
aux_info.bg_desc[i].bg_inode_bitmap = group_start_block + header_size + 1;
aux_info.bg_desc[i].bg_inode_table = group_start_block + header_size + 2;
aux_info.bg_desc[i].bg_free_blocks_count = sb->s_blocks_per_group;
aux_info.bg_desc[i].bg_free_inodes_count = sb->s_inodes_per_group;
aux_info.bg_desc[i].bg_used_dirs_count = 0;
}
}
static struct block_allocation *do_inode_allocate_extents(
struct ext4_inode *inode, u64 len)
{
u32 block_len = DIV_ROUND_UP(len, info.block_size);
struct block_allocation *alloc = allocate_blocks(block_len + 1);
u32 extent_block = 0;
u32 file_block = 0;
struct ext4_extent *extent;
u64 blocks;
if (alloc == NULL) {
error("Failed to allocate %d blocks\n", block_len + 1);
return NULL;
}
int allocation_len = block_allocation_num_regions(alloc);
if (allocation_len <= 3) {
reduce_allocation(alloc, 1);
} else {
reserve_oob_blocks(alloc, 1);
extent_block = get_oob_block(alloc, 0);
}
if (!extent_block) {
struct ext4_extent_header *hdr =
(struct ext4_extent_header *)&inode->i_block[0];
hdr->eh_magic = EXT4_EXT_MAGIC;
hdr->eh_entries = allocation_len;
hdr->eh_max = 3;
hdr->eh_generation = 0;
hdr->eh_depth = 0;
extent = (struct ext4_extent *)&inode->i_block[3];
} else {
struct ext4_extent_header *hdr =
(struct ext4_extent_header *)&inode->i_block[0];
hdr->eh_magic = EXT4_EXT_MAGIC;
hdr->eh_entries = 1;
hdr->eh_max = 3;
hdr->eh_generation = 0;
hdr->eh_depth = 1;
struct ext4_extent_idx *idx =
(struct ext4_extent_idx *)&inode->i_block[3];
idx->ei_block = 0;
idx->ei_leaf_lo = extent_block;
idx->ei_leaf_hi = 0;
idx->ei_unused = 0;
u8 *data = calloc(info.block_size, 1);
if (!data)
critical_error_errno("calloc");
queue_data_block(data, info.block_size, extent_block);
if (((int)(info.block_size - sizeof(struct ext4_extent_header) /
sizeof(struct ext4_extent))) < allocation_len) {
error("File size %llu is too big to fit in a single extent block\n",
len);
return NULL;
}
hdr = (struct ext4_extent_header *)data;
hdr->eh_magic = EXT4_EXT_MAGIC;
hdr->eh_entries = allocation_len;
hdr->eh_max = (info.block_size - sizeof(struct ext4_extent_header)) /
sizeof(struct ext4_extent);
hdr->eh_generation = 0;
hdr->eh_depth = 0;
extent = (struct ext4_extent *)(data +
sizeof(struct ext4_extent_header));
}
for (; !last_region(alloc); extent++, get_next_region(alloc)) {
u32 region_block;
u32 region_len;
get_region(alloc, ®ion_block, ®ion_len);
extent->ee_block = file_block;
extent->ee_len = region_len;
extent->ee_start_hi = 0;
extent->ee_start_lo = region_block;
file_block += region_len;
}
if (extent_block)
block_len += 1;
blocks = (u64)block_len * info.block_size / 512;
inode->i_flags |= EXT4_EXTENTS_FL;
inode->i_size_lo = len;
inode->i_size_high = len >> 32;
inode->i_blocks_lo = blocks;
inode->osd2.linux2.l_i_blocks_high = blocks >> 32;
rewind_alloc(alloc);
return alloc;
}
