lgcosta/reiserfsprogs
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
20357cf349bb25d1e3e72e62887727811c2496c3
reiserfsprogs/debugreiserfs/corruption.c
T

1382 lines
36 KiB
C
Raw Blame History

/*
* 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((__u32 *) 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 */
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 */
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 */
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 */
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 */
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 */
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
*/
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:
*/
Reference in new issue View Git Blame Copy Permalink