| /* |
| * Copyright 2000-2004 by Hans Reiser, licensing governed by |
| * reiserfsprogs/README |
| */ |
| |
| #include "debugreiserfs.h" |
| #include <time.h> |
| |
| extern struct reiserfs_fsstat g_stat_info; |
| |
| int do_one_ih_corrupt(struct item_head *ih, unsigned int nr_bytes); |
| int do_one_ih_random_corrupt(struct item_head *ih); |
| |
| void do_one_corruption_in_one_block(reiserfs_filsys_t fs, |
| struct buffer_head *bh, |
| char *corruption_command); |
| int corrupt_block_header(struct block_head *blkh, unsigned int offset, |
| unsigned int bytes); |
| void do_one_block_random_corrupt(struct buffer_head *bh); |
| |
| static int str2int(char *str, int *res) |
| { |
| int val; |
| char *tmp; |
| |
| val = (int)strtol(str, &tmp, 0); |
| if (tmp == str) |
| /* could not convert string into a number */ |
| return 0; |
| *res = val; |
| return 1; |
| } |
| |
| static int get_rand(double min, double max) |
| { |
| |
| /* srand (time (0)); */ |
| int ret; |
| |
| ret = (int)(min + (int)((max - min + 1) * rand() / (RAND_MAX + 1.0))); |
| if ((ret < min) || (ret > max)) |
| die("get_rand failed: min %d, max %d, returned %d\n", (int)min, |
| (int)max, ret); |
| |
| return ret; |
| } |
| |
| static void edit_journal_params(struct journal_params *jp) |
| { |
| char *str; |
| size_t n; |
| int num; |
| |
| printf("Journal parameters:\n"); |
| printf("\tDevice: current: %x: new:", get_jp_journal_dev(jp)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_jp_journal_dev(jp, num); |
| |
| printf("\tFirst block: current: %d: new:", |
| get_jp_journal_1st_block(jp)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_jp_journal_1st_block(jp, num); |
| |
| printf("\tSize: current: %d: new:", get_jp_journal_size(jp)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_jp_journal_size(jp, num); |
| |
| printf("\tMagic number: current: %d: new:", get_jp_journal_magic(jp)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_jp_journal_magic(jp, num); |
| |
| printf("\tMax transaction size: current: %d: new:", |
| get_jp_journal_max_trans_len(jp)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_jp_journal_max_trans_len(jp, num); |
| |
| printf("\tMax batch size: current: %d: new:", |
| get_jp_journal_max_batch(jp)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_jp_journal_max_batch(jp, num); |
| |
| printf("\tMax commit age: current: %d: new:", |
| get_jp_journal_max_commit_age(jp)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_jp_journal_max_commit_age(jp, num); |
| } |
| |
| /* this allows to edit all super block fields */ |
| static void edit_super_block(reiserfs_filsys_t fs) |
| { |
| char *str; |
| size_t n; |
| int num; |
| |
| str = NULL; |
| n = 0; |
| |
| /* bs_block_count */ |
| printf("\tBlock count: current: %u: new:", |
| get_sb_block_count(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_block_count(fs->fs_ondisk_sb, num); |
| |
| /* sb_free_blocks */ |
| printf("\tFree block count: current: %u: new:", |
| get_sb_free_blocks(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_free_blocks(fs->fs_ondisk_sb, num); |
| |
| /* sb_root_block */ |
| printf("\tRoot block: current: %u: new:", |
| get_sb_root_block(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_root_block(fs->fs_ondisk_sb, num); |
| |
| /* sb_journal */ |
| edit_journal_params(sb_jp(fs->fs_ondisk_sb)); |
| |
| /* sb_blocksize */ |
| printf("\tBlocksize: current: %u: new:", |
| get_sb_block_size(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_block_size(fs->fs_ondisk_sb, num); |
| |
| /* sb_oid_maxsize */ |
| printf("\tMax objectid size: current: %u: new:", |
| get_sb_oid_maxsize(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_oid_maxsize(fs->fs_ondisk_sb, num); |
| |
| /* sb_oid_cursize */ |
| printf("\tCur objectid size: current: %u: new:", |
| get_sb_oid_cursize(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_oid_cursize(fs->fs_ondisk_sb, num); |
| |
| /* sb_state */ |
| printf("\tUmount state: current: %u: new:", |
| get_sb_umount_state(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_umount_state(fs->fs_ondisk_sb, num); |
| |
| /* char s_magic [10]; */ |
| printf("\tMagic: current: \"%s\": new:", |
| fs->fs_ondisk_sb->s_v1.s_magic); |
| getline(&str, &n, stdin); |
| if (strcmp(str, "\n")) |
| strncpy(fs->fs_ondisk_sb->s_v1.s_magic, str, n > 10 ? 10 : n); |
| |
| /* __u16 sb_fsck_state; */ |
| printf("\tFilesystem state: current: %u: new:", |
| get_sb_fs_state(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_fs_state(fs->fs_ondisk_sb, num); |
| |
| /* __u32 sb_hash_function_code; */ |
| printf("\tHash code: current: %u: new (tea %d, r5 %d, rupasov %d):", |
| get_sb_hash_code(fs->fs_ondisk_sb), TEA_HASH, R5_HASH, |
| YURA_HASH); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_hash_code(fs->fs_ondisk_sb, num); |
| |
| /* __u16 sb_tree_height; */ |
| printf("\tTree height: current: %u: new:", |
| get_sb_tree_height(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_tree_height(fs->fs_ondisk_sb, num); |
| |
| /* __u16 sb_bmap_nr; */ |
| printf("\tNumber of bitmaps: current: %u: new:", |
| get_sb_bmap_nr(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_bmap_nr(fs->fs_ondisk_sb, num); |
| |
| /* __u16 sb_version; */ |
| printf("\tFilesystem format: current: %u: new:", |
| le16_to_cpu(fs->fs_ondisk_sb->s_v1.sb_version)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_version(fs->fs_ondisk_sb, num); |
| |
| /* __u16 sb_reserved_for_journal; */ |
| printf("\tSpace reserved for journal: current: %u: new:", |
| get_sb_reserved_for_journal(fs->fs_ondisk_sb)); |
| getline(&str, &n, stdin); |
| if (str2int(str, &num)) |
| set_sb_reserved_for_journal(fs->fs_ondisk_sb, num); |
| |
| print_block(stdout, fs, fs->fs_super_bh); |
| if (user_confirmed(stderr, "Is this ok ? [N/Yes]: ", "Yes\n")) { |
| mark_buffer_dirty(fs->fs_super_bh); |
| bwrite(fs->fs_super_bh); |
| } |
| } |
| |
| static void corrupt_clobber_hash(char *name, struct item_head *ih, |
| struct reiserfs_de_head *deh) |
| { |
| printf("\tCorrupting deh_offset of entry \"%s\" of [%u %u]\n", name, |
| get_key_dirid(&ih->ih_key), get_key_objectid(&ih->ih_key)); |
| set_deh_offset(deh, 700); |
| } |
| |
| /* this reads list of desired corruptions from stdin and perform the |
| corruptions. Format of that list: |
| A hash_code |
| C name objectid - 'C'ut entry 'name' from directory item with 'objectid' |
| H name objectid - clobber 'H'hash of entry 'name' of directory 'objectid' |
| I item_num pos_in_item make pos_in_item-th slot of indirect item to point out of device |
| O item_num - destroy item 'O'rder - make 'item_num'-th to have key bigger than 'item_num' + 1-th item |
| D item_num - 'D'elete item_num-th item |
| S item_num value - change file size (item_num-th item must be stat data) |
| F item_num value - change sd_first_direct_byte of stat data |
| J item_num objectid |
| E name objectid new - change entry's deh_objectid to new |
| P - print the block |
| B offset bytes_to_corrupt - corrupt bytes_to_corrupt bytes in block header, |
| start from offset |
| */ |
| |
| void do_corrupt_one_block(reiserfs_filsys_t fs, char *fline) |
| { |
| struct buffer_head *bh; |
| char *line = NULL; |
| size_t n = 0; |
| unsigned long block; |
| |
| block = certain_block(fs); |
| printf("block = %lu\n", block); |
| if (block == fs->fs_super_bh->b_blocknr) { |
| edit_super_block(fs); |
| return; |
| } |
| |
| if (!fs->fs_bitmap2) { |
| struct buffer_head *bm_bh; |
| unsigned long bm_block; |
| |
| if (spread_bitmaps(fs)) |
| bm_block = (block / (fs->fs_blocksize * 8)) ? |
| (block / (fs->fs_blocksize * 8)) * |
| (fs->fs_blocksize * |
| 8) : fs->fs_super_bh->b_blocknr + 1; |
| else |
| bm_block = |
| fs->fs_super_bh->b_blocknr + 1 + |
| (block / (fs->fs_blocksize * 8)); |
| |
| bm_bh = bread(fs->fs_dev, bm_block, fs->fs_blocksize); |
| if (bm_bh) { |
| if (misc_test_bit |
| ((block % (fs->fs_blocksize * 8)), bm_bh->b_data)) |
| fprintf(stderr, |
| "%lu is used in ondisk bitmap\n", |
| block); |
| else |
| fprintf(stderr, |
| "%lu is free in ondisk bitmap\n", |
| block); |
| |
| brelse(bm_bh); |
| } |
| } else { |
| if (reiserfs_bitmap_test_bit(fs->fs_bitmap2, block)) |
| fprintf(stderr, "%lu is used in ondisk bitmap\n", |
| block); |
| else |
| fprintf(stderr, "%lu is free in ondisk bitmap\n", |
| block); |
| } |
| |
| /* READ block */ |
| bh = bread(fs->fs_dev, block, fs->fs_blocksize); |
| if (!bh) { |
| printf("corrupt_one_block: bread fialed\n"); |
| return; |
| } |
| |
| if (who_is_this(bh->b_data, fs->fs_blocksize) != THE_LEAF) { |
| printf("Can not corrupt not a leaf node\n"); |
| brelse(bh); |
| return; |
| } |
| |
| printf("Corrupting block %lu..\n", bh->b_blocknr); |
| |
| if (data(fs)->log_file_name) { |
| printf("Log file : %s\n", data(fs)->log_file_name); |
| } else { |
| printf("No Log file specified\n"); |
| } |
| |
| if (fline != NULL) { |
| do_one_corruption_in_one_block(fs, bh, fline); |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, "%lu\n", block); |
| fprintf(data(fs)->log, "%s\n", fline); |
| } |
| } else { |
| /* Get list of corruptions from stdin */ |
| while (getline(&line, &n, stdin) != -1) { |
| if (line[0] == '\n') { |
| free(line); |
| line = NULL; |
| n = 0; |
| break; |
| } |
| do_one_corruption_in_one_block(fs, bh, line); |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, "%lu\n", block); |
| fprintf(data(fs)->log, "%s\n", line); |
| } |
| |
| free(line); |
| line = NULL; |
| n = 0; |
| } |
| } |
| |
| printf("Done\n"); |
| bwrite(bh); |
| brelse(bh); |
| return; |
| } |
| |
| void do_one_corruption_in_one_block(reiserfs_filsys_t fs, |
| struct buffer_head *bh, |
| char *corruption_command) |
| { |
| int i, j; |
| struct item_head *ih; |
| int item_num; |
| int item_numbers; |
| int bytes_to_corrupt; |
| char code, name[100]; |
| __u32 objectid, new_objectid; |
| int value; |
| int hash_code; |
| unsigned int pos_in_item; |
| int type, format; |
| |
| printf("corruption_command : %s", corruption_command); |
| |
| switch (corruption_command[0]) { |
| case '#': |
| case '\n': |
| break; |
| |
| case '?': |
| printf("A hash_code - reset hAsh code in super block\n" |
| "T item_num type (0, 1, 2, 3) format (0, 1)\n" |
| "C name objectid - Cut entry 'name' from directory item with 'objectid'\n" |
| "H name objectid - clobber Hash of entry 'name' of directory 'objectid'\n" |
| "I item_num pos_in_item make pos_in_tem-th slot of Indirect item to point out of device\n" |
| "O item_num - destroy item Order - make 'item_num'-th to have key bigger than 'item_num' + 1-th item\n" |
| "D item_num - Delete item_num-th item\n" |
| "S item_num value - change file Size (item_num-th item must be stat data)\n" |
| "F item_num value - change sd_First_direct_byte of stat data\n" |
| "J item_num objectid - set 'obJectid' of 'item_num'-th item\n" |
| "E name objectid objectid - set deh_objectid of an entry to objectid\n" |
| "N item_numbers bytes_to_corrupt - corrupt bytes_to_corrupt in number of bytes in item_numbers items\n" |
| "B offset bytes_to_corrupt - corrupt bytes_to_corrupt in block_header, start corruption from offset\n"); |
| |
| break; |
| |
| case 'P': |
| print_block(stderr, fs, bh, 3, -1, -1); |
| break; |
| |
| case 'A': |
| /* corrupt hash record in super block */ |
| if (sscanf(corruption_command, "%c %d\n", &code, &hash_code) != |
| 2) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| reiserfs_warning(stderr, "Changing %s to %s\n", |
| code2name(get_sb_hash_code(fs->fs_ondisk_sb)), |
| code2name(hash_code)); |
| set_sb_hash_code(fs->fs_ondisk_sb, hash_code); |
| break; |
| |
| case 'C': /* cut entry */ |
| case 'H': /* make hash wrong */ |
| if (sscanf |
| (corruption_command, "%c %s %u\n", &code, name, |
| &objectid) != 3) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| |
| ih = item_head(bh, 0); |
| for (i = 0; i < get_blkh_nr_items(B_BLK_HEAD(bh)); i++, ih++) { |
| struct reiserfs_de_head *deh; |
| /* look for property objectid */ |
| if (get_key_objectid(&ih->ih_key) != objectid |
| || !is_direntry_ih(ih)) |
| continue; |
| |
| deh = B_I_DEH(bh, ih); |
| |
| for (j = 0; j < get_ih_entry_count(ih); j++, deh++) { |
| /* look for proper entry */ |
| if (name_in_entry_length(ih, deh, j) == |
| (int)strlen(name) |
| && !strncmp(name, name_in_entry(deh, j), |
| strlen(name))) |
| break; |
| } |
| if (j == get_ih_entry_count(ih)) { |
| printf("Can't find entry %s\n", name); |
| exit(1); |
| } |
| switch (code) { |
| case 'H': /* clobber hash */ |
| corrupt_clobber_hash(name, ih, deh); |
| break; |
| |
| case 'C': /* cut entry */ |
| cut_entry(fs, bh, i, j, 1); |
| break; |
| |
| default: |
| printf("Unknown command found\n"); |
| } |
| } |
| |
| if (!B_IS_IN_TREE(bh)) { |
| printf("NOTE: block is deleted from the tree\n"); |
| exit(0); |
| } |
| break; |
| |
| case 'E': /* set objectid : used to simulate objectid sharing problem */ |
| if (sscanf |
| (corruption_command, "%c %s %u %d\n", &code, name, |
| &objectid, &new_objectid) != 4) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| ih = item_head(bh, 0); |
| for (i = 0; i < get_blkh_nr_items(B_BLK_HEAD(bh)); i++, ih++) { |
| struct reiserfs_de_head *deh; |
| /* look for property objectid */ |
| if (get_key_objectid(&ih->ih_key) != objectid |
| || !is_direntry_ih(ih)) |
| continue; |
| deh = B_I_DEH(bh, ih); |
| set_deh_objectid(deh, new_objectid); |
| break; |
| } |
| break; |
| |
| case 'T': /* set type of item */ |
| if (sscanf |
| (corruption_command, "%c %d %d %d\n", &code, &item_num, |
| &type, &format) != 4) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) { |
| printf("Wrong format \'%c\', wrong item_num \n", |
| corruption_command[0]); |
| return; |
| } |
| |
| ih = item_head(bh, item_num); |
| set_ih_key_format(ih, format); |
| set_type(format, &ih->ih_key, type); |
| |
| break; |
| |
| case 'J': /* set objectid : used to simulate objectid sharing problem */ |
| if (sscanf |
| (corruption_command, "%c %d %d\n", &code, &item_num, |
| &objectid) != 3) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) { |
| printf("Wrong format \'%c\', wrong item_num \n", |
| corruption_command[0]); |
| return; |
| } |
| ih = item_head(bh, item_num); |
| set_key_objectid(&ih->ih_key, objectid); |
| break; |
| |
| case 'I': /* break unformatted node pointer */ |
| if (sscanf |
| (corruption_command, "%c %d %u\n", &code, &item_num, |
| &pos_in_item) != 3) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) { |
| printf("Wrong format \'%c\', wrong item_num \n", |
| corruption_command[0]); |
| return; |
| } |
| ih = item_head(bh, item_num); |
| if (!is_indirect_ih(ih) || pos_in_item >= I_UNFM_NUM(ih)) { |
| reiserfs_warning(stderr, |
| "Not an indirect item or there is " |
| "not so many unfm ptrs in it\n"); |
| return; |
| } |
| d32_put((__le32 *) ih_item_body(bh, ih), pos_in_item, |
| get_sb_block_count(fs->fs_ondisk_sb) + 100); |
| break; |
| |
| case 'D': /* delete item */ |
| if (sscanf(corruption_command, "%c %d\n", &code, &item_num) != |
| 2) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) { |
| printf("Wrong format \'%c\', wrong item_num \n", |
| corruption_command[0]); |
| return; |
| } |
| delete_item(fs, bh, item_num); |
| break; |
| |
| case 'O': /* make item out of order */ |
| { |
| struct reiserfs_key *key; |
| if (sscanf |
| (corruption_command, "%c %d\n", &code, |
| &item_num) != 2) { |
| printf("Wrong format \'%c\'\n", |
| corruption_command[0]); |
| return; |
| } |
| if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) { |
| printf("Wrong format \'%c\', wrong item_num \n", |
| corruption_command[0]); |
| return; |
| } |
| |
| /* destroy item order */ |
| |
| if (item_num == get_blkh_nr_items(B_BLK_HEAD(bh)) - 1) { |
| printf("can not destroy order\n"); |
| return; |
| } |
| ih = item_head(bh, item_num); |
| key = &(ih + 1)->ih_key; |
| set_key_dirid(&ih->ih_key, get_key_dirid(key) + 1); |
| |
| break; |
| } |
| case 'S': /* corrupt st_size */ |
| { |
| /* fixme: old stat data only */ |
| struct stat_data_v1 *sd; |
| |
| if (sscanf |
| (corruption_command, "%c %d %d\n", &code, &item_num, |
| &value) != 3) { |
| printf("Wrong format \'%c\'\n", |
| corruption_command[0]); |
| return; |
| } |
| if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) { |
| printf("Wrong format \'%c\', wrong item_num \n", |
| corruption_command[0]); |
| return; |
| } |
| ih = item_head(bh, item_num); |
| |
| sd = (struct stat_data_v1 *)ih_item_body(bh, ih); |
| reiserfs_warning(stderr, |
| "Changing sd_size of %k from %d to %d\n", |
| &ih->ih_key, sd_v1_size(sd), value); |
| set_sd_v1_size(sd, value); |
| break; |
| } |
| |
| case 'F': /* st_first_direct_byte */ |
| { |
| /* fixme: old stat data only */ |
| struct stat_data_v1 *sd; |
| |
| if (sscanf |
| (corruption_command, "%c %d %d\n", &code, &item_num, |
| &value) != 3) { |
| printf("Wrong format \'%c\'\n", |
| corruption_command[0]); |
| return; |
| } |
| if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) { |
| printf("Wrong format \'%c\', wrong item_num \n", |
| corruption_command[0]); |
| return; |
| } |
| ih = item_head(bh, item_num); |
| |
| sd = (struct stat_data_v1 *)ih_item_body(bh, ih); |
| reiserfs_warning(stderr, |
| "Changing sd_first_direct_byte of %k from %d to %d\n", |
| &ih->ih_key, |
| sd_v1_first_direct_byte(sd), value); |
| set_sd_v1_first_direct_byte(sd, value); |
| break; |
| } |
| |
| case 'N': /* corrupt N number of items */ |
| if (sscanf(corruption_command, "%c %d %d\n", |
| &code, &item_numbers, &bytes_to_corrupt) != 3) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| |
| if (item_numbers > get_blkh_nr_items(B_BLK_HEAD(bh))) { |
| printf |
| ("Wrong item_numbers %d expected not more then %d\n", |
| item_numbers, get_blkh_nr_items(B_BLK_HEAD(bh))); |
| return; |
| } |
| |
| for (i = 0; i < item_numbers; i++) { |
| printf("Do corruptions : %d item header; \n", i); |
| ih = item_head(bh, i); |
| do_one_ih_corrupt(ih, bytes_to_corrupt); |
| printf("Ok\n"); |
| } |
| |
| break; |
| case 'B': |
| { |
| struct block_head *blkh; |
| unsigned int offset; |
| |
| if (sscanf(corruption_command, "%c %d %d\n", |
| &code, &offset, &bytes_to_corrupt) != 3) { |
| printf("Wrong format \'%c\'\n", |
| corruption_command[0]); |
| return; |
| } |
| |
| blkh = B_BLK_HEAD(bh); |
| corrupt_block_header(blkh, offset, bytes_to_corrupt); |
| break; |
| } |
| |
| default: |
| printf("Unknown command found\n"); |
| } |
| mark_buffer_dirty(bh); |
| return; |
| } |
| |
| /* corrupt first nr_bytes bytes in item header */ |
| int do_one_ih_corrupt(struct item_head *ih, unsigned int nr_bytes) |
| { |
| if (nr_bytes > IH_SIZE) { |
| printf("Bad byte number %u expected not more then %lu\n", |
| nr_bytes, (unsigned long)IH_SIZE); |
| exit(1); |
| } |
| |
| if (memset((char *)ih, 0, nr_bytes) != ih) { |
| perror("do_one_ih_corrupt: memset failed"); |
| exit(1); |
| } |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, "\tfirst %u bytes corrupted\n", |
| nr_bytes); |
| |
| printf("\tfirst %u bytes corrupted\n", nr_bytes); |
| return 0; |
| } |
| |
| /* item header random corruption */ |
| int do_one_ih_random_corrupt(struct item_head *ih) |
| { |
| unsigned int i; |
| unsigned int from; |
| unsigned int count; |
| |
| from = get_rand(0, IH_SIZE - 1); |
| count = get_rand(1, IH_SIZE); |
| |
| if (from + count > IH_SIZE) |
| count = IH_SIZE - from; |
| |
| for (i = from; i < from + count; i++) |
| ((char *)ih)[i] = get_rand(0, 255); |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, "\tfrom %u ( %u )\n", from, count); |
| |
| printf("\tfrom %u ( %u )\n", from, count); |
| return 0; |
| } |
| |
| /* Corrupt n bytes in block header */ |
| int corrupt_block_header(struct block_head *blkh, unsigned int offset, |
| unsigned int bytes) |
| { |
| if ((offset + bytes) > BLKH_SIZE) { |
| printf |
| ("Bad offset number: %u or bad bytes number: %u, the suumary " |
| "value expected not more then %lu\n", offset, bytes, |
| (unsigned long)BLKH_SIZE); |
| exit(1); |
| } |
| |
| if (memset((char *)blkh, 0, bytes) != blkh) { |
| perror("corrupt_block_head: memset failed"); |
| exit(1); |
| } |
| |
| printf("offset : %u, corrupt %u bytes\n", offset, bytes); |
| return 0; |
| } |
| |
| /* corrupt random number of bytes within block header started from random |
| offset */ |
| static void do_one_blkh_random_corrupt(struct buffer_head *bh) |
| { |
| struct block_head *blkh; |
| unsigned int from; |
| unsigned int count; |
| unsigned int i; |
| |
| from = get_rand(0, BLKH_SIZE - 1); |
| count = get_rand(1, BLKH_SIZE); |
| |
| blkh = B_BLK_HEAD(bh); |
| |
| if (from + count > BLKH_SIZE) |
| count = BLKH_SIZE - from; |
| |
| for (i = from; i < from + count; i++) |
| ((char *)blkh)[i] = get_rand(0, 255); |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, "# : %lu # ", bh->b_blocknr); |
| fprintf(data(fs)->log, "from %u (%u)\n", from, count); |
| } |
| |
| printf("# : %lu # ", bh->b_blocknr); |
| printf("from %u (%u)\n", from, count); |
| |
| } |
| |
| void do_leaves_corruption(reiserfs_filsys_t fs, unsigned long nr_leaves_cr) |
| { |
| struct buffer_head *bh; |
| unsigned long nr_leaves = 0; |
| unsigned int i, should_be_corrupted; |
| |
| srand(time(NULL)); |
| printf("%lu leaves will be corrupted\n", nr_leaves_cr); |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, |
| "Block headers in %lu leaves will be corrupted\n", |
| nr_leaves_cr); |
| } |
| |
| if (reiserfs_open_ondisk_bitmap(fs) < 0) |
| reiserfs_exit(1, "Could not open ondisk bitmap"); |
| |
| for (i = 0; (i < get_sb_block_count(fs->fs_ondisk_sb)) && |
| nr_leaves < nr_leaves_cr; i++) { |
| |
| if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i)) |
| continue; |
| |
| bh = bread(fs->fs_dev, i, fs->fs_blocksize); |
| if (!bh) { |
| reiserfs_warning(stderr, "could not read block %lu\n", |
| i); |
| continue; |
| } |
| |
| if (who_is_this(bh->b_data, bh->b_size) != THE_LEAF) { |
| brelse(bh); |
| continue; |
| } |
| |
| if ((!is_leaf_node(bh)) || (block_of_journal(fs, i))) { |
| brelse(bh); |
| continue; |
| } |
| |
| should_be_corrupted = |
| (unsigned int)get_rand((double)0, (double)1); |
| if (should_be_corrupted == 0) { |
| brelse(bh); |
| continue; |
| } |
| do_one_blkh_random_corrupt(bh); |
| /* do_one_block_random_corrupt (bh); */ |
| mark_buffer_dirty(bh); |
| bwrite(bh); |
| brelse(bh); |
| nr_leaves++; |
| } |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, |
| "%lu leaves WERE corrupted\n", nr_leaves); |
| } |
| |
| printf("%lu leaves WERE corrupted\n", nr_leaves); |
| |
| reiserfs_close_ondisk_bitmap(fs); |
| return; |
| } |
| |
| void do_one_block_random_corrupt(struct buffer_head *bh) |
| { |
| unsigned int from = get_rand(0, bh->b_size - 1); |
| unsigned int count = get_rand(1, bh->b_size); |
| unsigned int i; |
| |
| if (from + count > bh->b_size) |
| count = bh->b_size - from; |
| |
| for (i = from; i < from + count; i++) |
| ((char *)bh->b_data)[i] = get_rand(0, 255); |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, "# block %lu: ", bh->b_blocknr); |
| fprintf(data(fs)->log, "from %u ( %u )\n", from, count); |
| } |
| |
| printf("# block %lu: ", bh->b_blocknr); |
| printf("from %u ( %u )\n", from, count); |
| |
| } |
| |
| void do_bitmap_corruption(reiserfs_filsys_t fs) |
| { |
| |
| unsigned long first = fs->fs_super_bh->b_blocknr + 1; |
| unsigned long nr_bitmap_to_corrupt; |
| unsigned long block; |
| struct buffer_head *bh; |
| unsigned int i; |
| |
| nr_bitmap_to_corrupt = |
| (unsigned long)get_rand(1, reiserfs_fs_bmap_nr(fs) - 1); |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, "%lu bitmaps will be corrupted\n", |
| nr_bitmap_to_corrupt); |
| } |
| printf("%lu bitmaps will be corrupted\n", nr_bitmap_to_corrupt); |
| for (i = 0; i < nr_bitmap_to_corrupt; i++) { |
| block = (i == 0) ? first : fs->fs_blocksize * 8 * i; |
| bh = bread(fs->fs_dev, block, fs->fs_blocksize); |
| |
| if (!bh) { |
| printf |
| ("do_bitmap_corruption: bread failed for bitmap %d: %lu\n", |
| i, block); |
| exit(1); |
| } |
| do_one_block_random_corrupt(bh); |
| mark_buffer_dirty(bh); |
| bwrite(bh); |
| brelse(bh); |
| } |
| |
| } |
| |
| /* corrupt the random number of item headers in random number of leaves */ |
| static void do_ih_random_corrupt(reiserfs_filsys_t fs, |
| unsigned long nr_leaves_cr) |
| { |
| unsigned int nr_ih_cr; |
| unsigned int i, j; |
| struct buffer_head *bh; |
| struct item_head *ih; |
| unsigned long nr_leaves = 0; |
| unsigned int should_be_corrupted = 0; |
| |
| srand(time(NULL)); |
| |
| printf("item headers in %lu leaves will be corrupted\n", nr_leaves_cr); |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, |
| "item headers in %lu leaves will be corrupted\n", |
| nr_leaves_cr); |
| } |
| |
| if (reiserfs_open_ondisk_bitmap(fs) < 0) |
| reiserfs_exit(1, "Could not open ondisk bitmap"); |
| |
| for (i = 0; (i < get_sb_block_count(fs->fs_ondisk_sb)) && |
| nr_leaves < nr_leaves_cr; i++) { |
| |
| if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i)) |
| continue; |
| |
| bh = bread(fs->fs_dev, i, fs->fs_blocksize); |
| if (!bh) { |
| reiserfs_warning(stderr, "could not read block %lu\n", |
| i); |
| continue; |
| } |
| |
| if (who_is_this(bh->b_data, bh->b_size) != THE_LEAF) { |
| brelse(bh); |
| continue; |
| } |
| |
| if ((!is_leaf_node(bh)) || (block_of_journal(fs, i))) { |
| brelse(bh); |
| continue; |
| } |
| |
| should_be_corrupted = |
| (unsigned int)get_rand((double)0, (double)1); |
| if (should_be_corrupted == 0) { |
| brelse(bh); |
| continue; |
| } |
| |
| nr_ih_cr = get_rand(1, get_blkh_nr_items(B_BLK_HEAD(bh))); |
| for (j = 0; j < nr_ih_cr; j++) { |
| should_be_corrupted = |
| (unsigned int)get_rand((double)0, (double)1); |
| if (should_be_corrupted == 0) |
| continue; |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, |
| "# block %lu , item header %d\n", |
| bh->b_blocknr, j); |
| printf("# block %lu , item header %d\n", bh->b_blocknr, |
| j); |
| |
| ih = item_head(bh, j); |
| do_one_ih_random_corrupt(ih); |
| } |
| mark_buffer_dirty(bh); |
| bwrite(bh); |
| brelse(bh); |
| nr_leaves++; |
| } |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, |
| "item headers in %lu leaves WERE corrupted\n", |
| nr_leaves); |
| printf("item headers in %lu leaves WERE corrupted\n", nr_leaves); |
| |
| reiserfs_close_ondisk_bitmap(fs); |
| } |
| |
| /* corrupt item */ |
| static void do_one_item_random_corrupt(struct buffer_head *bh, |
| struct item_head *ih) |
| { |
| unsigned int i; |
| unsigned int from; |
| unsigned int count; |
| char *p; |
| |
| p = (char *)ih_item_body(bh, ih); |
| |
| from = get_rand(0, get_ih_item_len(ih) - 1); |
| count = get_rand(1, get_ih_item_len(ih)); |
| |
| if (from + count > get_ih_item_len(ih)) |
| count = get_ih_item_len(ih) - from; |
| |
| for (i = from; i < from + count; i++) |
| ((char *)p)[i] = get_rand(0, 255); |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, "item body \tfrom %u ( %u )\n", from, |
| count); |
| |
| printf("item body \tfrom %u ( %u )\n", from, count); |
| return; |
| |
| } |
| |
| /* corrupt the random number of directory items in random number of leaves */ |
| static void do_dir_random_corrupt(reiserfs_filsys_t fs, |
| unsigned long nr_leaves_cr) |
| { |
| unsigned int nr_ih_cr; |
| unsigned int i, j; |
| struct buffer_head *bh; |
| struct item_head *ih; |
| unsigned long nr_leaves = 0; |
| unsigned int should_be_corrupted = 0; |
| |
| srand(time(NULL)); |
| |
| printf("DIR items in %lu leaves will be corrupted\n", nr_leaves_cr); |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, |
| "DIR items in %lu leaves will be corrupted\n", |
| nr_leaves_cr); |
| } |
| |
| if (reiserfs_open_ondisk_bitmap(fs) < 0) |
| reiserfs_exit(1, "Could not open ondisk bitmap"); |
| |
| for (i = 0; (i < get_sb_block_count(fs->fs_ondisk_sb)) && |
| nr_leaves < nr_leaves_cr; i++) { |
| |
| if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i)) |
| continue; |
| |
| bh = bread(fs->fs_dev, i, fs->fs_blocksize); |
| if (!bh) { |
| reiserfs_warning(stderr, "could not read block %lu\n", |
| i); |
| continue; |
| } |
| |
| if (who_is_this(bh->b_data, bh->b_size) != THE_LEAF) { |
| brelse(bh); |
| continue; |
| } |
| |
| if ((!is_leaf_node(bh)) || (block_of_journal(fs, i))) { |
| brelse(bh); |
| continue; |
| } |
| |
| should_be_corrupted = |
| (unsigned int)get_rand((double)0, (double)1); |
| if (should_be_corrupted == 0) { |
| brelse(bh); |
| continue; |
| } |
| |
| /* get next item, look is it a DIR */ |
| nr_ih_cr = get_rand(1, get_blkh_nr_items(B_BLK_HEAD(bh))); |
| for (j = 0; j < nr_ih_cr; j++) { |
| should_be_corrupted = |
| (unsigned int)get_rand((double)0, (double)1); |
| if (should_be_corrupted == 0) |
| continue; |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, |
| "# block %lu , item %d\n", |
| bh->b_blocknr, j); |
| printf("# block %lu , item %d\n", bh->b_blocknr, j); |
| |
| ih = item_head(bh, j); |
| if (get_type(&ih->ih_key) != TYPE_DIRENTRY) |
| continue; |
| do_one_item_random_corrupt(bh, ih); |
| } |
| mark_buffer_dirty(bh); |
| bwrite(bh); |
| brelse(bh); |
| nr_leaves++; |
| } |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, |
| "DIR items in %lu leaves WERE corrupted\n", nr_leaves); |
| printf("DIR items in %lu leaves WERE corrupted\n", nr_leaves); |
| |
| reiserfs_close_ondisk_bitmap(fs); |
| } |
| |
| /* corrupt the random number of stat data items in random number of leaves */ |
| static void do_sd_random_corrupt(reiserfs_filsys_t fs, |
| unsigned long nr_leaves_cr) |
| { |
| unsigned int nr_ih_cr; |
| unsigned int i, j; |
| struct buffer_head *bh; |
| struct item_head *ih; |
| unsigned long nr_leaves = 0; |
| unsigned int should_be_corrupted = 0; |
| |
| srand(time(NULL)); |
| |
| printf("SD items in %lu leaves will be corrupted\n", nr_leaves_cr); |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, |
| "SD items in %lu leaves will be corrupted\n", |
| nr_leaves_cr); |
| } |
| |
| if (reiserfs_open_ondisk_bitmap(fs) < 0) |
| reiserfs_exit(1, "Could not open ondisk bitmap"); |
| |
| for (i = 0; (i < get_sb_block_count(fs->fs_ondisk_sb)) && |
| nr_leaves < nr_leaves_cr; i++) { |
| |
| if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i)) |
| continue; |
| |
| bh = bread(fs->fs_dev, i, fs->fs_blocksize); |
| if (!bh) { |
| reiserfs_warning(stderr, "could not read block %lu\n", |
| i); |
| continue; |
| } |
| |
| if (who_is_this(bh->b_data, bh->b_size) != THE_LEAF) { |
| brelse(bh); |
| continue; |
| } |
| |
| if ((!is_leaf_node(bh)) || (block_of_journal(fs, i))) { |
| brelse(bh); |
| continue; |
| } |
| |
| should_be_corrupted = |
| (unsigned int)get_rand((double)0, (double)1); |
| if (should_be_corrupted == 0) { |
| brelse(bh); |
| continue; |
| } |
| |
| /* get next item, look is it a SD */ |
| nr_ih_cr = get_rand(1, get_blkh_nr_items(B_BLK_HEAD(bh))); |
| for (j = 0; j < nr_ih_cr; j++) { |
| should_be_corrupted = |
| (unsigned int)get_rand((double)0, (double)1); |
| if (should_be_corrupted == 0) |
| continue; |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, |
| "# block %lu , item %d\n", |
| bh->b_blocknr, j); |
| printf("# block %lu , item %d\n", bh->b_blocknr, j); |
| |
| ih = item_head(bh, j); |
| if (get_type(&ih->ih_key) != TYPE_STAT_DATA) |
| continue; |
| do_one_item_random_corrupt(bh, ih); |
| } |
| mark_buffer_dirty(bh); |
| bwrite(bh); |
| brelse(bh); |
| nr_leaves++; |
| } |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, |
| "SD items in %lu leaves WERE corrupted\n", nr_leaves); |
| printf("SD items in %lu leaves WERE corrupted\n", nr_leaves); |
| |
| reiserfs_close_ondisk_bitmap(fs); |
| } |
| |
| /* corrupt the random number of indierct items in random number of leaves */ |
| static void do_ind_random_corrupt(reiserfs_filsys_t fs, |
| unsigned long nr_leaves_cr) |
| { |
| unsigned int nr_ih_cr; |
| unsigned int i, j; |
| struct buffer_head *bh; |
| struct item_head *ih; |
| unsigned long nr_leaves = 0; |
| unsigned int should_be_corrupted = 0; |
| |
| srand(time(NULL)); |
| |
| printf("IND items in %lu leaves will be corrupted\n", nr_leaves_cr); |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, |
| "IND items in %lu leaves will be corrupted\n", |
| nr_leaves_cr); |
| } |
| |
| if (reiserfs_open_ondisk_bitmap(fs) < 0) |
| reiserfs_exit(1, "Could not open ondisk bitmap"); |
| |
| for (i = 0; (i < get_sb_block_count(fs->fs_ondisk_sb)) && |
| nr_leaves < nr_leaves_cr; i++) { |
| |
| if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i)) |
| continue; |
| |
| bh = bread(fs->fs_dev, i, fs->fs_blocksize); |
| if (!bh) { |
| reiserfs_warning(stderr, "could not read block %lu\n", |
| i); |
| continue; |
| } |
| |
| if (who_is_this(bh->b_data, bh->b_size) != THE_LEAF) { |
| brelse(bh); |
| continue; |
| } |
| |
| if ((!is_leaf_node(bh)) || (block_of_journal(fs, i))) { |
| brelse(bh); |
| continue; |
| } |
| |
| should_be_corrupted = |
| (unsigned int)get_rand((double)0, (double)1); |
| if (should_be_corrupted == 0) { |
| brelse(bh); |
| continue; |
| } |
| |
| /* get next item, look is it an IND */ |
| nr_ih_cr = get_rand(1, get_blkh_nr_items(B_BLK_HEAD(bh))); |
| for (j = 0; j < nr_ih_cr; j++) { |
| should_be_corrupted = |
| (unsigned int)get_rand((double)0, (double)1); |
| if (should_be_corrupted == 0) |
| continue; |
| |
| ih = item_head(bh, j); |
| if (get_type(&ih->ih_key) != TYPE_INDIRECT) |
| continue; |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, |
| "# block %lu , item %d\n", |
| bh->b_blocknr, j); |
| printf("# block %lu , item %d\n", bh->b_blocknr, j); |
| |
| do_one_item_random_corrupt(bh, ih); |
| } |
| mark_buffer_dirty(bh); |
| bwrite(bh); |
| brelse(bh); |
| nr_leaves++; |
| } |
| |
| if ((data(fs)->log_file_name) && (data(fs)->log)) |
| fprintf(data(fs)->log, |
| "IND items in %lu leaves WERE corrupted\n", nr_leaves); |
| printf("IND items in %lu leaves WERE corrupted\n", nr_leaves); |
| |
| reiserfs_close_ondisk_bitmap(fs); |
| } |
| |
| /* this reads list of desired corruptions from stdin and performs the |
| corruptions. Format of that list: |
| B - the random number of bitmap to be corrupted |
| L nr_leaves - block headers in nr_leaves leaves to be corupted |
| H nr_leaves - the random number of item headers in nr_leaves to be corrupted |
| S nr_leaves - the random number of stat data items in nr_leaves to be |
| corrupted |
| D nr_leaves - the random number of directory items in nr_leaves to be |
| corrupted |
| I nr_leaves - the random number of indirect items in nr_leaves to be |
| corrupted |
| */ |
| |
| static void what_to_corrupt(reiserfs_filsys_t fs, char *corruption_command) |
| { |
| unsigned long nr_leaves_cr; |
| char code; |
| |
| switch (corruption_command[0]) { |
| case 'B': |
| /* bitmap */ |
| do_bitmap_corruption(fs); |
| break; |
| |
| case 'L': |
| /* leaves */ |
| if (sscanf(corruption_command, "%c %lu\n", &code, &nr_leaves_cr) |
| != 2) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| do_leaves_corruption(fs, nr_leaves_cr); |
| break; |
| |
| case 'H': |
| /* item headers */ |
| if (sscanf(corruption_command, "%c %lu\n", &code, &nr_leaves_cr) |
| != 2) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| do_ih_random_corrupt(fs, nr_leaves_cr); |
| break; |
| |
| case 'D': |
| /* directory items */ |
| if (sscanf(corruption_command, "%c %lu\n", &code, &nr_leaves_cr) |
| != 2) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| do_dir_random_corrupt(fs, nr_leaves_cr); |
| break; |
| |
| case 'S': |
| /* stat data items */ |
| if (sscanf(corruption_command, "%c %lu\n", &code, &nr_leaves_cr) |
| != 2) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| do_sd_random_corrupt(fs, nr_leaves_cr); |
| break; |
| |
| case 'I': |
| /* indirect items */ |
| if (sscanf(corruption_command, "%c %lu\n", &code, &nr_leaves_cr) |
| != 2) { |
| printf("Wrong format \'%c\'\n", corruption_command[0]); |
| return; |
| } |
| do_ind_random_corrupt(fs, nr_leaves_cr); |
| break; |
| |
| default: |
| printf("Unknown command specified\n"); |
| } |
| } |
| |
| void do_fs_random_corrupt(reiserfs_filsys_t fs) |
| { |
| char *line = NULL; |
| size_t n = 0; |
| |
| printf("Corrupting fs. Please insert one of the following command\n" |
| " B - the random number of bitmap to be corrupted\n" |
| " L nr_leaves - block headers in nr_leaves leaves to be corupted\n" |
| " H nr_leaves - the random number of item headers in nr_leaves to be corrupted\n" |
| " S nr_leaves - the random number of stat data items in nr_leaves to be corrupted\n" |
| " D nr_leaves - the random number of directory items in nr_leaves to be corrupted\n" |
| " I nr_leaves - the random number of indirect items in nr_leaves to be corrupted\n" |
| ".. ->\n"); |
| |
| /* Get list of corruptions from stdin */ |
| while (getline(&line, &n, stdin) != -1) { |
| if (line[0] == '\n') { |
| free(line); |
| line = NULL; |
| n = 0; |
| break; |
| } |
| printf("################## command : %s", line); |
| if ((data(fs)->log_file_name) && (data(fs)->log)) { |
| fprintf(data(fs)->log, |
| "################## command : %s", line); |
| } |
| |
| what_to_corrupt(fs, line); |
| |
| free(line); |
| line = NULL; |
| n = 0; |
| } |
| } |
| |
| /* |
| Local variables: |
| c-indentation-style: "K&R" |
| mode-name: "LC" |
| c-basic-offset: 4 |
| tab-width: 4 |
| fill-column: 80 |
| End: |
| */ |