int ddfs_hash_write(ext2_filsys fs, __u32 blk_no, __u8 hash[DDFS_HASH_LEN]) { blk_t phy_blk_no =0; unsigned inBlockIndex; //struct buffer_head * bh; unsigned long group; group = ext2fs_group_of_blk(fs,blk_no) & (~0x3); blk_t first_block = ext2fs_group_first_block(fs, group); unsigned offset; struct ext2_group_desc * desc = &fs->group_desc[group]; phy_blk_no = (blk_no - ext2fs_group_first_block(fs,group)) / 128 + desc->bg_block_store; inBlockIndex = (blk_no - ext2fs_group_first_block(fs,group)) % 128; io_channel_read_blk(fs->io,phy_blk_no,1,blk_buf); //bh = sb_bread(sb, phy_blk_no); //TODO: Error check memcpy( blk_buf + 32 * inBlockIndex + 8,hash, 24); memcpy(blk_buf + DDFS_HASH_LEN * inBlockIndex, hash, DDFS_HASH_LEN); io_channel_write_blk(fs->io,phy_blk_no,1,blk_buf); return 0; }
void ext2fs_block_alloc_stats(ext2_filsys fs, blk_t blk, int inuse) { int group = ext2fs_group_of_blk(fs, blk); #ifndef OMIT_COM_ERR if (blk >= fs->super->s_blocks_count) { com_err("ext2fs_block_alloc_stats", 0, "Illegal block number: %lu", (unsigned long) blk); return; } #endif if (inuse > 0) ext2fs_mark_block_bitmap(fs->block_map, blk); else ext2fs_unmark_block_bitmap(fs->block_map, blk); fs->group_desc[group].bg_free_blocks_count -= inuse; fs->group_desc[group].bg_flags &= ~EXT2_BG_BLOCK_UNINIT; ext2fs_group_desc_csum_set(fs, group); fs->super->s_free_blocks_count -= inuse; ext2fs_mark_super_dirty(fs); ext2fs_mark_bb_dirty(fs); if (fs->block_alloc_stats) (fs->block_alloc_stats)(fs, (blk64_t) blk, inuse); }
void ext2fs_block_alloc_stats(ext2_filsys fs, blk_t blk, int inuse) { int group = ext2fs_group_of_blk(fs, blk); if (inuse > 0) ext2fs_mark_block_bitmap(fs->block_map, blk); else ext2fs_unmark_block_bitmap(fs->block_map, blk); fs->group_desc[group].bg_free_blocks_count -= inuse; fs->super->s_free_blocks_count -= inuse; ext2fs_mark_super_dirty(fs); ext2fs_mark_bb_dirty(fs); }
static void print_bg_rel_offset(ext2_filsys fs, blk64_t block, int itable, blk64_t first_block, blk64_t last_block) { if ((block >= first_block) && (block <= last_block)) { if (itable && block == first_block) return; printf(" (+%u)", (unsigned)(block - first_block)); } else if (fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_FLEX_BG) { dgrp_t flex_grp = ext2fs_group_of_blk(fs, block); printf(" (bg #%u + %u)", flex_grp, (unsigned)(block-ext2fs_group_first_block(fs,flex_grp))); } }
static int ddfs_get_range(ext2_filsys fs,blk_t blk_no,blk_t *start,blk_t * end){ unsigned entry_per_block = 128; unsigned long group; struct ext2_group_desc * desc; blk_t first_block; group = ext2fs_group_of_blk(fs,blk_no); first_block = ext2fs_group_first_block(fs, group); desc = &fs->group_desc[group]; unsigned pos = blk_no - desc->bg_block_store; *start = pos * entry_per_block + first_block; *end = *start + entry_per_block; return 0; }
int ddfs_count_read(ext2_filsys fs, __u32 blk_no, __u32 * count) { blk_t phy_blk_no =0; unsigned inBlockIndex; //struct buffer_head * bh; unsigned long group; group = ext2fs_group_of_blk(fs,blk_no) & (~0x3); blk_t first_block = ext2fs_group_first_block(fs, group); unsigned offset; struct ext2_group_desc * desc = &fs->group_desc[group]; phy_blk_no = (blk_no - ext2fs_group_first_block(fs,group)) / 128 + desc->bg_block_store; inBlockIndex = (blk_no - ext2fs_group_first_block(fs,group)) % 128; io_channel_read_blk(fs->io,phy_blk_no,1,blk_buf); //bh = sb_bread(sb, phy_blk_no); //TODO: Error check memcpy(count, blk_buf + 32 * inBlockIndex , 4); return 0; }
int ddfs_is_hash_block(ext2_filsys fs,blk_t blk_no){ unsigned long group; struct ext2_group_desc * desc; blk_t first_block; group = ext2fs_group_of_blk(fs,blk_no); first_block = ext2fs_group_first_block(fs, group); desc = &fs->group_desc[group]; if(group % 4 == 0 && blk_no >= desc->bg_block_store && blk_no <= desc->bg_block_store + fs->super->s_blocks_per_group * 4 / 128){ printf("YES!\n"); return 1; } #ifdef DDFS_STORE_DEBUG printf("blk_no = %u,first_block = %u," "desc->bg_block_store = %u\n", blk_no,first_block, desc->bg_block_store ); #endif return 0; }
sizeof(fs->super->s_journal_uuid)); ext2fs_mark_super_dirty(fs); printf(_("Journal removed\n")); free(journal_path); } /* Helper function for remove_journal_inode */ static int release_blocks_proc(ext2_filsys fs, blk_t *blocknr, int blockcnt, void *private) { blk_t block; int group; block = *blocknr; ext2fs_unmark_block_bitmap(fs->block_map,block); group = ext2fs_group_of_blk(fs, block); fs->group_desc[group].bg_free_blocks_count++; fs->super->s_free_blocks_count++; return 0; } /* * Remove the journal inode from the filesystem */ static void remove_journal_inode(ext2_filsys fs) { struct ext2_inode inode; errcode_t retval; ino_t ino = fs->super->s_journal_inum; retval = ext2fs_read_inode(fs, ino, &inode);
static void handle_bad_blocks(ext2_filsys fs, badblocks_list bb_list) { dgrp_t i; blk_t j; unsigned must_be_good; blk_t blk; badblocks_iterate bb_iter; errcode_t retval; blk_t group_block; int group; int group_bad; if (!bb_list) return; /* * The primary superblock and group descriptors *must* be * good; if not, abort. */ must_be_good = fs->super->s_first_data_block + 1 + fs->desc_blocks; for (i = fs->super->s_first_data_block; i <= must_be_good; i++) { if (ext2fs_badblocks_list_test(bb_list, i)) { fprintf(stderr, _("Block %d in primary " "superblock/group descriptor area bad.\n"), i); fprintf(stderr, _("Blocks %u through %d must be good " "in order to build a filesystem.\n"), fs->super->s_first_data_block, must_be_good); fputs(_("Aborting....\n"), stderr); exit(1); } } /* * See if any of the bad blocks are showing up in the backup * superblocks and/or group descriptors. If so, issue a * warning and adjust the block counts appropriately. */ group_block = fs->super->s_first_data_block + fs->super->s_blocks_per_group; for (i = 1; i < fs->group_desc_count; i++) { group_bad = 0; for (j=0; j < fs->desc_blocks+1; j++) { if (ext2fs_badblocks_list_test(bb_list, group_block + j)) { if (!group_bad) fprintf(stderr, _("Warning: the backup superblock/group descriptors at block %u contain\n" " bad blocks.\n\n"), group_block); group_bad++; group = ext2fs_group_of_blk(fs, group_block+j); fs->group_desc[group].bg_free_blocks_count++; fs->super->s_free_blocks_count++; } } group_block += fs->super->s_blocks_per_group; } /* * Mark all the bad blocks as used... */ retval = ext2fs_badblocks_list_iterate_begin(bb_list, &bb_iter); if (retval) { com_err("ext2fs_badblocks_list_iterate_begin", retval, _("while marking bad blocks as used")); exit(1); } while (ext2fs_badblocks_list_iterate(bb_iter, &blk)) ext2fs_mark_block_bitmap(fs->block_map, blk); ext2fs_badblocks_list_iterate_end(bb_iter); }
/* * This function creates a journal using direct I/O routines. */ static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino, blk_t size, int flags) { char *buf; dgrp_t group, start, end, i, log_flex; errcode_t retval; struct ext2_inode inode; struct mkjournal_struct es; if ((retval = ext2fs_create_journal_superblock(fs, size, flags, &buf))) return retval; if ((retval = ext2fs_read_bitmaps(fs))) return retval; if ((retval = ext2fs_read_inode(fs, journal_ino, &inode))) return retval; if (inode.i_blocks > 0) return EEXIST; es.num_blocks = size; es.newblocks = 0; es.buf = buf; es.err = 0; es.zero_count = 0; if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) { inode.i_flags |= EXT4_EXTENTS_FL; if ((retval = ext2fs_write_inode(fs, journal_ino, &inode))) return retval; } /* * Set the initial goal block to be roughly at the middle of * the filesystem. Pick a group that has the largest number * of free blocks. */ group = ext2fs_group_of_blk(fs, (fs->super->s_blocks_count - fs->super->s_first_data_block) / 2); log_flex = 1 << fs->super->s_log_groups_per_flex; if (fs->super->s_log_groups_per_flex && (group > log_flex)) { group = group & ~(log_flex - 1); while ((group < fs->group_desc_count) && fs->group_desc[group].bg_free_blocks_count == 0) group++; if (group == fs->group_desc_count) group = 0; start = group; } else start = (group > 0) ? group-1 : group; end = ((group+1) < fs->group_desc_count) ? group+1 : group; group = start; for (i=start+1; i <= end; i++) if (fs->group_desc[i].bg_free_blocks_count > fs->group_desc[group].bg_free_blocks_count) group = i; es.goal = (fs->super->s_blocks_per_group * group) + fs->super->s_first_data_block; retval = ext2fs_block_iterate2(fs, journal_ino, BLOCK_FLAG_APPEND, 0, mkjournal_proc, &es); if (es.err) { retval = es.err; goto errout; } if (es.zero_count) { retval = ext2fs_zero_blocks(fs, es.blk_to_zero, es.zero_count, 0, 0); if (retval) goto errout; } if ((retval = ext2fs_read_inode(fs, journal_ino, &inode))) goto errout; inode.i_size += fs->blocksize * size; ext2fs_iblk_add_blocks(fs, &inode, es.newblocks); inode.i_mtime = inode.i_ctime = fs->now ? fs->now : time(0); inode.i_links_count = 1; inode.i_mode = LINUX_S_IFREG | 0600; if ((retval = ext2fs_write_new_inode(fs, journal_ino, &inode))) goto errout; retval = 0; memcpy(fs->super->s_jnl_blocks, inode.i_block, EXT2_N_BLOCKS*4); fs->super->s_jnl_blocks[16] = inode.i_size; fs->super->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS; ext2fs_mark_super_dirty(fs); errout: ext2fs_free_mem(&buf); return retval; }
errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group, ext2fs_block_bitmap bmap) { errcode_t retval; blk_t group_blk, start_blk, last_blk, new_blk, blk; dgrp_t last_grp = 0; int j, rem_grps = 0, flexbg_size = 0; group_blk = ext2fs_group_first_block(fs, group); last_blk = ext2fs_group_last_block(fs, group); if (!bmap) bmap = fs->block_map; if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT4_FEATURE_INCOMPAT_FLEX_BG) && fs->super->s_log_groups_per_flex) { flexbg_size = 1 << fs->super->s_log_groups_per_flex; last_grp = group | (flexbg_size - 1); rem_grps = last_grp - group; if (last_grp > fs->group_desc_count) last_grp = fs->group_desc_count; } /* * Allocate the block and inode bitmaps, if necessary */ if (fs->stride) { retval = ext2fs_get_free_blocks(fs, group_blk, last_blk, 1, bmap, &start_blk); if (retval) return retval; start_blk += fs->inode_blocks_per_group; start_blk += ((fs->stride * group) % (last_blk - start_blk + 1)); if (start_blk >= last_blk) start_blk = group_blk; } else start_blk = group_blk; if (flexbg_size) { blk64_t prev_block = 0; if (group && fs->group_desc[group-1].bg_block_bitmap) prev_block = fs->group_desc[group-1].bg_block_bitmap; start_blk = flexbg_offset(fs, group, prev_block, bmap, 0, rem_grps, 1); last_blk = ext2fs_group_last_block(fs, last_grp); } if (!fs->group_desc[group].bg_block_bitmap) { retval = ext2fs_get_free_blocks(fs, start_blk, last_blk, 1, bmap, &new_blk); if (retval == EXT2_ET_BLOCK_ALLOC_FAIL) retval = ext2fs_get_free_blocks(fs, group_blk, last_blk, 1, bmap, &new_blk); if (retval) return retval; ext2fs_mark_block_bitmap2(bmap, new_blk); fs->group_desc[group].bg_block_bitmap = new_blk; if (flexbg_size) { dgrp_t gr = ext2fs_group_of_blk(fs, new_blk); fs->group_desc[gr].bg_free_blocks_count--; fs->super->s_free_blocks_count--; fs->group_desc[gr].bg_flags &= ~EXT2_BG_BLOCK_UNINIT; ext2fs_group_desc_csum_set(fs, gr); } } if (flexbg_size) { blk_t prev_block = 0; if (group && fs->group_desc[group-1].bg_inode_bitmap) prev_block = fs->group_desc[group-1].bg_inode_bitmap; start_blk = flexbg_offset(fs, group, prev_block, bmap, flexbg_size, rem_grps, 1); last_blk = ext2fs_group_last_block(fs, last_grp); } if (!fs->group_desc[group].bg_inode_bitmap) { retval = ext2fs_get_free_blocks(fs, start_blk, last_blk, 1, bmap, &new_blk); if (retval == EXT2_ET_BLOCK_ALLOC_FAIL) retval = ext2fs_get_free_blocks(fs, group_blk, last_blk, 1, bmap, &new_blk); if (retval) return retval; ext2fs_mark_block_bitmap2(bmap, new_blk); fs->group_desc[group].bg_inode_bitmap = new_blk; if (flexbg_size) { dgrp_t gr = ext2fs_group_of_blk(fs, new_blk); fs->group_desc[gr].bg_free_blocks_count--; fs->super->s_free_blocks_count--; fs->group_desc[gr].bg_flags &= ~EXT2_BG_BLOCK_UNINIT; ext2fs_group_desc_csum_set(fs, gr); } } /* * Allocate the inode table */ if (flexbg_size) { blk_t prev_block = 0; if (group && fs->group_desc[group-1].bg_inode_table) prev_block = fs->group_desc[group-1].bg_inode_table; group_blk = flexbg_offset(fs, group, prev_block, bmap, flexbg_size * 2, fs->inode_blocks_per_group * rem_grps, fs->inode_blocks_per_group); last_blk = ext2fs_group_last_block(fs, last_grp); } if (!fs->group_desc[group].bg_inode_table) { retval = ext2fs_get_free_blocks(fs, group_blk, last_blk, fs->inode_blocks_per_group, bmap, &new_blk); if (retval) return retval; for (j=0, blk = new_blk; j < fs->inode_blocks_per_group; j++, blk++) { ext2fs_mark_block_bitmap2(bmap, blk); if (flexbg_size) { dgrp_t gr = ext2fs_group_of_blk(fs, blk); fs->group_desc[gr].bg_free_blocks_count--; fs->super->s_free_blocks_count--; fs->group_desc[gr].bg_flags &= ~EXT2_BG_BLOCK_UNINIT; ext2fs_group_desc_csum_set(fs, gr); } } fs->group_desc[group].bg_inode_table = new_blk; } ext2fs_group_desc_csum_set(fs, group); return 0; }