return;
memset(¶m, 0, sizeof(struct ext2_super_block));
- param.s_blocks_count = parse_ulong(argv[2], argv[0],
- "blocks count", &err);
+ ext2fs_blocks_count_set(¶m, parse_ulong(argv[2], argv[0],
+ "blocks count", &err));
if (err)
return;
retval = ext2fs_initialize(argv[1], 0, ¶m,
current_fs->blocksize) + 1;
if (logical_width < 5)
logical_width = 5;
- physical_width = int_log10(current_fs->super->s_blocks_count) + 1;
+ physical_width = int_log10(ext2fs_blocks_count(current_fs->super)) + 1;
if (physical_width < 5)
physical_width = 5;
fprintf(out_file, "\tuuid=%s\n", jsb_buffer);
fprintf(out_file, "\tblocksize=%d\n", blocksize);
fprintf(out_file, "\tjournal data size %lu\n",
- (unsigned long) sb->s_blocks_count);
+ (unsigned long) ext2fs_blocks_count(sb));
}
}
lsd->num_blocks++;
if (*block_nr < fs->super->s_first_data_block ||
- *block_nr >= fs->super->s_blocks_count) {
+ *block_nr >= ext2fs_blocks_count(fs->super)) {
lsd->bad_blocks++;
return BLOCK_ABORT;
}
return;
for (blk=current_fs->super->s_first_data_block;
- blk < current_fs->super->s_blocks_count; blk++) {
+ blk < ext2fs_blocks_count(current_fs->super); blk++) {
if (ext2fs_test_block_bitmap2(current_fs->block_map,blk))
continue;
retval = io_channel_read_blk64(current_fs->io, blk, 1, buf);
goto fatal;
}
} else {
- sprintf(buf, "badblocks -b %d -X %s%s%s %d", fs->blocksize,
+ sprintf(buf, "badblocks -b %d -X %s%s%s %llu", fs->blocksize,
(ctx->options & E2F_OPT_PREEN) ? "" : "-s ",
(ctx->options & E2F_OPT_WRITECHECK) ? "-n " : "",
- fs->device_name, fs->super->s_blocks_count-1);
+ fs->device_name, ext2fs_blocks_count(fs->super)-1);
f = popen(buf, "r");
if (!f) {
com_err("read_bad_blocks_file", errno,
/*
* If the block number is outrageous, clear it and ignore it.
*/
- if (*block_nr >= fs->super->s_blocks_count ||
+ if (*block_nr >= ext2fs_blocks_count(fs->super) ||
*block_nr < fs->super->s_first_data_block) {
printf(_("Warning: illegal block %u found in bad block inode. "
"Cleared.\n"), *block_nr);
p = (struct process_block_struct *) priv_data;
if (blk < fs->super->s_first_data_block ||
- blk >= fs->super->s_blocks_count)
+ blk >= ext2fs_blocks_count(fs->super))
return BLOCK_ABORT;
if (blockcnt >= 0)
goto errout;
}
- journal->j_maxlen = jsuper.s_blocks_count;
+ journal->j_maxlen = ext2fs_blocks_count(&jsuper);
start++;
}
(extent.e_lblk != 0) ||
(extent.e_len != 1) ||
(extent.e_pblk < fs->super->s_first_data_block) ||
- (extent.e_pblk >= fs->super->s_blocks_count))
+ (extent.e_pblk >= ext2fs_blocks_count(fs->super)))
goto exit_extent;
i = 1;
exit_extent:
if ((inode->i_size >= fs->blocksize) ||
(blocks != fs->blocksize >> 9) ||
(inode->i_block[0] < fs->super->s_first_data_block) ||
- (inode->i_block[0] >= fs->super->s_blocks_count))
+ (inode->i_block[0] >= ext2fs_blocks_count(fs->super)))
return 0;
for (i = 1; i < EXT2_N_BLOCKS; i++)
not_device++;
if (blk < ctx->fs->super->s_first_data_block ||
- blk >= ctx->fs->super->s_blocks_count ||
+ blk >= ext2fs_blocks_count(ctx->fs->super) ||
ext2fs_fast_test_block_bitmap2(ctx->block_found_map, blk))
return; /* Invalid block, can't be dir */
}
*/
if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
(blk < fs->super->s_first_data_block) ||
- (blk >= fs->super->s_blocks_count)) {
+ (blk >= ext2fs_blocks_count(fs->super))) {
mark_inode_bad(ctx, ino);
return 0;
}
if ((pctx->errcode) ||
(blk == 0) ||
(blk < fs->super->s_first_data_block) ||
- (blk >= fs->super->s_blocks_count)) {
+ (blk >= ext2fs_blocks_count(fs->super))) {
if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
return 1;
else
problem = 0;
if (extent.e_pblk < ctx->fs->super->s_first_data_block ||
- extent.e_pblk >= ctx->fs->super->s_blocks_count)
+ extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super))
problem = PR_1_EXTENT_BAD_START_BLK;
else if (extent.e_lblk < start_block)
problem = PR_1_OUT_OF_ORDER_EXTENTS;
else if (is_leaf &&
(extent.e_pblk + extent.e_len) >
- ctx->fs->super->s_blocks_count)
+ ext2fs_blocks_count(ctx->fs->super))
problem = PR_1_EXTENT_ENDS_BEYOND;
if (problem) {
if (block < super) {
sprintf(problem, "< FIRSTBLOCK (%u)", super);
return(problem);
- } else if (block >= fs->super->s_blocks_count) {
- sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count);
+ } else if (block >= ext2fs_blocks_count(fs->super)) {
+ sprintf(problem, "> BLOCKS (%u)", ext2fs_blocks_count(fs->super));
return(problem);
}
for (i = 0; i < fs->group_desc_count; i++) {
problem = PR_1_TOOBIG_SYMLINK;
if (blk < fs->super->s_first_data_block ||
- blk >= fs->super->s_blocks_count)
+ blk >= ext2fs_blocks_count(fs->super))
problem = PR_1_ILLEGAL_BLOCK_NUM;
if (problem) {
pctx->blkcount = blockcnt;
if ((blk < fs->super->s_first_data_block) ||
- (blk >= fs->super->s_blocks_count)) {
+ (blk >= ext2fs_blocks_count(fs->super))) {
if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
*block_nr = 0;
return BLOCK_CHANGED;
if (is_flexbg && (pctx.errcode == EXT2_ET_BLOCK_ALLOC_FAIL))
pctx.errcode = ext2fs_get_free_blocks2(fs,
fs->super->s_first_data_block,
- fs->super->s_blocks_count,
+ ext2fs_blocks_count(fs->super),
num, ctx->block_found_map, new_block);
if (pctx.errcode) {
pctx.num = num;
if (HOLE_BLKADDR(*block_nr))
return 0;
if ((*block_nr < fs->super->s_first_data_block) ||
- (*block_nr >= fs->super->s_blocks_count))
+ (*block_nr >= ext2fs_blocks_count(fs->super)))
return 0;
ext2fs_unmark_block_bitmap2(ctx->block_found_map, *block_nr);
ext2fs_block_alloc_stats(fs, *block_nr, -1);
if (ext2fs_file_acl_block(&inode) &&
((ext2fs_file_acl_block(&inode) < fs->super->s_first_data_block) ||
- (ext2fs_file_acl_block(&inode) >= fs->super->s_blocks_count))) {
+ (ext2fs_file_acl_block(&inode) >= ext2fs_blocks_count(fs->super)))) {
if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) {
ext2fs_file_acl_block_set(&inode, 0);
inode_modified++;
if ((fs->super->s_first_data_block <
ext2fs_get_block_bitmap_start2(ctx->block_found_map)) ||
- (fs->super->s_blocks_count-1 >
+ (ext2fs_blocks_count(fs->super)-1 >
ext2fs_get_block_bitmap_end2(ctx->block_found_map))) {
pctx.num = 1;
pctx.blk = fs->super->s_first_data_block;
- pctx.blk2 = fs->super->s_blocks_count -1;
+ pctx.blk2 = ext2fs_blocks_count(fs->super) -1;
pctx.ino = ext2fs_get_block_bitmap_start2(ctx->block_found_map);
pctx.ino2 = ext2fs_get_block_bitmap_end2(ctx->block_found_map);
fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
if ((fs->super->s_first_data_block <
ext2fs_get_block_bitmap_start2(fs->block_map)) ||
- (fs->super->s_blocks_count-1 >
+ (ext2fs_blocks_count(fs->super)-1 >
ext2fs_get_block_bitmap_end2(fs->block_map))) {
pctx.num = 2;
pctx.blk = fs->super->s_first_data_block;
- pctx.blk2 = fs->super->s_blocks_count -1;
+ pctx.blk2 = ext2fs_blocks_count(fs->super) -1;
pctx.ino = ext2fs_get_block_bitmap_start2(fs->block_map);
pctx.ino2 = ext2fs_get_block_bitmap_end2(fs->block_map);
fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
(ext2fs_bg_flag_test(fs, group, EXT2_BG_BLOCK_UNINIT)))
skip_group++;
for (i = fs->super->s_first_data_block;
- i < fs->super->s_blocks_count;
+ i < ext2fs_blocks_count(fs->super);
i++) {
actual = ext2fs_fast_test_block_bitmap2(ctx->block_found_map, i);
cmp_block = fs->super->s_blocks_per_group;
if (group == (int)fs->group_desc_count - 1)
cmp_block =
- fs->super->s_blocks_count %
+ ext2fs_blocks_count(fs->super) %
fs->super->s_blocks_per_group;
}
}
blocks ++;
if ((blocks == fs->super->s_blocks_per_group) ||
- (i == fs->super->s_blocks_count-1)) {
+ (i == ext2fs_blocks_count(fs->super)-1)) {
free_array[group] = group_free;
group ++;
blocks = 0;
fs->group_desc_count*2))
goto errout;
if (csum_flag &&
- (i != fs->super->s_blocks_count-1) &&
+ (i != ext2fs_blocks_count(fs->super)-1) &&
ext2fs_bg_flag_test(fs, group,
EXT2_BG_BLOCK_UNINIT))
skip_group++;
ext2fs_unmark_valid(fs);
}
}
- if (free_blocks != fs->super->s_free_blocks_count) {
+ if (free_blocks != ext2fs_free_blocks_count(fs->super)) {
pctx.group = 0;
- pctx.blk = fs->super->s_free_blocks_count;
+ pctx.blk = ext2fs_free_blocks_count(fs->super);
pctx.blk2 = free_blocks;
if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) {
- fs->super->s_free_blocks_count = free_blocks;
+ ext2fs_free_blocks_count_set(fs->super, free_blocks);
ext2fs_mark_super_dirty(fs);
} else
ext2fs_unmark_valid(fs);
return 0;
if ((blk < fs->super->s_first_data_block) ||
- (blk >= fs->super->s_blocks_count)) {
+ (blk >= ext2fs_blocks_count(fs->super))) {
fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx);
return_abort:
pb->abort = 1;
if ((i < EXT2_N_BLOCKS) || !blk || !inode.i_links_count ||
!(inode.i_mode & LINUX_S_IFREG) ||
(blk < fs->super->s_first_data_block ||
- blk >= fs->super->s_blocks_count)) {
+ blk >= ext2fs_blocks_count(fs->super))) {
resize_inode_invalid:
if (fix_problem(ctx, PR_0_RESIZE_INODE_INVALID, &pctx)) {
memset(&inode, 0, sizeof(inode));
*/
check_super_value(ctx, "inodes_count", sb->s_inodes_count,
MIN_CHECK, 1, 0);
- check_super_value(ctx, "blocks_count", sb->s_blocks_count,
+ check_super_value(ctx, "blocks_count", ext2fs_blocks_count(sb),
MIN_CHECK, 1, 0);
check_super_value(ctx, "first_data_block", sb->s_first_data_block,
- MAX_CHECK, 0, sb->s_blocks_count);
+ MAX_CHECK, 0, ext2fs_blocks_count(sb));
check_super_value(ctx, "log_block_size", sb->s_log_block_size,
MIN_CHECK | MAX_CHECK, 0,
EXT2_MAX_BLOCK_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE);
MIN_CHECK | MAX_CHECK, 8, bpg_max);
check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group,
MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max);
- check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count,
- MAX_CHECK, 0, sb->s_blocks_count / 2);
+ check_super_value(ctx, "r_blocks_count", ext2fs_r_blocks_count(sb),
+ MAX_CHECK, 0, ext2fs_blocks_count(sb) / 2);
check_super_value(ctx, "reserved_gdt_blocks",
sb->s_reserved_gdt_blocks, MAX_CHECK, 0,
fs->blocksize/4);
}
if ((ctx->flags & E2F_FLAG_GOT_DEVSIZE) &&
- (ctx->num_blocks < sb->s_blocks_count)) {
- pctx.blk = sb->s_blocks_count;
+ (ctx->num_blocks < ext2fs_blocks_count(sb))) {
+ pctx.blk = ext2fs_blocks_count(sb);
pctx.blk2 = ctx->num_blocks;
if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) {
ctx->flags |= E2F_FLAG_ABORT;
* Verify the group descriptors....
*/
first_block = sb->s_first_data_block;
- last_block = sb->s_blocks_count-1;
+ last_block = ext2fs_blocks_count(sb)-1;
csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
* inodes; if the filesystem is not unmounted cleanly, the
* global counts may not be accurate.
*/
- if ((free_blocks != sb->s_free_blocks_count) ||
+ if ((free_blocks != ext2fs_free_blocks_count(sb)) ||
(free_inodes != sb->s_free_inodes_count)) {
if (ctx->options & E2F_OPT_READONLY)
ext2fs_unmark_valid(fs);
else {
- sb->s_free_blocks_count = free_blocks;
+ ext2fs_free_blocks_count_set(sb, free_blocks);
sb->s_free_inodes_count = free_inodes;
ext2fs_mark_super_dirty(fs);
}
}
- if ((sb->s_free_blocks_count > sb->s_blocks_count) ||
+ if ((ext2fs_free_blocks_count(sb) > ext2fs_blocks_count(sb)) ||
(sb->s_free_inodes_count > sb->s_inodes_count))
ext2fs_unmark_valid(fs);
inodes = fs->super->s_inodes_count;
inodes_used = (fs->super->s_inodes_count -
fs->super->s_free_inodes_count);
- blocks = fs->super->s_blocks_count;
- blocks_used = (fs->super->s_blocks_count -
- fs->super->s_free_blocks_count);
+ blocks = ext2fs_blocks_count(fs->super);
+ blocks_used = (ext2fs_blocks_count(fs->super) -
+ ext2fs_free_blocks_count(fs->super));
frag_percent_file = (10000 * ctx->fs_fragmented) / inodes_used;
frag_percent_file = (frag_percent_file + 5) / 10;
fputs(_(", check forced.\n"), stdout);
return;
}
- printf(_("%s: clean, %u/%u files, %u/%u blocks"), ctx->device_name,
+ printf(_("%s: clean, %u/%u files, %llu/%llu blocks"), ctx->device_name,
fs->super->s_inodes_count - fs->super->s_free_inodes_count,
fs->super->s_inodes_count,
- fs->super->s_blocks_count - fs->super->s_free_blocks_count,
- fs->super->s_blocks_count);
+ ext2fs_blocks_count(fs->super) -
+ ext2fs_free_blocks_count(fs->super),
+ ext2fs_blocks_count(fs->super));
next_check = 100000;
if (fs->super->s_max_mnt_count > 0) {
next_check = fs->super->s_max_mnt_count - fs->super->s_mnt_count;
if (ctx->flags & E2F_FLAG_JOURNAL_INODE) {
if (fix_problem(ctx, PR_6_RECREATE_JOURNAL, &pctx)) {
if (journal_size < 1024)
- journal_size = ext2fs_default_journal_size(fs->super->s_blocks_count);
+ journal_size = ext2fs_default_journal_size(ext2fs_blocks_count(fs->super));
if (journal_size < 0) {
fs->super->s_feature_compat &=
~EXT3_FEATURE_COMPAT_HAS_JOURNAL;
ptr->callback [num]=callback;
}
-static unsigned int div_ceil(unsigned int a, unsigned int b)
-{
- if (!a)
- return 0;
- return ((a - 1) / b) + 1;
-}
-
int set_file_system_info (void)
{
file_system_info.first_group_desc_offset=2*EXT2_MIN_BLOCK_SIZE;
else
file_system_info.first_group_desc_offset=file_system_info.block_size;
- file_system_info.groups_count = div_ceil(sb->s_blocks_count,
+ file_system_info.groups_count = ext2fs_div64_ceil(ext2fs_blocks_count(sb),
sb->s_blocks_per_group);
file_system_info.inodes_per_block=file_system_info.block_size/sizeof (struct ext2_inode);
file_system_info.blocks_per_group=sb->s_inodes_per_group/file_system_info.inodes_per_block;
file_system_info.no_blocks_in_group=sb->s_blocks_per_group;
- file_system_info.file_system_size=(sb->s_blocks_count-1)*file_system_info.block_size;
+ file_system_info.file_system_size=(ext2fs_blocks_count(sb)-1)*file_system_info.block_size;
}
else {
show (command_line);
- if (super->s_blocks_count != 0) {
- wmove (show_pad,2,40);wprintw (show_pad,"%2.2f%%",100*(float) super->s_r_blocks_count/ (float) super->s_blocks_count);
- wmove (show_pad,3,40);wprintw (show_pad,"%2.2f%%",100*(float) super->s_free_blocks_count/ (float) super->s_blocks_count);
+ if (ext2fs_blocks_count(super) != 0) {
+ wmove (show_pad,2,40);wprintw (show_pad,"%2.2f%%",100*(float) ext2fs_r_blocks_count(super)/ (float) ext2fs_blocks_count(super));
+ wmove (show_pad,3,40);wprintw (show_pad,"%2.2f%%",100*(float) ext2fs_free_blocks_count(super)/ (float) ext2fs_blocks_count(super));
}
if (super->s_inodes_count != 0) {
map = fs->block_map;
if (!map)
return EXT2_ET_NO_BLOCK_BITMAP;
- if (!goal || (goal >= fs->super->s_blocks_count))
+ if (!goal || (goal >= ext2fs_blocks_count(fs->super)))
goal = fs->super->s_first_data_block;
i = goal;
check_block_uninit(fs, map,
return 0;
}
i++;
- if (i >= fs->super->s_blocks_count)
+ if (i >= ext2fs_blocks_count(fs->super))
i = fs->super->s_first_data_block;
} while (i != goal);
return EXT2_ET_BLOCK_ALLOC_FAIL;
if (!num)
num = 1;
do {
- if (b+num-1 > fs->super->s_blocks_count)
+ if (b+num-1 > ext2fs_blocks_count(fs->super))
b = fs->super->s_first_data_block;
if (ext2fs_fast_test_block_bitmap_range2(map, b, num)) {
*ret = b;
if (fs->super->s_reserved_gdt_blocks && fs->block_map == bmap)
ext2fs_bg_flag_clear(fs, group, EXT2_BG_BLOCK_UNINIT);
for (j=0; j < old_desc_blocks; j++)
- if (old_desc_blk + j < fs->super->s_blocks_count)
+ if (old_desc_blk + j < ext2fs_blocks_count(fs->super))
ext2fs_mark_block_bitmap2(bmap,
old_desc_blk + j);
}
ext2fs_mark_block_bitmap2(bmap, new_desc_blk);
if (group == fs->group_desc_count-1) {
- num_blocks = (fs->super->s_blocks_count -
+ num_blocks = (ext2fs_blocks_count(fs->super) -
fs->super->s_first_data_block) %
fs->super->s_blocks_per_group;
if (!num_blocks)
int group = ext2fs_group_of_blk2(fs, blk);
#ifndef OMIT_COM_ERR
- if (blk >= fs->super->s_blocks_count) {
+ if (blk >= ext2fs_blocks_count(fs->super)) {
com_err("ext2fs_block_alloc_stats", 0,
"Illegal block number: %lu", (unsigned long) blk);
return;
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--;
+ ext2fs_free_blocks_count_add(fs->super, -1);
ext2fs_bg_flag_clear(fs, gr, EXT2_BG_BLOCK_UNINIT);
ext2fs_group_desc_csum_set(fs, gr);
}
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--;
+ ext2fs_free_blocks_count_add(fs->super, -1);
ext2fs_bg_flag_clear(fs, gr, EXT2_BG_BLOCK_UNINIT);
ext2fs_group_desc_csum_set(fs, gr);
}
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--;
+ ext2fs_free_blocks_count_add(fs->super, -1);
ext2fs_bg_flag_clear(fs, gr,
EXT2_BG_BLOCK_UNINIT);
ext2fs_group_desc_csum_set(fs, gr);
/*
* If the block number is outrageous, clear it and ignore it.
*/
- if (*block_nr >= fs->super->s_blocks_count ||
+ if (*block_nr >= ext2fs_blocks_count(fs->super) ||
*block_nr < fs->super->s_first_data_block) {
*block_nr = 0;
return BLOCK_CHANGED;
ctx->bcount += limit;
return ret;
}
- if (*ind_block >= ctx->fs->super->s_blocks_count ||
+ if (*ind_block >= ext2fs_blocks_count(ctx->fs->super) ||
*ind_block < ctx->fs->super->s_first_data_block) {
ctx->errcode = EXT2_ET_BAD_IND_BLOCK;
ret |= BLOCK_ERROR;
ctx->bcount += limit*limit;
return ret;
}
- if (*dind_block >= ctx->fs->super->s_blocks_count ||
+ if (*dind_block >= ext2fs_blocks_count(ctx->fs->super) ||
*dind_block < ctx->fs->super->s_first_data_block) {
ctx->errcode = EXT2_ET_BAD_DIND_BLOCK;
ret |= BLOCK_ERROR;
ctx->bcount += limit*limit*limit;
return ret;
}
- if (*tind_block >= ctx->fs->super->s_blocks_count ||
+ if (*tind_block >= ext2fs_blocks_count(ctx->fs->super) ||
*tind_block < ctx->fs->super->s_first_data_block) {
ctx->errcode = EXT2_ET_BAD_TIND_BLOCK;
ret |= BLOCK_ERROR;
*/
if (ext2fs_test_block_bitmap2(pb->reserve, block)) {
do {
- if (++block >= fs->super->s_blocks_count)
+ if (++block >= ext2fs_blocks_count(fs->super))
block = fs->super->s_first_data_block;
if (block == orig) {
pb->error = EXT2_ET_BLOCK_ALLOC_FAIL;
errcode_t retval;
dgrp_t i;
blk_t first_block = fs->super->s_first_data_block;
- blk_t last_block = fs->super->s_blocks_count-1;
+ blk_t last_block = ext2fs_blocks_count(fs->super)-1;
blk_t blk, b;
int j;
first_block = ext2fs_group_first_block(fs, i);
last_block = ext2fs_group_last_block(fs, i);
if (i == (fs->group_desc_count - 1))
- last_block = fs->super->s_blocks_count-1;
+ last_block = ext2fs_blocks_count(fs->super)-1;
}
/*
&ret_used_blks);
if (group == fs->group_desc_count-1) {
- numblocks = (fs->super->s_blocks_count -
- fs->super->s_first_data_block) %
- fs->super->s_blocks_per_group;
+ numblocks = (ext2fs_blocks_count(fs->super) -
+ (blk64_t) fs->super->s_first_data_block) %
+ (blk64_t) fs->super->s_blocks_per_group;
if (!numblocks)
numblocks = fs->super->s_blocks_per_group;
} else
__u16 csum1, csum2, csum_known = 0xd3a4;
memset(¶m, 0, sizeof(param));
- param.s_blocks_count = 32768;
+ ext2fs_blocks_count_set(¶m, 32768);
retval = ext2fs_initialize("test fs", EXT2_FLAG_64BITS, ¶m,
test_io_manager, &fs);
struct ext2_ext_attr_header *header;
char *buf = 0;
- if ((blk >= fs->super->s_blocks_count) ||
+ if ((blk >= ext2fs_blocks_count(fs->super)) ||
(blk < fs->super->s_first_data_block))
return EXT2_ET_BAD_EA_BLOCK_NUM;
initialize_ext2_error_table();
memset(¶m, 0, sizeof(param));
- param.s_blocks_count = 12000;
+ ext2fs_blocks_count_set(¶m, 12000);
retval = ext2fs_initialize("test fs", EXT2_FLAG_64BITS, ¶m,
test_io_manager, &test_fs);
/* We set it at 1024x the current filesystem size, or
* the upper block count limit (2^32), whichever is lower.
*/
- if (sb->s_blocks_count < max_blocks / 1024)
- max_blocks = sb->s_blocks_count * 1024;
+ if (ext2fs_blocks_count(sb) < max_blocks / 1024)
+ max_blocks = ext2fs_blocks_count(sb) * 1024;
rsv_groups = ext2fs_div_ceil(max_blocks - sb->s_first_data_block, bpg);
rsv_gdb = ext2fs_div_ceil(rsv_groups, gdpb) - fs->desc_blocks;
if (rsv_gdb > EXT2_ADDR_PER_BLOCK(sb))
char *buf = 0;
char c;
- if (!param || !param->s_blocks_count)
+ if (!param || !ext2fs_blocks_count(param))
return EXT2_ET_INVALID_ARGUMENT;
retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs);
super->s_blocks_per_group = EXT2_MAX_BLOCKS_PER_GROUP(super);
super->s_frags_per_group = super->s_blocks_per_group * frags_per_block;
- super->s_blocks_count = param->s_blocks_count;
- super->s_r_blocks_count = param->s_r_blocks_count;
- if (super->s_r_blocks_count >= param->s_blocks_count) {
+ ext2fs_blocks_count_set(super, ext2fs_blocks_count(param));
+ ext2fs_r_blocks_count_set(super, ext2fs_r_blocks_count(param));
+ if (ext2fs_r_blocks_count(super) >= ext2fs_blocks_count(param)) {
retval = EXT2_ET_INVALID_ARGUMENT;
goto cleanup;
}
}
retry:
- fs->group_desc_count = ext2fs_div_ceil(super->s_blocks_count -
- super->s_first_data_block,
- EXT2_BLOCKS_PER_GROUP(super));
+ fs->group_desc_count = (blk_t) ext2fs_div64_ceil(
+ ext2fs_blocks_count(super) - super->s_first_data_block,
+ EXT2_BLOCKS_PER_GROUP(super));
if (fs->group_desc_count == 0) {
retval = EXT2_ET_TOOSMALL;
goto cleanup;
EXT2_DESC_PER_BLOCK(super));
i = fs->blocksize >= 4096 ? 1 : 4096 / fs->blocksize;
- set_field(s_inodes_count, super->s_blocks_count / i);
+ set_field(s_inodes_count, ext2fs_blocks_count(super) / i);
/*
* Make sure we have at least EXT2_FIRST_INO + 1 inodes, so
if (super->s_blocks_per_group >= 256) {
/* Try again with slightly different parameters */
super->s_blocks_per_group -= 8;
- super->s_blocks_count = param->s_blocks_count;
+ ext2fs_blocks_count_set(super,
+ ext2fs_blocks_count(param));
super->s_frags_per_group = super->s_blocks_per_group *
frags_per_block;
goto retry;
overhead = (int) (2 + fs->inode_blocks_per_group);
if (ext2fs_bg_has_super(fs, fs->group_desc_count - 1))
overhead += 1 + fs->desc_blocks + super->s_reserved_gdt_blocks;
- rem = ((super->s_blocks_count - super->s_first_data_block) %
+ rem = ((ext2fs_blocks_count(super) - super->s_first_data_block) %
super->s_blocks_per_group);
if ((fs->group_desc_count == 1) && rem && (rem < overhead)) {
retval = EXT2_ET_TOOSMALL;
goto cleanup;
}
if (rem && (rem < overhead+50)) {
- super->s_blocks_count -= rem;
+ ext2fs_blocks_count_set(super, ext2fs_blocks_count(super) -
+ rem);
+
goto retry;
}
* superblock and group descriptors (the inode tables and
* bitmaps will be accounted for when allocated).
*/
- super->s_free_blocks_count = 0;
+ ext2fs_free_blocks_count_set(super, 0);
csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
for (i = 0; i < fs->group_desc_count; i++) {
if (fs->super->s_log_groups_per_flex)
numblocks += 2 + fs->inode_blocks_per_group;
- super->s_free_blocks_count += numblocks;
+ ext2fs_free_blocks_count_set(super,
+ ext2fs_free_blocks_count(super) +
+ numblocks);
fs->group_desc[i].bg_free_blocks_count = numblocks;
fs->group_desc[i].bg_free_inodes_count =
fs->super->s_inodes_per_group;
* the filesystem. Pick a group that has the largest number
* of free blocks.
*/
- group = ext2fs_group_of_blk(fs, (fs->super->s_blocks_count -
+ group = ext2fs_group_of_blk(fs, (ext2fs_blocks_count(fs->super) -
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)) {
*/
if (group_block != fs->super->s_first_data_block &&
((ret_blk + fs->super->s_blocks_per_group) <
- fs->super->s_blocks_count))
+ ext2fs_blocks_count(fs->super)))
ret_blk += fs->super->s_blocks_per_group;
return ret_blk;
}
blocks_per_group > EXT2_MAX_BLOCKS_PER_GROUP(fs->super) ||
fs->inode_blocks_per_group > EXT2_MAX_INODES_PER_GROUP(fs->super) ||
EXT2_DESC_PER_BLOCK(fs->super) == 0 ||
- fs->super->s_first_data_block >= fs->super->s_blocks_count) {
+ fs->super->s_first_data_block >= ext2fs_blocks_count(fs->super)) {
retval = EXT2_ET_CORRUPT_SUPERBLOCK;
goto cleanup;
}
- fs->group_desc_count = ext2fs_div_ceil(fs->super->s_blocks_count -
- fs->super->s_first_data_block,
- blocks_per_group);
- if (fs->group_desc_count * EXT2_INODES_PER_GROUP(fs->super) !=
- fs->super->s_inodes_count) {
- retval = EXT2_ET_CORRUPT_SUPERBLOCK;
+ fs->group_desc_count = ext2fs_div64_ceil(ext2fs_blocks_count(fs->super) -
+ fs->super->s_first_data_block,
+ blocks_per_group);
+ if (fs->group_desc_count * EXT2_INODES_PER_GROUP(fs->super) !=
+ fs->super->s_inodes_count) {
+ retval = EXT2_ET_CORRUPT_SUPERBLOCK;
goto cleanup;
- }
+ }
fs->desc_blocks = ext2fs_div_ceil(fs->group_desc_count,
EXT2_DESC_PER_BLOCK(fs->super));
retval = ext2fs_get_array(fs->desc_blocks, fs->blocksize,
if (i == fs->group_desc_count - 1) {
/* Force bitmap padding for the last group */
- nbits = ((fs->super->s_blocks_count
- - fs->super->s_first_data_block)
- % EXT2_BLOCKS_PER_GROUP(fs->super));
+ nbits = ((ext2fs_blocks_count(fs->super)
+ - (__u64) fs->super->s_first_data_block)
+ % (__u64) EXT2_BLOCKS_PER_GROUP(fs->super));
if (nbits)
for (j = nbits; j < fs->blocksize * 8; j++)
ext2fs_set_bit(j, block_buf);
fs->super = malloc(SUPERBLOCK_SIZE);
memset(fs->super, 0, SUPERBLOCK_SIZE);
fs->super->s_first_data_block = 1;
- fs->super->s_blocks_count = 100;
+ ext2fs_blocks_count_set(fs->super, 100);
f = tmpfile();
if (!f) {
findsuper: findsuper.o
$(E) " LD $@"
- $(Q) $(CC) $(ALL_LDFLAGS) -o findsuper findsuper.o
+ $(Q) $(CC) $(ALL_LDFLAGS) -o findsuper findsuper.o $(LIBS)
partinfo: partinfo.o
$(E) " LD $@"
void scan_block_bitmap(ext2_filsys fs, struct chunk_info *info)
{
- unsigned long long blocks_count = fs->super->s_blocks_count;
+ unsigned long long blocks_count = ext2fs_blocks_count(fs->super);
unsigned long long chunks = (blocks_count + info->blks_in_chunk) >>
(info->chunkbits - info->blocksize_bits);
unsigned long long chunk_num;
scan_block_bitmap(fs, info);
- printf("Total blocks: %u\nFree blocks: %u (%0.1f%%)\n",
- fs->super->s_blocks_count, fs->super->s_free_blocks_count,
+ printf("Total blocks: %llu\nFree blocks: %u (%0.1f%%)\n",
+ ext2fs_blocks_count(fs->super), fs->super->s_free_blocks_count,
(double)fs->super->s_free_blocks_count * 100 /
- fs->super->s_blocks_count);
+ ext2fs_blocks_count(fs->super));
if (info->chunkbytes) {
printf("\nChunksize: %lu bytes (%u blocks)\n",
info->chunkbytes, info->blks_in_chunk);
- total_chunks = (fs->super->s_blocks_count +
+ total_chunks = (ext2fs_blocks_count(fs->super) +
info->blks_in_chunk) >>
(info->chunkbits - info->blocksize_bits);
printf("Total chunks: %lu\nFree chunks: %lu (%0.1f%%)\n",
exit(1);
}
memset(zero_buf, 0, fs->blocksize);
- for (blk = 0; blk < fs->super->s_blocks_count; blk++) {
+ for (blk = 0; blk < ext2fs_blocks_count(fs->super); blk++) {
if ((blk >= fs->super->s_first_data_block) &&
ext2fs_test_block_bitmap2(meta_block_map, blk)) {
retval = io_channel_read_blk64(fs->io, blk, 1, buf);
#include <time.h>
#include "ext2fs/ext2_fs.h"
+#include "ext2fs/ext2fs.h"
#include "nls-enable.h"
#undef DEBUG
continue;
if (ext2.s_log_block_size > 6)
WHY("log block size > 6 (%u)\n", ext2.s_log_block_size);
- if (ext2.s_r_blocks_count > ext2.s_blocks_count)
+ if (ext2fs_r_blocks_count(&ext2) > ext2fs_blocks_count(&ext2))
WHY("r_blocks_count > blocks_count (%u > %u)\n",
- ext2.s_r_blocks_count, ext2.s_blocks_count);
- if (ext2.s_free_blocks_count > ext2.s_blocks_count)
+ ext2fs_r_blocks_count(&ext2),
+ ext2fs_blocks_count(&ext2));
+ if (ext2fs_free_blocks_count(&ext2) > ext2fs_blocks_count(&ext2))
WHY("free_blocks_count > blocks_count\n (%u > %u)\n",
- ext2.s_free_blocks_count, ext2.s_blocks_count);
+ ext2fs_free_blocks_count(&ext2),
+ ext2fs_blocks_count(&ext2));
if (ext2.s_free_inodes_count > ext2.s_inodes_count)
WHY("free_inodes_count > inodes_count (%u > %u)\n",
ext2.s_free_inodes_count, ext2.s_inodes_count);
printf("\r%11Lu %11Lu%s %11Lu%s %9u %5Lu %4u%s %s %02x%02x%02x%02x %s\n",
sk, sk - ext2.s_block_group_nr * grpsize - sb_offset,
jnl_copy ? "*":" ",
- sk + ext2.s_blocks_count * bsize -
+ sk + ext2fs_blocks_count(&ext2) * bsize -
ext2.s_block_group_nr * grpsize - sb_offset,
- jnl_copy ? "*" : " ", ext2.s_blocks_count, bsize,
+ jnl_copy ? "*" : " ", ext2fs_blocks_count(&ext2), bsize,
ext2.s_block_group_nr, jnl_copy ? "*" : " ", s,
ext2.s_uuid[0], ext2.s_uuid[1],
ext2.s_uuid[2], ext2.s_uuid[3], ext2.s_volume_name);
errcode_t retval;
char buf[1024];
- sprintf(buf, "badblocks -b %d -X %s%s%s %u", fs->blocksize,
+ sprintf(buf, "badblocks -b %d -X %s%s%s %llu", fs->blocksize,
quiet ? "" : "-s ", (cflag > 1) ? "-w " : "",
- fs->device_name, fs->super->s_blocks_count-1);
+ fs->device_name, ext2fs_blocks_count(fs->super)-1);
if (verbose)
printf(_("Running command: %s\n"), buf);
f = popen(buf, "r");
group = ext2fs_group_of_blk(fs, group_block+j);
fs->group_desc[group].bg_free_blocks_count++;
ext2fs_group_desc_csum_set(fs, group);
- fs->super->s_free_blocks_count++;
+ ext2fs_free_blocks_count_add(fs->super, 1);
}
}
group_block += fs->super->s_blocks_per_group;
int c, count, err_count;
retval = ext2fs_create_journal_superblock(fs,
- fs->super->s_blocks_count, 0, &buf);
+ ext2fs_blocks_count(fs->super), 0, &buf);
if (retval) {
com_err("create_journal_dev", retval,
_("while initializing journal superblock"));
_("Zeroing journal device: "),
ext2fs_blocks_count(fs->super));
blk = 0;
- count = fs->super->s_blocks_count;
+ count = ext2fs_blocks_count(fs->super);
while (count > 0) {
if (count > 1024)
c = 1024;
dgrp_t i;
int need, col_left;
- if (fs_param.s_blocks_count != s->s_blocks_count)
- fprintf(stderr, _("warning: %u blocks unused.\n\n"),
- fs_param.s_blocks_count - s->s_blocks_count);
+ if (ext2fs_blocks_count(&fs_param) != ext2fs_blocks_count(s))
+ fprintf(stderr, _("warning: %llu blocks unused.\n\n"),
+ ext2fs_blocks_count(&fs_param) - ext2fs_blocks_count(s));
memset(buf, 0, sizeof(buf));
strncpy(buf, s->s_volume_name, sizeof(s->s_volume_name));
s->s_log_block_size);
printf(_("Fragment size=%u (log=%u)\n"), fs->fragsize,
s->s_log_frag_size);
- printf(_("%u inodes, %u blocks\n"), s->s_inodes_count,
- s->s_blocks_count);
- printf(_("%u blocks (%2.2f%%) reserved for the super user\n"),
- s->s_r_blocks_count,
- 100.0 * s->s_r_blocks_count / s->s_blocks_count);
+ printf(_("%u inodes, %llu blocks\n"), s->s_inodes_count,
+ ext2fs_blocks_count(s));
+ printf(_("%llu blocks (%2.2f%%) reserved for the super user\n"),
+ ext2fs_r_blocks_count(s),
+ 100.0 * ext2fs_r_blocks_count(s) / ext2fs_blocks_count(s));
printf(_("First data block=%u\n"), s->s_first_data_block);
if (s->s_reserved_gdt_blocks)
printf(_("Maximum filesystem blocks=%lu\n"),
r_usage++;
continue;
}
- if (resize <= param->s_blocks_count) {
+ if (resize <= ext2fs_blocks_count(param)) {
fprintf(stderr,
_("The resize maximum must be greater "
"than the filesystem size.\n"));
if (!bpg)
bpg = blocksize * 8;
gdpb = EXT2_DESC_PER_BLOCK(param);
- group_desc_count =
- ext2fs_div_ceil(param->s_blocks_count, bpg);
+ group_desc_count = (__u32) ext2fs_div64_ceil(
+ ext2fs_blocks_count(param), bpg);
desc_blocks = (group_desc_count +
gdpb - 1) / gdpb;
rsv_groups = ext2fs_div_ceil(resize, bpg);
}
meg = (1024 * 1024) / EXT2_BLOCK_SIZE(fs_param);
- if (fs_param->s_blocks_count < 3 * meg)
+ if (ext2fs_blocks_count(fs_param) < 3 * meg)
size_type = "floppy";
- else if (fs_param->s_blocks_count < 512 * meg)
+ else if (ext2fs_blocks_count(fs_param) < 512 * meg)
size_type = "small";
else
size_type = "default";
blocksize, sys_page_size);
}
if (optind < argc) {
- fs_param.s_blocks_count = parse_num_blocks(argv[optind++],
- fs_param.s_log_block_size);
- if (!fs_param.s_blocks_count) {
+ ext2fs_blocks_count_set(&fs_param, parse_num_blocks(argv[optind++],
+ fs_param.s_log_block_size));
+ if (!ext2fs_blocks_count(&fs_param)) {
com_err(program_name, 0, _("invalid blocks count - %s"),
argv[optind - 1]);
exit(1);
fs_param.s_log_frag_size = fs_param.s_log_block_size;
- if (noaction && fs_param.s_blocks_count) {
- dev_size = fs_param.s_blocks_count;
+ if (noaction && ext2fs_blocks_count(&fs_param)) {
+ dev_size = ext2fs_blocks_count(&fs_param);
retval = 0;
} else {
retry:
exit(1);
}
got_size:
- if (!fs_param.s_blocks_count) {
+ if (!ext2fs_blocks_count(&fs_param)) {
if (retval == EXT2_ET_UNIMPLEMENTED) {
com_err(program_name, 0,
_("Couldn't determine device size; you "
));
exit(1);
}
- fs_param.s_blocks_count = dev_size;
- if (sys_page_size > EXT2_BLOCK_SIZE(&fs_param))
- fs_param.s_blocks_count &= ~((sys_page_size /
- EXT2_BLOCK_SIZE(&fs_param))-1);
- }
+ ext2fs_blocks_count_set(&fs_param, dev_size);
+ if (sys_page_size > EXT2_BLOCK_SIZE(&fs_param)) {
+ blk64_t tmp = ext2fs_blocks_count(&fs_param);
- } else if (!force && (fs_param.s_blocks_count > dev_size)) {
+ tmp &= ~((blk64_t) ((sys_page_size /
+ EXT2_BLOCK_SIZE(&fs_param))-1));
+ ext2fs_blocks_count_set(&fs_param, tmp);
+ }
+ }
+ } else if (!force && (ext2fs_blocks_count(&fs_param) > dev_size)) {
com_err(program_name, 0,
_("Filesystem larger than apparent device size."));
proceed_question();
if ((blocksize < 0) && (use_bsize < (-blocksize)))
use_bsize = -blocksize;
blocksize = use_bsize;
- fs_param.s_blocks_count /= blocksize / 1024;
+ ext2fs_blocks_count_set(&fs_param,
+ ext2fs_blocks_count(&fs_param) /
+ (blocksize / 1024));
}
if (inode_ratio == 0) {
/* Make sure number of inodes specified will fit in 32 bits */
if (num_inodes == 0) {
unsigned long long n;
- n = (unsigned long long) fs_param.s_blocks_count * blocksize / inode_ratio;
+ n = ext2fs_blocks_count(&fs_param) * blocksize / inode_ratio;
if (n > ~0U) {
com_err(program_name, 0,
_("too many inodes (%llu), raise inode ratio?"), n);
* Calculate number of inodes based on the inode ratio
*/
fs_param.s_inodes_count = num_inodes ? num_inodes :
- ((__u64) fs_param.s_blocks_count * blocksize)
- / inode_ratio;
+ (ext2fs_blocks_count(&fs_param) * blocksize) / inode_ratio;
if ((((long long)fs_param.s_inodes_count) *
(inode_size ? inode_size : EXT2_GOOD_OLD_INODE_SIZE)) >=
- (((long long)fs_param.s_blocks_count) *
+ ((ext2fs_blocks_count(&fs_param)) *
EXT2_BLOCK_SIZE(&fs_param))) {
com_err(program_name, 0, _("inode_size (%u) * inodes_count "
"(%u) too big for a\n\t"
- "filesystem with %lu blocks, "
+ "filesystem with %llu blocks, "
"specify higher inode_ratio (-i)\n\t"
"or lower inode count (-N).\n"),
inode_size ? inode_size : EXT2_GOOD_OLD_INODE_SIZE,
fs_param.s_inodes_count,
- (unsigned long) fs_param.s_blocks_count);
+ (unsigned long long) ext2fs_blocks_count(&fs_param));
exit(1);
}
/*
* Calculate number of blocks to reserve
*/
- fs_param.s_r_blocks_count = (unsigned int) (reserved_ratio *
- fs_param.s_blocks_count / 100.0);
+ ext2fs_r_blocks_count_set(&fs_param, reserved_ratio *
+ ext2fs_blocks_count(&fs_param) / 100.0);
}
static int should_do_undo(const char *name)
} else {
/* rsv must be a power of two (64kB is MD RAID sb alignment) */
unsigned int rsv = 65536 / fs->blocksize;
- unsigned long blocks = fs->super->s_blocks_count;
+ unsigned long blocks = ext2fs_blocks_count(fs->super);
unsigned long start;
blk_t ret_blk;
static time_t last_check_time;
static int print_label;
static int max_mount_count, mount_count, mount_flags;
-static unsigned long interval, reserved_blocks;
+static unsigned long interval;
+static blk64_t reserved_blocks;
static double reserved_ratio;
static unsigned long resgid, resuid;
static unsigned short errors;
group = ext2fs_group_of_blk(fs, block);
fs->group_desc[group].bg_free_blocks_count++;
ext2fs_group_desc_csum_set(fs, group);
- fs->super->s_free_blocks_count++;
+ ext2fs_free_blocks_count_add(fs->super, 1);
return 0;
}
}
ext2fs_badblocks_list_free(bb_list);
- if (needed_blocks > fs->super->s_free_blocks_count)
+ if (needed_blocks > ext2fs_free_blocks_count(fs->super))
return ENOSPC;
return 0;
return retval;
for (new_blk = blk = fs->super->s_first_data_block;
- blk < fs->super->s_blocks_count; blk++) {
+ blk < ext2fs_blocks_count(fs->super); blk++) {
if (!ext2fs_test_block_bitmap2(bmap, blk))
continue;
* First calculate the block statistics
*/
for (blk = fs->super->s_first_data_block;
- blk < fs->super->s_blocks_count; blk++) {
+ blk < ext2fs_blocks_count(fs->super); blk++) {
if (!ext2fs_fast_test_block_bitmap2(fs->block_map, blk)) {
group_free++;
total_free++;
}
count++;
if ((count == fs->super->s_blocks_per_group) ||
- (blk == fs->super->s_blocks_count-1)) {
+ (blk == ext2fs_blocks_count(fs->super)-1)) {
fs->group_desc[group++].bg_free_blocks_count =
group_free;
count = 0;
group_free = 0;
}
}
- fs->super->s_free_blocks_count = total_free;
+ ext2fs_free_blocks_count_set(fs->super, total_free);
/*
* Next, calculate the inode statistics
interval);
}
if (m_flag) {
- sb->s_r_blocks_count = (unsigned int) (reserved_ratio *
- sb->s_blocks_count / 100.0);
+ ext2fs_r_blocks_count_set(sb, reserved_ratio *
+ ext2fs_blocks_count(sb) / 100.0);
ext2fs_mark_super_dirty(fs);
- printf(_("Setting reserved blocks percentage to %g%% "
- "(%u blocks)\n"),
- reserved_ratio, sb->s_r_blocks_count);
+ printf (_("Setting reserved blocks percentage to %g%% (%llu blocks)\n"),
+ reserved_ratio, ext2fs_r_blocks_count(sb));
}
if (r_flag) {
- if (reserved_blocks >= sb->s_blocks_count/2) {
+ if (reserved_blocks >= ext2fs_blocks_count(sb)/2) {
com_err(program_name, 0,
- _("reserved blocks count is too big (%lu)"),
+ _("reserved blocks count is too big (%llu)"),
reserved_blocks);
exit(1);
}
- sb->s_r_blocks_count = reserved_blocks;
+ ext2fs_r_blocks_count_set(sb, reserved_blocks);
ext2fs_mark_super_dirty(fs);
- printf(_("Setting reserved blocks count to %lu\n"),
+ printf(_("Setting reserved blocks count to %llu\n"),
reserved_blocks);
}
if (s_flag == 1) {
{
int j_blocks;
- j_blocks = ext2fs_default_journal_size(fs->super->s_blocks_count);
+ j_blocks = ext2fs_default_journal_size(ext2fs_blocks_count(fs->super));
if (j_blocks < 0) {
fputs(_("\nFilesystem too small for a journal\n"), stderr);
return 0;
j_blocks);
exit(1);
}
- if ((unsigned) j_blocks > fs->super->s_free_blocks_count / 2) {
+ if ((unsigned) j_blocks > ext2fs_free_blocks_count(fs->super) / 2) {
fputs(_("\nJournal size too big for filesystem.\n"),
stderr);
exit(1);
fs->blocksize / 1024, new_size);
exit(1);
}
- if (new_size == fs->super->s_blocks_count) {
+ if (new_size == ext2fs_blocks_count(fs->super)) {
fprintf(stderr, _("The filesystem is already %u blocks "
"long. Nothing to do!\n\n"), new_size);
exit(0);
printf(_("Filesystem at %s is mounted on %s; "
"on-line resizing required\n"), fs->device_name, mtpt);
- if (*new_size < sb->s_blocks_count) {
- printf(_("On-line shrinking from %u to %u not supported.\n"),
- sb->s_blocks_count, *new_size);
+ if (*new_size < ext2fs_blocks_count(sb)) {
+ printf(_("On-line shrinking from %llu to %u not supported.\n"),
+ ext2fs_blocks_count(sb), *new_size);
exit(1);
}
exit(1);
}
- size=sb->s_blocks_count;
+ size=ext2fs_blocks_count(sb);
if (ioctl(fd, EXT2_IOC_GROUP_EXTEND, &size)) {
if (errno == EPERM)
com_err(program_name, 0,
exit(1);
}
- percent = (sb->s_r_blocks_count * 100.0) / sb->s_blocks_count;
+ percent = (ext2fs_r_blocks_count(sb) * 100.0) /
+ ext2fs_blocks_count(sb);
retval = ext2fs_read_bitmaps(fs);
if (retval)
input.inode_table = new_fs->group_desc[i].bg_inode_table;
input.blocks_count = sb->s_blocks_per_group;
if (i == new_fs->group_desc_count-1) {
- input.blocks_count = new_fs->super->s_blocks_count -
+ input.blocks_count = ext2fs_blocks_count(new_fs->super) -
sb->s_first_data_block -
(i * sb->s_blocks_per_group);
}
ext2fs_bg_flag_clear(rfs->new_fs, rfs->new_fs->group_desc_count - 1,
EXT2_BG_BLOCK_UNINIT);
- *new_size = rfs->new_fs->super->s_blocks_count;
+ *new_size = ext2fs_blocks_count(rfs->new_fs->super);
retval = blocks_to_move(rfs);
if (retval)
#ifdef RESIZE2FS_DEBUG
if (rfs->flags & RESIZE_DEBUG_BMOVE)
- printf("Number of free blocks: %u/%u, Needed: %d\n",
- rfs->old_fs->super->s_free_blocks_count,
- rfs->new_fs->super->s_free_blocks_count,
+ printf("Number of free blocks: %llu/%llu, Needed: %d\n",
+ ext2fs_free_blocks_count(rfs->old_fs->super),
+ ext2fs_free_blocks_count(rfs->new_fs->super),
rfs->needed_blocks);
#endif
fs->super->s_reserved_gdt_blocks;
for (i=0; i < fs->super->s_blocks_per_group; i++, blk++) {
- if (blk >= fs->super->s_blocks_count)
+ if (blk >= ext2fs_blocks_count(fs->super))
break;
if ((blk == super_blk) ||
(old_desc_blk && old_desc_blocks &&
int j;
if (gdp->bg_block_bitmap &&
- (gdp->bg_block_bitmap < fs->super->s_blocks_count)) {
+ (gdp->bg_block_bitmap < ext2fs_blocks_count(fs->super))) {
ext2fs_block_alloc_stats(fs, gdp->bg_block_bitmap, -1);
ext2fs_mark_block_bitmap2(reserve_blocks,
gdp->bg_block_bitmap);
}
if (gdp->bg_inode_bitmap &&
- (gdp->bg_inode_bitmap < fs->super->s_blocks_count)) {
+ (gdp->bg_inode_bitmap < ext2fs_blocks_count(fs->super))) {
ext2fs_block_alloc_stats(fs, gdp->bg_inode_bitmap, -1);
ext2fs_mark_block_bitmap2(reserve_blocks,
gdp->bg_inode_bitmap);
}
if (gdp->bg_inode_table == 0 ||
- (gdp->bg_inode_table >= fs->super->s_blocks_count))
+ (gdp->bg_inode_table >= ext2fs_blocks_count(fs->super)))
return;
for (blk = gdp->bg_inode_table, j = 0;
j < fs->inode_blocks_per_group; j++, blk++) {
- if (blk >= fs->super->s_blocks_count)
+ if (blk >= ext2fs_blocks_count(fs->super))
break;
ext2fs_block_alloc_stats(fs, blk, -1);
ext2fs_mark_block_bitmap2(reserve_blocks, blk);
unsigned long long new_inodes; /* u64 to check for overflow */
double percent;
- fs->super->s_blocks_count = new_size;
+ ext2fs_blocks_count_set(fs->super, new_size);
retry:
- fs->group_desc_count = ext2fs_div_ceil(fs->super->s_blocks_count -
+ fs->group_desc_count = ext2fs_div64_ceil(ext2fs_blocks_count(fs->super) -
fs->super->s_first_data_block,
EXT2_BLOCKS_PER_GROUP(fs->super));
if (fs->group_desc_count == 0)
* necessary data structures. If not, we need to get rid of
* it.
*/
- rem = (fs->super->s_blocks_count - fs->super->s_first_data_block) %
+ rem = (ext2fs_blocks_count(fs->super) - fs->super->s_first_data_block) %
fs->super->s_blocks_per_group;
if ((fs->group_desc_count == 1) && rem && (rem < overhead))
return EXT2_ET_TOOSMALL;
if (rem && (rem < overhead+50)) {
- fs->super->s_blocks_count -= rem;
+ ext2fs_blocks_count_set(fs->super,
+ ext2fs_blocks_count(fs->super) - rem);
goto retry;
}
/*
/*
* Adjust the number of free blocks
*/
- blk = old_fs->super->s_blocks_count;
- if (blk > fs->super->s_blocks_count)
- fs->super->s_free_blocks_count -=
- (blk - fs->super->s_blocks_count);
+ blk = ext2fs_blocks_count(old_fs->super);
+ if (blk > ext2fs_blocks_count(fs->super))
+ ext2fs_free_blocks_count_set(fs->super,
+ ext2fs_free_blocks_count(fs->super) -
+ (blk - ext2fs_blocks_count(fs->super)));
else
- fs->super->s_free_blocks_count +=
- (fs->super->s_blocks_count - blk);
+ ext2fs_free_blocks_count_set(fs->super,
+ ext2fs_free_blocks_count(fs->super) +
+ (ext2fs_blocks_count(fs->super) - blk));
/*
* Adjust the number of reserved blocks
*/
- percent = (old_fs->super->s_r_blocks_count * 100.0) /
- old_fs->super->s_blocks_count;
- fs->super->s_r_blocks_count = (unsigned int) (percent *
- fs->super->s_blocks_count / 100.0);
+ percent = (ext2fs_r_blocks_count(old_fs->super) * 100.0) /
+ ext2fs_blocks_count(old_fs->super);
+ ext2fs_r_blocks_count_set(fs->super,
+ (percent * ext2fs_blocks_count(fs->super) /
+ 100.0));
/*
* Adjust the bitmaps for size
real_end = ((EXT2_BLOCKS_PER_GROUP(fs->super)
* fs->group_desc_count)) - 1 +
fs->super->s_first_data_block;
- retval = ext2fs_resize_block_bitmap2(fs->super->s_blocks_count-1,
+ retval = ext2fs_resize_block_bitmap2(ext2fs_blocks_count(fs->super)-1,
real_end, fs->block_map);
if (retval) goto errout;
/*
* Fix the count of the last (old) block group
*/
- old_numblocks = (old_fs->super->s_blocks_count -
+ old_numblocks = (ext2fs_blocks_count(old_fs->super) -
old_fs->super->s_first_data_block) %
old_fs->super->s_blocks_per_group;
if (!old_numblocks)
old_numblocks = old_fs->super->s_blocks_per_group;
if (old_fs->group_desc_count == fs->group_desc_count) {
- numblocks = (fs->super->s_blocks_count -
+ numblocks = (ext2fs_blocks_count(fs->super) -
fs->super->s_first_data_block) %
fs->super->s_blocks_per_group;
if (!numblocks)
ext2fs_bg_flag_set(fs, i, EXT2_BG_INODE_UNINIT | EXT2_BG_INODE_ZEROED)
;
if (i == fs->group_desc_count-1) {
- numblocks = (fs->super->s_blocks_count -
+ numblocks = (ext2fs_blocks_count(fs->super) -
fs->super->s_first_data_block) %
fs->super->s_blocks_per_group;
if (!numblocks)
adjblocks += 2 + fs->inode_blocks_per_group;
numblocks -= adjblocks;
- fs->super->s_free_blocks_count -= adjblocks;
+ ext2fs_free_blocks_count_set(fs->super,
+ ext2fs_free_blocks_count(fs->super) - adjblocks);
fs->super->s_free_inodes_count +=
fs->super->s_inodes_per_group;
fs->group_desc[i].bg_free_blocks_count = numblocks;
fs = rfs->new_fs;
old_fs = rfs->old_fs;
- if (old_fs->super->s_blocks_count > fs->super->s_blocks_count)
+ if (ext2fs_blocks_count(old_fs->super) > ext2fs_blocks_count(fs->super))
fs = rfs->old_fs;
retval = ext2fs_allocate_block_bitmap(fs, _("blocks to be moved"),
* If we're shrinking the filesystem, we need to move all of
* the blocks that don't fit any more
*/
- for (blk = fs->super->s_blocks_count;
- blk < old_fs->super->s_blocks_count; blk++) {
+ for (blk = ext2fs_blocks_count(fs->super);
+ blk < ext2fs_blocks_count(old_fs->super); blk++) {
g = ext2fs_group_of_blk(fs, blk);
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_GDT_CSUM) &&
rfs->new_blk = rfs->new_fs->super->s_first_data_block;
#if 0
/* HACK for testing */
- if (rfs->new_fs->super->s_blocks_count >
- rfs->old_fs->super->s_blocks_count)
- rfs->new_blk = rfs->old_fs->super->s_blocks_count;
+ if (ext2fs_blocks_count(rfs->new_fs->super) >
+ ext2fs_blocks_count(rfs->old_fs->super))
+ rfs->new_blk = ext2fs_blocks_count(rfs->old_fs->super);
#endif
}
ext2_filsys fs = rfs->new_fs;
while (1) {
- if (rfs->new_blk >= fs->super->s_blocks_count) {
+ if (rfs->new_blk >= ext2fs_blocks_count(fs->super)) {
if (rfs->alloc_state == DESPERATION)
return 0;
ext2fs_test_block_bitmap2(rfs->reserve_blocks,
rfs->new_blk) ||
((rfs->alloc_state == AVOID_OLD) &&
- (rfs->new_blk < rfs->old_fs->super->s_blocks_count) &&
+ (rfs->new_blk < ext2fs_blocks_count(rfs->old_fs->super)) &&
ext2fs_test_block_bitmap2(rfs->old_fs->block_map,
rfs->new_blk))) {
rfs->new_blk++;
to_move = moved = 0;
init_block_alloc(rfs);
for (blk = old_fs->super->s_first_data_block;
- blk < old_fs->super->s_blocks_count; blk++) {
+ blk < ext2fs_blocks_count(old_fs->super); blk++) {
if (!ext2fs_test_block_bitmap2(old_fs->block_map, blk))
continue;
if (!ext2fs_test_block_bitmap2(rfs->move_blocks, blk))
* is larger. We need to do this to avoid catching an error
* by the block iterator routines
*/
- orig_size = rfs->old_fs->super->s_blocks_count;
- if (orig_size < rfs->new_fs->super->s_blocks_count)
- rfs->old_fs->super->s_blocks_count =
- rfs->new_fs->super->s_blocks_count;
+ orig_size = ext2fs_blocks_count(rfs->old_fs->super);
+ if (orig_size < ext2fs_blocks_count(rfs->new_fs->super))
+ ext2fs_blocks_count_set(rfs->old_fs->super,
+ ext2fs_blocks_count(rfs->new_fs->super));
retval = ext2fs_open_inode_scan(rfs->old_fs, 0, &scan);
if (retval) goto errout;
io_channel_flush(rfs->old_fs->io);
errout:
- rfs->old_fs->super->s_blocks_count = orig_size;
+ ext2fs_blocks_count_set(rfs->old_fs->super, orig_size);
if (rfs->bmap) {
ext2fs_free_extent_table(rfs->bmap);
rfs->bmap = 0;
old_desc_blocks = fs->desc_blocks +
fs->super->s_reserved_gdt_blocks;
for (blk = fs->super->s_first_data_block;
- blk < fs->super->s_blocks_count; blk++) {
+ blk < ext2fs_blocks_count(fs->super); blk++) {
if ((uninit &&
!((blk == super_blk) ||
((old_desc_blk && old_desc_blocks &&
}
count++;
if ((count == fs->super->s_blocks_per_group) ||
- (blk == fs->super->s_blocks_count-1)) {
+ (blk == ext2fs_blocks_count(fs->super)-1)) {
fs->group_desc[group].bg_free_blocks_count =
group_free;
ext2fs_group_desc_csum_set(fs, group);
fs->super->s_reserved_gdt_blocks;
}
}
- fs->super->s_free_blocks_count = total_free;
+ ext2fs_free_blocks_count_set(fs->super, total_free);
/*
* Next, calculate the inode statistics
}
/* calculate how many blocks are needed for data */
- data_needed = fs->super->s_blocks_count -
- fs->super->s_free_blocks_count;
+ data_needed = ext2fs_blocks_count(fs->super) -
+ ext2fs_free_blocks_count(fs->super);
data_needed -= SUPER_OVERHEAD(fs) * num_of_superblocks;
data_needed -= META_OVERHEAD(fs) * fs->group_desc_count;
* If at this point we've already added up more "needed" than
* the current size, just return current size as minimum.
*/
- if (blks_needed >= fs->super->s_blocks_count)
- return fs->super->s_blocks_count;
+ if (blks_needed >= ext2fs_blocks_count(fs->super))
+ return ext2fs_blocks_count(fs->super);
/*
* We need to reserve a few extra blocks if extents are
* enabled, in case we need to grow the extent tree. The more
* we shrink the file system, the more space we need.
*/
if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS)
- blks_needed += (fs->super->s_blocks_count - blks_needed)/500;
+ blks_needed += (ext2fs_blocks_count(fs->super) -
+ blks_needed)/500;
return blks_needed;
}
* Create a sample filesystem structure
*/
memset(¶m, 0, sizeof(struct ext2_super_block));
- param.s_blocks_count = 80000;
+ ext2fs_blocks_count_set(¶m, 80000);
param.s_inodes_count = 20000;
retval = ext2fs_initialize("/dev/null", 0, ¶m,
unix_io_manager, &test_fs);
git://git.whamcloud.com / tools / e2fsprogs.git / commitdiff