From: Andreas Dilger Date: Tue, 20 Mar 2012 03:54:03 +0000 (-0400) Subject: tests: add field sizes to inode/super struct tests X-Git-Tag: v1.42.2~23 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=963d0f1a9458396c18d0aa030601f29cc1e25f30;p=thirdparty%2Fe2fsprogs.git tests: add field sizes to inode/super struct tests In addition to validating the ordering of fields within the inode and superblock structures, also validate the field sizes. Otherwise it is possible to incorrectly change the size of one of these fields without getting any kind of error from these tests. Failures would only show up later in the test image checks if the field that is changed is before another in-use field. Signed-off-by: Andreas Dilger Signed-off-by: Theodore Ts'o --- diff --git a/lib/ext2fs/tst_inode_size.c b/lib/ext2fs/tst_inode_size.c index 86e3227eb..3e43d9f42 100644 --- a/lib/ext2fs/tst_inode_size.c +++ b/lib/ext2fs/tst_inode_size.c @@ -16,67 +16,70 @@ #include "ext2_fs.h" -struct ext2_inode inode; +struct ext2_inode_large inode; -int verbose = 0; +#define offsetof(type, member) __builtin_offsetof(type, member) +#define check_field(x, s) cur_offset = do_field(#x, s, sizeof(inode.x), \ + offsetof(struct ext2_inode_large, x), \ + cur_offset) -#define offsetof(type, member) __builtin_offsetof (type, member) -#define check_field(x) cur_offset = do_field(#x, sizeof(inode.x), \ - offsetof(struct ext2_inode, x), \ - cur_offset) - -static int do_field(const char *field, size_t size, int offset, int cur_offset) +static int do_field(const char *field, unsigned size, unsigned cur_size, + unsigned offset, unsigned cur_offset) { + if (size != cur_size) { + printf("error: %s size %u should be %u\n", + field, cur_size, size); + exit(1); + } if (offset != cur_offset) { - printf("Warning! Unexpected offset at %s\n", field); + printf("error: %s offset %u should be %u\n", + field, cur_offset, offset); exit(1); } printf("%8d %-30s %3u\n", offset, field, (unsigned) size); return offset + size; } -void check_structure_fields() +int main(int argc, char **argv) { #if (__GNUC__ >= 4) int cur_offset = 0; printf("%8s %-30s %3s\n", "offset", "field", "size"); - check_field(i_mode); - check_field(i_uid); - check_field(i_size); - check_field(i_atime); - check_field(i_ctime); - check_field(i_mtime); - check_field(i_dtime); - check_field(i_gid); - check_field(i_links_count); - check_field(i_blocks); - check_field(i_flags); - check_field(osd1.linux1.l_i_version); - check_field(i_block); - check_field(i_generation); - check_field(i_file_acl); - check_field(i_size_high); - check_field(i_faddr); - check_field(osd2.linux2.l_i_blocks_hi); - check_field(osd2.linux2.l_i_file_acl_high); - check_field(osd2.linux2.l_i_uid_high); - check_field(osd2.linux2.l_i_gid_high); - check_field(osd2.linux2.l_i_checksum_lo); - check_field(osd2.linux2.l_i_reserved); - printf("Ending offset is %d\n\n", cur_offset); + check_field(i_mode, 2); + check_field(i_uid, 2); + check_field(i_size, 4); + check_field(i_atime, 4); + check_field(i_ctime, 4); + check_field(i_mtime, 4); + check_field(i_dtime, 4); + check_field(i_gid, 2); + check_field(i_links_count, 2); + check_field(i_blocks, 4); + check_field(i_flags, 4); + check_field(osd1.linux1.l_i_version, 4); + check_field(i_block, 15 * 4); + check_field(i_generation, 4); + check_field(i_file_acl, 4); + check_field(i_size_high, 4); + check_field(i_faddr, 4); + check_field(osd2.linux2.l_i_blocks_hi, 2); + check_field(osd2.linux2.l_i_file_acl_high, 2); + check_field(osd2.linux2.l_i_uid_high, 2); + check_field(osd2.linux2.l_i_gid_high, 2); + check_field(osd2.linux2.l_i_checksum_lo, 2); + check_field(osd2.linux2.l_i_reserved, 2); + do_field("Small inode end", 0, 0, cur_offset, 128); + check_field(i_extra_isize, 2); + check_field(i_checksum_hi, 2); + check_field(i_ctime_extra, 4); + check_field(i_mtime_extra, 4); + check_field(i_atime_extra, 4); + check_field(i_crtime, 4); + check_field(i_crtime_extra, 4); + check_field(i_version_hi, 4); + /* This size will change as new fields are added */ + do_field("Large inode end", 0, 0, cur_offset, sizeof(inode)); #endif -} - - -int main(int argc, char **argv) -{ - int l = sizeof(struct ext2_inode); - - check_structure_fields(); - printf("Size of struct ext2_inode is %d\n", l); - if (l != 128) { - exit(1); - } - exit(0); + return 0; } diff --git a/lib/ext2fs/tst_super_size.c b/lib/ext2fs/tst_super_size.c index 659365201..76e6e6fe9 100644 --- a/lib/ext2fs/tst_super_size.c +++ b/lib/ext2fs/tst_super_size.c @@ -21,127 +21,120 @@ struct sb_struct sb; -int verbose = 0; - #define offsetof(type, member) __builtin_offsetof (type, member) -#define check_field(x) cur_offset = do_field(#x, sizeof(sb.x), \ - offsetof(struct sb_struct, x), \ - cur_offset) +#define check_field(x, s) cur_offset = do_field(#x, s, sizeof(sb.x), \ + offsetof(struct sb_struct, x), \ + cur_offset) -static int do_field(const char *field, size_t size, int offset, int cur_offset) +static int do_field(const char *field, unsigned size, unsigned cur_size, + unsigned offset, unsigned cur_offset) { + if (size != cur_size) { + printf("error: %s size %u should be %u\n", + field, cur_size, size); + exit(1); + } if (offset != cur_offset) { - printf("Warning! Unexpected offset at %s\n", field); + printf("error: %s offset %u should be %u\n", + field, cur_offset, offset); exit(1); } - printf("%8d %-30s %3u\n", offset, field, (unsigned) size); + printf("%8d %-30s %3u\n", offset, field, size); return offset + size; } -void check_superblock_fields() +int main(int argc, char **argv) { #if (__GNUC__ >= 4) int cur_offset = 0; printf("%8s %-30s %3s\n", "offset", "field", "size"); - check_field(s_inodes_count); - check_field(s_blocks_count); - check_field(s_r_blocks_count); - check_field(s_free_blocks_count); - check_field(s_free_inodes_count); - check_field(s_first_data_block); - check_field(s_log_block_size); - check_field(s_log_cluster_size); - check_field(s_blocks_per_group); - check_field(s_clusters_per_group); - check_field(s_inodes_per_group); - check_field(s_mtime); - check_field(s_wtime); - check_field(s_mnt_count); - check_field(s_max_mnt_count); - check_field(s_magic); - check_field(s_state); - check_field(s_errors); - check_field(s_minor_rev_level); - check_field(s_lastcheck); - check_field(s_checkinterval); - check_field(s_creator_os); - check_field(s_rev_level); - check_field(s_def_resuid); - check_field(s_def_resgid); - check_field(s_first_ino); - check_field(s_inode_size); - check_field(s_block_group_nr); - check_field(s_feature_compat); - check_field(s_feature_incompat); - check_field(s_feature_ro_compat); - check_field(s_uuid); - check_field(s_volume_name); - check_field(s_last_mounted); - check_field(s_algorithm_usage_bitmap); - check_field(s_prealloc_blocks); - check_field(s_prealloc_dir_blocks); - check_field(s_reserved_gdt_blocks); - check_field(s_journal_uuid); - check_field(s_journal_inum); - check_field(s_journal_dev); - check_field(s_last_orphan); - check_field(s_hash_seed); - check_field(s_def_hash_version); - check_field(s_jnl_backup_type); - check_field(s_desc_size); - check_field(s_default_mount_opts); - check_field(s_first_meta_bg); - check_field(s_mkfs_time); - check_field(s_jnl_blocks); - check_field(s_blocks_count_hi); - check_field(s_r_blocks_count_hi); - check_field(s_free_blocks_hi); - check_field(s_min_extra_isize); - check_field(s_want_extra_isize); - check_field(s_flags); - check_field(s_raid_stride); - check_field(s_mmp_update_interval); - check_field(s_mmp_block); - check_field(s_raid_stripe_width); - check_field(s_log_groups_per_flex); - check_field(s_reserved_char_pad); - check_field(s_reserved_pad); - check_field(s_kbytes_written); - check_field(s_snapshot_inum); - check_field(s_snapshot_id); - check_field(s_snapshot_r_blocks_count); - check_field(s_snapshot_list); - check_field(s_error_count); - check_field(s_first_error_time); - check_field(s_first_error_ino); - check_field(s_first_error_block); - check_field(s_first_error_func); - check_field(s_first_error_line); - check_field(s_last_error_time); - check_field(s_last_error_ino); - check_field(s_last_error_line); - check_field(s_last_error_block); - check_field(s_last_error_func); - check_field(s_mount_opts); - check_field(s_usr_quota_inum); - check_field(s_grp_quota_inum); - check_field(s_overhead_blocks); - check_field(s_reserved); - check_field(s_checksum); - printf("Ending offset is %d\n\n", cur_offset); + check_field(s_inodes_count, 4); + check_field(s_blocks_count, 4); + check_field(s_r_blocks_count, 4); + check_field(s_free_blocks_count, 4); + check_field(s_free_inodes_count, 4); + check_field(s_first_data_block, 4); + check_field(s_log_block_size, 4); + check_field(s_log_cluster_size, 4); + check_field(s_blocks_per_group, 4); + check_field(s_clusters_per_group, 4); + check_field(s_inodes_per_group, 4); + check_field(s_mtime, 4); + check_field(s_wtime, 4); + check_field(s_mnt_count, 2); + check_field(s_max_mnt_count, 2); + check_field(s_magic, 2); + check_field(s_state, 2); + check_field(s_errors, 2); + check_field(s_minor_rev_level, 2); + check_field(s_lastcheck, 4); + check_field(s_checkinterval, 4); + check_field(s_creator_os, 4); + check_field(s_rev_level, 4); + check_field(s_def_resuid, 2); + check_field(s_def_resgid, 2); + check_field(s_first_ino, 4); + check_field(s_inode_size, 2); + check_field(s_block_group_nr, 2); + check_field(s_feature_compat, 4); + check_field(s_feature_incompat, 4); + check_field(s_feature_ro_compat, 4); + check_field(s_uuid, 16); + check_field(s_volume_name, 16); + check_field(s_last_mounted, 64); + check_field(s_algorithm_usage_bitmap, 4); + check_field(s_prealloc_blocks, 1); + check_field(s_prealloc_dir_blocks, 1); + check_field(s_reserved_gdt_blocks, 2); + check_field(s_journal_uuid, 16); + check_field(s_journal_inum, 4); + check_field(s_journal_dev, 4); + check_field(s_last_orphan, 4); + check_field(s_hash_seed, 4 * 4); + check_field(s_def_hash_version, 1); + check_field(s_jnl_backup_type, 1); + check_field(s_desc_size, 2); + check_field(s_default_mount_opts, 4); + check_field(s_first_meta_bg, 4); + check_field(s_mkfs_time, 4); + check_field(s_jnl_blocks, 17 * 4); + check_field(s_blocks_count_hi, 4); + check_field(s_r_blocks_count_hi, 4); + check_field(s_free_blocks_hi, 4); + check_field(s_min_extra_isize, 2); + check_field(s_want_extra_isize, 2); + check_field(s_flags, 4); + check_field(s_raid_stride, 2); + check_field(s_mmp_update_interval, 2); + check_field(s_mmp_block, 8); + check_field(s_raid_stripe_width, 4); + check_field(s_log_groups_per_flex, 1); + check_field(s_reserved_char_pad, 1); + check_field(s_reserved_pad, 2); + check_field(s_kbytes_written, 8); + check_field(s_snapshot_inum, 4); + check_field(s_snapshot_id, 4); + check_field(s_snapshot_r_blocks_count, 8); + check_field(s_snapshot_list, 4); + check_field(s_error_count, 4); + check_field(s_first_error_time, 4); + check_field(s_first_error_ino, 4); + check_field(s_first_error_block, 8); + check_field(s_first_error_func, 32); + check_field(s_first_error_line, 4); + check_field(s_last_error_time, 4); + check_field(s_last_error_ino, 4); + check_field(s_last_error_line, 4); + check_field(s_last_error_block, 8); + check_field(s_last_error_func, 32); + check_field(s_mount_opts, 64); + check_field(s_usr_quota_inum, 4); + check_field(s_grp_quota_inum, 4); + check_field(s_overhead_blocks, 4); + check_field(s_reserved, 108 * 4); + check_field(s_checksum, 4); + do_field("Superblock end", 0, 0, cur_offset, 1024); #endif -} - - -int main(int argc, char **argv) -{ - int s = sizeof(struct sb_struct); - - check_superblock_fields(); - printf("Size of struct %s is %d\n", sb_struct_name, s); - if (s != 1024) { - exit(1); - } - exit(0); + return 0; }