void do_init_filesys(int argc, char **argv)
{
struct ext2_super_block param;
errcode_t retval;
int err;
if (common_args_process(argc, argv, 3, 3, "initialize",
"<device> <blocksize>", CHECK_FS_NOTOPEN))
return;
memset(¶m, 0, sizeof(struct ext2_super_block));
param.s_blocks_count = parse_ulong(argv[2], argv[0],
"blocks count", &err);
if (err)
return;
retval = ext2fs_initialize(argv[1], 0, ¶m,
unix_io_manager, ¤t_fs);
if (retval) {
com_err(argv[1], retval, "while initializing filesystem");
current_fs = NULL;
return;
}
root = cwd = EXT2_ROOT_INO;
return;
}
static void setup_filesystem(const char *name,
unsigned int blocks, unsigned int inodes,
unsigned int type, int flags)
{
struct ext2_super_block param;
errcode_t retval;
memset(¶m, 0, sizeof(param));
ext2fs_blocks_count_set(¶m, blocks);
param.s_inodes_count = inodes;
retval = ext2fs_initialize("test fs", flags, ¶m,
test_io_manager, &test_fs);
if (retval) {
com_err(name, retval, "while initializing filesystem");
return;
}
test_fs->default_bitmap_type = type;
ext2fs_free_block_bitmap(test_fs->block_map);
test_fs->block_map = 0;
ext2fs_free_inode_bitmap(test_fs->inode_map);
test_fs->inode_map = 0;
retval = ext2fs_allocate_block_bitmap(test_fs, "block bitmap",
&test_fs->block_map);
if (retval) {
com_err(name, retval, "while allocating block bitmap");
goto errout;
}
retval = ext2fs_allocate_inode_bitmap(test_fs, "inode bitmap",
&test_fs->inode_map);
if (retval) {
com_err(name, retval, "while allocating inode bitmap");
goto errout;
}
return;
errout:
ext2fs_close_free(&test_fs);
}
/*
* Setup the variables for doing the inode scan test.
*/
static void setup(void)
{
errcode_t retval;
struct ext2_super_block param;
initialize_ext2_error_table();
memset(¶m, 0, sizeof(param));
ext2fs_blocks_count_set(¶m, 12000);
retval = ext2fs_initialize("test fs", EXT2_FLAG_64BITS, ¶m,
test_io_manager, &test_fs);
if (retval) {
com_err("setup", retval,
"while initializing filesystem");
exit(1);
}
retval = ext2fs_allocate_tables(test_fs);
if (retval) {
com_err("setup", retval,
"while allocating tables for test filesystem");
exit(1);
}
}
int main(int argc, char **argv)
{
int retval;
int sci_idx;
int c;
char *request = 0;
int exit_status = 0;
char *cmd_file = 0;
struct ext2_super_block param;
initialize_ext2_error_table();
/*
* Create a sample filesystem structure
*/
memset(¶m, 0, sizeof(struct ext2_super_block));
ext2fs_blocks_count_set(¶m, 80000);
param.s_inodes_count = 20000;
retval = ext2fs_initialize("/dev/null", 0, ¶m,
unix_io_manager, &test_fs);
if (retval) {
com_err("/dev/null", retval, "while setting up test fs");
exit(1);
}
while ((c = getopt (argc, argv, "wR:f:")) != EOF) {
switch (c) {
case 'R':
request = optarg;
break;
case 'f':
cmd_file = optarg;
break;
default:
com_err(argv[0], 0, "Usage: test_icount "
"[-R request] [-f cmd_file]");
exit(1);
}
}
sci_idx = ss_create_invocation("test_icount", "0.0", (char *) NULL,
&test_cmds, &retval);
if (retval) {
ss_perror(sci_idx, retval, "creating invocation");
exit(1);
}
(void) ss_add_request_table (sci_idx, &ss_std_requests, 1, &retval);
if (retval) {
ss_perror(sci_idx, retval, "adding standard requests");
exit (1);
}
if (request) {
retval = 0;
retval = ss_execute_line(sci_idx, request);
if (retval) {
ss_perror(sci_idx, retval, request);
exit_status++;
}
} else if (cmd_file) {
exit_status = source_file(cmd_file, sci_idx);
} else {
ss_listen(sci_idx);
}
return(exit_status);
}
int main(int argc, char *argv[])
{
ext2_filsys fs;
struct ext2_super_block param;
errcode_t retval;
int i;
/* setup */
initialize_ext2_error_table();
memset(¶m, 0, sizeof(param));
ext2fs_blocks_count_set(¶m, 32768);
param.s_inodes_count = 100;
param.s_feature_incompat |= EXT4_FEATURE_INCOMPAT_INLINE_DATA;
param.s_rev_level = EXT2_DYNAMIC_REV;
param.s_inode_size = 256;
retval = ext2fs_initialize("test fs", EXT2_FLAG_64BITS, ¶m,
test_io_manager, &fs);
if (retval) {
com_err("setup", retval,
"while initializing filesystem");
exit(1);
}
retval = ext2fs_allocate_tables(fs);
if (retval) {
com_err("setup", retval,
"while allocating tables for test filesysmte");
exit(1);
}
/* initialize inode cache */
if (!fs->icache) {
struct ext2_inode inode;
ext2_ino_t first_ino = EXT2_FIRST_INO(fs->super);
int i;
/* we just want to init inode cache. So ignore error */
ext2fs_create_inode_cache(fs, 16);
if (!fs->icache) {
fprintf(stderr,
"tst_inline_data: init inode cache failed\n");
exit(1);
}
/* setup inode cache */
for (i = 0; i < fs->icache->cache_size; i++)
fs->icache->cache[i].ino = first_ino++;
}
/* test */
if (file_test(fs)) {
fprintf(stderr, "tst_inline_data(FILE): FAILED\n");
return 1;
}
printf("tst_inline_data(FILE): OK\n");
if (dir_test(fs)) {
fprintf(stderr, "tst_inline_data(DIR): FAILED\n");
return 1;
}
printf("tst_inline_data(DIR): OK\n");
return 0;
}
int main(int argc, char **argv)
{
struct ext2_super_block param;
errcode_t retval;
ext2_filsys fs;
int i;
__u16 csum1, csum2, csum_known = 0xd3a4;
memset(¶m, 0, sizeof(param));
param.s_blocks_count = 32768;
retval = ext2fs_initialize("test fs", 0, ¶m,
test_io_manager, &fs);
if (retval) {
com_err("setup", retval,
"While initializing filesystem");
exit(1);
}
memcpy(fs->super->s_uuid, sb_uuid, 16);
fs->super->s_feature_ro_compat = EXT4_FEATURE_RO_COMPAT_GDT_CSUM;
for (i=0; i < fs->group_desc_count; i++) {
fs->group_desc[i].bg_block_bitmap = 124;
fs->group_desc[i].bg_inode_bitmap = 125;
fs->group_desc[i].bg_inode_table = 126;
fs->group_desc[i].bg_free_blocks_count = 31119;
fs->group_desc[i].bg_free_inodes_count = 15701;
fs->group_desc[i].bg_used_dirs_count = 2;
fs->group_desc[i].bg_flags = 0;
};
csum1 = ext2fs_group_desc_csum(fs, 0);
print_csum("csum0000", fs, 0);
if (csum1 != csum_known) {
printf("checksum for group 0 should be %04x\n", csum_known);
exit(1);
}
csum2 = ext2fs_group_desc_csum(fs, 1);
print_csum("csum0001", fs, 1);
if (csum1 == csum2) {
printf("checksums for different groups shouldn't match\n");
exit(1);
}
csum2 = ext2fs_group_desc_csum(fs, 2);
print_csum("csumffff", fs, 2);
if (csum1 == csum2) {
printf("checksums for different groups shouldn't match\n");
exit(1);
}
fs->group_desc[0].bg_checksum = csum1;
csum2 = ext2fs_group_desc_csum(fs, 0);
print_csum("csum_set", fs, 0);
if (csum1 != csum2) {
printf("checksums should not depend on checksum field\n");
exit(1);
}
if (!ext2fs_group_desc_csum_verify(fs, 0)) {
printf("checksums should verify against gd_checksum\n");
exit(1);
}
memset(fs->super->s_uuid, 0x30, sizeof(fs->super->s_uuid));
print_csum("new_uuid", fs, 0);
if (ext2fs_group_desc_csum_verify(fs, 0) != 0) {
printf("checksums for different filesystems shouldn't match\n");
exit(1);
}
csum1 = fs->group_desc[0].bg_checksum = ext2fs_group_desc_csum(fs, 0);
print_csum("csum_new", fs, 0);
fs->group_desc[0].bg_free_blocks_count = 1;
csum2 = ext2fs_group_desc_csum(fs, 0);
print_csum("csum_blk", fs, 0);
if (csum1 == csum2) {
printf("checksums for different data shouldn't match\n");
exit(1);
}
return 0;
}
/*
* Setup the variables for doing the inode scan test.
*/
static void setup(void)
{
errcode_t retval;
int i;
struct ext2_super_block param;
initialize_ext2_error_table();
memset(¶m, 0, sizeof(param));
param.s_blocks_count = 12000;
test_io_cb_read_blk = test_read_blk;
retval = ext2fs_initialize("test fs", 0, ¶m,
test_io_manager, &test_fs);
if (retval) {
com_err("setup", retval,
"While initializing filesystem");
exit(1);
}
retval = ext2fs_allocate_tables(test_fs);
if (retval) {
com_err("setup", retval,
"While allocating tables for test filesystem");
exit(1);
}
retval = ext2fs_allocate_block_bitmap(test_fs, "bad block map",
&bad_block_map);
if (retval) {
com_err("setup", retval,
"While allocating bad_block bitmap");
exit(1);
}
retval = ext2fs_allocate_block_bitmap(test_fs, "touched map",
&touched_map);
if (retval) {
com_err("setup", retval,
"While allocating touched block bitmap");
exit(1);
}
retval = ext2fs_allocate_inode_bitmap(test_fs, "bad inode map",
&bad_inode_map);
if (retval) {
com_err("setup", retval,
"While allocating bad inode bitmap");
exit(1);
}
retval = ext2fs_badblocks_list_create(&test_badblocks, 5);
if (retval) {
com_err("setup", retval, "while creating badblocks list");
exit(1);
}
for (i=0; test_vec[i]; i++) {
retval = ext2fs_badblocks_list_add(test_badblocks, test_vec[i]);
if (retval) {
com_err("setup", retval,
"while adding test vector %d", i);
exit(1);
}
ext2fs_mark_block_bitmap(bad_block_map, test_vec[i]);
}
test_fs->badblocks = test_badblocks;
}
