/* this makes a map of blocks which can be allocated when fsck will continue: */
static void find_allocable_blocks (reiserfs_filsys_t fs)
{
int i;
fsck_progress ("Looking for allocable blocks .. ");
stats (fs)->all_blocks = SB_BLOCK_COUNT (fs);
/* find how many leaves are not pointed by any indirect items */
for (i = 0; i < SB_BLOCK_COUNT (fs); i ++) {
if (not_data_block (fs, i))
continue;
#if 0
if (!was_block_used (i)) {
/* marked free in the on-disk bitmap - so it is allocable */
make_allocable (i);
stat_allocable_found (fs);
continue;
}
#endif
if (pass0_is_leaf (i)) {
/* block looks like a reiserfs leaf */
stats(fs)->leaves ++;
if (pass0_is_good_unfm (i) || pass0_is_bad_unfm (i))
/* leaf to which one or more indirect items point to */
stats(fs)->pointed_leaves ++;
}
if (pass0_is_good_unfm (i) && pass0_is_bad_unfm (i))
die ("find_allocable_blocks: bad and good unformatted");
if (pass0_is_good_unfm (i)) {
/* blocks which were pointed only once */
stats(fs)->pointed ++;
stats(fs)->pointed_once ++;
continue;
}
if (pass0_is_bad_unfm (i)) {
/* blocks pointed more than once */
stats(fs)->pointed ++;
stats(fs)->pointed_more_than_once ++;
continue;
}
/* blocks which marked used but are not leaves and are not
pointed (internals in short) get into bitmap of allocable
blocks */
if (!pass0_is_leaf (i)) {
make_allocable (i);
stats(fs)->allocable ++;
}
}
fsck_progress ("ok\n");
}
/* this is for check only. With this we make sure that all pointers we
put into tree on pass 1 do not point to leaves (FIXME), do not
point to journal, bitmap, etc, do not point out of fs boundary and
are marked used in on-disk bitmap */
int still_bad_unfm_ptr_1 (unsigned long block)
{
if (!block)
return 0;
if (pass0_is_leaf (block))
return 1;
if (pass0_is_bad_unfm (block) && !is_bad_unfm_in_tree_once (block))
return 1;
if (not_data_block (fs, block))
return 1;
/*
if (!was_block_used (block))
return 1;
*/
if (block >= stats (fs)->all_blocks)
return 1;
return 0;
}
/* FIXME: we can improve fixing of broken keys: we can ssfe direct items which
go after stat data and have broken keys */
static void pass0_correct_leaf (reiserfs_filsys_t fs,
struct buffer_head * bh)
{
int i, j;
struct item_head * ih;
__u32 * ind_item;
unsigned long unfm_ptr;
int dirty = 0;
start_again:
ih = B_N_PITEM_HEAD (bh, 0);
for (i = 0; i < node_item_number (bh); i ++, ih ++) {
if (ih->ih_key.k_dir_id == 0 || ih->ih_key.k_objectid == 0) {
/* sometimes stat datas get k_objectid==0 or k_dir_id==0 */
if (i == (node_item_number (bh) - 1)) {
/* */
if (i == 0) {
fsck_log ("block %lu: item %d: (%H) is alone in the block\n",
bh->b_blocknr, i, ih);
return;
}
/* delete last item */
delete_item (fs, bh, i - 1);
return;
}
/* there is next item: if it is not stat data - take its k_dir_id
and k_objectid. if key order will be still wrong - the changed
item will be deleted */
if (!is_stat_data_ih (ih + 1)) {
fsck_log ("block %lu: item %d: (%H) fixed to ", bh->b_blocknr, i, ih);
ih->ih_key.k_dir_id = (ih + 1)->ih_key.k_dir_id;
ih->ih_key.k_objectid = (ih + 1)->ih_key.k_objectid;
set_offset (KEY_FORMAT_1, &ih->ih_key, 0);
set_type (KEY_FORMAT_1, &ih->ih_key, TYPE_STAT_DATA);
fsck_log ("(%H)\n", ih);
dirty = 1;
} else if (i == 0) {
delete_item (fs, bh, i);
goto start_again;
}
}
/* this recovers corruptions like the below:
1774 1732 0 0
116262638 1732 1 3
1774 1736 0 0 */
if (i && is_stat_data_ih (ih - 1) && !is_stat_data_ih (ih)) {
if (ih->ih_key.k_objectid != (ih - 1)->ih_key.k_objectid ||
ih->ih_key.k_dir_id != (ih - 1)->ih_key.k_dir_id ||
get_offset (&ih->ih_key) != 1) {
if (is_direntry_ih (ih)) {
fsck_log ("block %lu: item %d: no \".\" entry found in "
"the first item of a directory\n", bh->b_blocknr, i);
} else {
fsck_log ("block %lu: item %d: (%H) fixed to ",
bh->b_blocknr, i, ih);
ih->ih_key.k_dir_id = (ih - 1)->ih_key.k_dir_id;
ih->ih_key.k_objectid = (ih - 1)->ih_key.k_objectid;
if (ih_item_len (ih - 1) == SD_SIZE) {
/* stat data is new, therefore this item is new too */
set_offset (KEY_FORMAT_2, &(ih->ih_key), 1);
if (ih_entry_count (ih) != 0xffff)
set_type (KEY_FORMAT_2, &(ih->ih_key), TYPE_INDIRECT);
else
set_type (KEY_FORMAT_2, &(ih->ih_key), TYPE_DIRECT);
set_ih_key_format (ih, KEY_FORMAT_2);
} else {
/* stat data is old, therefore this item is old too */
set_offset (KEY_FORMAT_1, &(ih->ih_key), 1);
if (ih_entry_count (ih) != 0xffff)
set_type (KEY_FORMAT_1, &(ih->ih_key), TYPE_INDIRECT);
else
set_type (KEY_FORMAT_1, &(ih->ih_key), TYPE_DIRECT);
set_ih_key_format (ih, KEY_FORMAT_1);
}
fsck_log ("%H\n", ih);
dirty = 1;
}
}
}
/* FIXME: corruptions like:
56702 66802 1 2
56702 65536 0 0
56702 66803 1 2
do not get recovered (both last items will be deleted) */
/* delete item if it is not in correct order of object items */
if (i && not_of_one_file (&ih->ih_key, &(ih - 1)->ih_key) &&
!is_stat_data_ih (ih)) {
fsck_log ("block %lu: item %d: %H follows non stat item %H - deleted\n",
bh->b_blocknr, i, ih, ih - 1);
delete_item (fs, bh, i);
goto start_again;
}
if (i && comp_keys (&(ih - 1)->ih_key, &ih->ih_key) != -1) {
/* previous item has key not smaller than the key of currect item */
if (is_stat_data_ih (ih - 1) && !is_stat_data_ih (ih)) {
/* fix key of stat data such as if it was stat data of that item */
fsck_log ("pass0: block %lu: %d-th item %k is out of order, made a stat data of %d-th (%k)\n",
bh->b_blocknr, i - 1, &(ih - 1)->ih_key, i, &ih->ih_key);
(ih - 1)->ih_key.k_dir_id = ih->ih_key.k_dir_id;
(ih - 1)->ih_key.k_objectid = ih->ih_key.k_objectid;
set_offset (KEY_FORMAT_1, &(ih - 1)->ih_key, 0);
set_type (KEY_FORMAT_1, &(ih - 1)->ih_key, TYPE_STAT_DATA);
dirty = 1;
} else {
/* ok, we have to delete one of these two - decide which one */
int retval;
/* something will be deleted */
dirty = 1;
retval = upper_correct (bh, ih - 1, i - 1);
switch (retval) {
case 0:
/* delete upper item */
fsck_log ("pass0: block %lu: %d-th (upper) item (%k) is out of order, deleted\n",
bh->b_blocknr, i - 1, &(ih - 1)->ih_key);
delete_item (fs, bh, i - 1);
goto start_again;
case 1:
/* delete lower item */
fsck_log ("pass0: block %lu: %d-th (lower) item (%k) is out of order, deleted\n",
bh->b_blocknr, i, &ih->ih_key);
delete_item (fs, bh, i);
goto start_again;
default:
/* upper item was the first item of a node */
}
retval = lower_correct (bh, ih, i);
switch (retval) {
case 0:
/* delete lower item */
fsck_log ("pass0: block %lu: %d-th (lower) item (%k) is out of order, deleted\n",
bh->b_blocknr, i, &ih->ih_key);
delete_item (fs, bh, i);
goto start_again;
case 1:
/* delete upper item */
fsck_log ("pass0: block %lu: %d-th (upper) item (%k) is out of order, deleted\n",
bh->b_blocknr, i - 1, &(ih - 1)->ih_key);
delete_item (fs, bh, i - 1);
goto start_again;
default:
/* there wer only two items in a node, so we could not
decide what to delete, go and ask user */
}
fsck_log ("pass0: which of these items looks better (other will be deleted)?\n"
"%H\n%H\n", ih - 1, ih);
if (fsck_user_confirmed (fs, "1 or 2?", "1\n", 1))
delete_item (fs, bh, i - 1);
else
delete_item (fs, bh, i);
goto start_again;
}
}
if (is_stat_data_ih (ih) && (ih_item_len (ih) != SD_SIZE &&
ih_item_len (ih) != SD_V1_SIZE)) {
fsck_log ("pass0: block %lu, stat data of wrong length %H - deleted\n",
bh, ih);
delete_item (fs, bh, i);
goto start_again;
}
dirty += correct_key_format (ih);
if (is_stat_data_ih (ih)) {
;/*correct_stat_data (fs, bh, i);*/
}
if (is_direntry_ih (ih)) {
verify_directory_item (fs, bh, i);
continue;
}
if (!is_indirect_ih (ih))
continue;
ind_item = (__u32 *)B_I_PITEM (bh, ih);
for (j = 0; j < I_UNFM_NUM (ih); j ++) {
unfm_ptr = le32_to_cpu (ind_item [j]);
if (!unfm_ptr)
continue;
if (fsck_mode (fs) == FSCK_ZERO_FILES) {
/* FIXME: this is temporary mode of fsck */
ind_item [j] = 0;
reiserfs_bitmap_clear_bit (fsck_new_bitmap(fs), unfm_ptr);
tmp_zeroed ++;
dirty = 1;
continue;
}
if (not_data_block (fs, unfm_ptr) || /* journal area or bitmap or super block */
unfm_ptr >= SB_BLOCK_COUNT (fs)) {/* garbage in pointer */
stats (fs)->wrong_pointers ++;
/*
fsck_log ("pass0: %d-th pointer (%lu) in item %k (leaf block %lu) is wrong\n",
j, unfm_ptr, &ih->ih_key, bh->b_blocknr);
*/
ind_item [j] = 0;
dirty = 1;
continue;
}
#if 0
if (!was_block_used (unfm_ptr)) {
/* this will get to a pool of allocable blocks */
ind_item [j] = 0;
dirty = 1;
stat_wrong_pointer_found (fs);
continue;
}
#endif
/* mark block in bitmaps of unformatted nodes */
register_unfm (unfm_ptr);
}
}
/* mark all objectids in use */
ih = B_N_PITEM_HEAD (bh, 0);
for (i = 0; i < node_item_number (bh); i ++, ih ++) {
mark_objectid_really_used (proper_id_map (fs), le32_to_cpu (ih->ih_key.k_dir_id));
mark_objectid_really_used (proper_id_map (fs), le32_to_cpu (ih->ih_key.k_objectid));
}
if (node_item_number (bh) < 1) {
/* pass 1 will skip this */
stats(fs)->all_contents_removed ++;
fsck_log ("pass0: block %lu got all items deleted\n",
bh->b_blocknr);
} else {
/* pass1 will use this bitmap */
pass0_mark_leaf (bh->b_blocknr);
}
if (dirty) {
stats(fs)->leaves_corrected ++;
mark_buffer_dirty (bh);
}
}
static int is_bad_sd (struct item_head * ih, char * item)
{
struct stat_data * sd = (struct stat_data *)item;
if (le32_to_cpu(ih->ih_key.u.k_offset_v1.k_offset) || le32_to_cpu(ih->ih_key.u.k_offset_v1.k_uniqueness)) {
reiserfs_warning (stderr, "Bad SD? %H\n", ih);
return 1;
}
if (ih_item_len (ih) == SD_V1_SIZE) {
/* looks like old stat data */
if (ih_key_format (ih) != KEY_FORMAT_1)
fsck_log ("item %H has wrong format\n", ih);
return 0;
}
if (!S_ISDIR (sd_v2_mode(sd)) && !S_ISREG(sd_v2_mode(sd)) &&
!S_ISCHR (sd_v2_mode(sd)) && !S_ISBLK(sd_v2_mode(sd)) &&
!S_ISLNK (sd_v2_mode(sd)) && !S_ISFIFO(sd_v2_mode(sd)) &&
!S_ISSOCK(sd_v2_mode(sd))) {
/*fsck_log ("file %k unexpected mode encountered 0%o\n", &ih->ih_key, sd_v2_mode(sd))*/;
}
return 0;
}
int is_bad_directory (struct item_head * ih, char * item, int dev, int blocksize)
{
int i;
char * name;
int namelen, entrylen;
struct reiserfs_de_head * deh = (struct reiserfs_de_head *)item;
__u32 prev_offset = 0;
__u16 prev_location = ih_item_len (ih);
int min_entry_size = 1;/* we have no way to understand whether the
filesystem were created in 3.6 format or
converted to it. So, we assume that minimal name
length is 1 */
if (ih_item_len (ih) / (DEH_SIZE + min_entry_size) < ih_entry_count (ih))
/* entry count is too big */
return 1;
for (i = 0; i < ih_entry_count (ih); i ++, deh ++) {
entrylen = entry_length(ih, deh, i);
if (entrylen > REISERFS_MAX_NAME_LEN (blocksize)) {
return 1;
}
if (deh_offset (deh) <= prev_offset) {
return 1;
}
prev_offset = deh_offset (deh);
if (deh_location(deh) + entrylen != prev_location) {
return 1;
}
prev_location = deh_location (deh);
namelen = name_length (ih, deh, i);
name = name_in_entry (deh, i);
if (!is_properly_hashed (fs, name, namelen, deh_offset (deh))) {
return 1;
}
}
return 0;
}
/* change incorrect block adresses by 0. Do not consider such item as incorrect */
static int is_bad_indirect (struct item_head * ih, char * item, int dev, int blocksize)
{
int i;
int bad = 0;
int blocks;
if (ih_item_len(ih) % UNFM_P_SIZE) {
fsck_log ("is_bad_indirect: indirect item of %H of invalid length\n", ih);
return 1;
}
blocks = SB_BLOCK_COUNT (fs);
for (i = 0; i < I_UNFM_NUM (ih); i ++) {
__u32 * ind = (__u32 *)item;
if (le32_to_cpu (ind[i]) >= blocks) {
bad ++;
fsck_log ("is_bad_indirect: %d-th pointer of item %H looks bad (%lu)\n",
i, ih, le32_to_cpu (ind [i]));
continue;
}
}
return bad;
}
static void go_through (reiserfs_filsys_t fs)
{
struct buffer_head * bh;
int i;
int what_node;
unsigned long done = 0, total;
if (fsck_mode (fs) == DO_TEST) {
/* just to test pass0_correct_leaf */
bh = bread (fs->s_dev, stats(fs)->test, fs->s_blocksize);
/*
if (is_leaf_bad (bh)) {
fsck_progress ("############### bad #################\n");
}
*/
pass0_correct_leaf (fs, bh);
print_block (stdout, fs, bh, 3, -1, -1);
if (is_leaf_bad (bh)) {
fsck_progress ("############### still bad #################\n");
}
brelse (bh);
reiserfs_free (fs);
exit(4);
}
total = reiserfs_bitmap_ones (fsck_disk_bitmap (fs));
fsck_progress ("\nPass 0 (%lu (of %lu) blocks will be read):\n",
total, SB_BLOCK_COUNT (fs));
for (i = 0; i < SB_BLOCK_COUNT (fs); i ++) {
if (!is_to_be_read (fs, i))
continue;
print_how_far (&done, total, 1, fsck_quiet (fs));
bh = bread (fs->s_dev, i, fs->s_blocksize);
if (!bh) {
/* we were reading one block at time, and failed, so mark
block bad */
fsck_progress ("pass0: reading block %lu failed\n", i);
continue;
}
if (not_data_block (fs, i))
reiserfs_panic ("not data block found");
stats (fs)->analyzed ++;
what_node = who_is_this (bh->b_data, fs->s_blocksize);
if ( what_node != THE_LEAF ) {
brelse (bh);
continue;
}
pass0_correct_leaf (fs, bh);
brelse (bh);
}
#if 0
for (i = 0; i < SB_BLOCK_COUNT (fs); i += nr_to_read) {
to_scan = how_many_to_scan (fs, i, nr_to_read);
if (to_scan) {
print_how_far (&done, total, to_scan, fsck_quiet (fs));
/* at least one of nr_to_read blocks is to be checked */
bbh = bread (fs->s_dev, i / nr_to_read, fs->s_blocksize * nr_to_read);
if (bbh) {
for (j = 0; j < nr_to_read; j ++) {
if (!is_to_be_read (fs, i + j))
continue;
if (not_data_block (fs, i + j))
reiserfs_panic ("not data block found");
stats (fs)->analyzed ++;
data = bbh->b_data + j * fs->s_blocksize;
what_node = who_is_this (data, fs->s_blocksize);
if ( what_node != THE_LEAF ) {
continue;
}
/* the node looks like a leaf, but it still can be
not perfect */
bh = make_buffer (fs->s_dev, i + j, fs->s_blocksize, data);
/*printf ("block %lu .. ", bh->b_blocknr);fflush(stdout);*/
pass0_correct_leaf (fs, bh);
/*printf ("ok\n");fflush(stdout);*/
brelse (bh);
}
if (buffer_dirty (bbh))
bwrite (bbh);
bforget (bbh);
} else {
done -= to_scan;
/* bread failed */
if (nr_to_read != 1) {
/* we tryied to read bunch of blocks. Try to read them by one */
nr_to_read = 1;
i --;
continue;
} else {
/* we were reading one block at time, and failed, so mark
block bad */
fsck_progress ("pass0: block %lu is bad, marked used\n", i);
}
}
}
if (nr_to_read == 1 && ((i + 1) % NR_TO_READ) == 0) {
/* we have read NR_TO_READ blocks one at time, switch back to
reading NR_TO_READ blocks at time */
i -= (NR_TO_READ - 1);
nr_to_read = NR_TO_READ;
}
}
#endif
/* just in case */
mark_objectid_really_used (proper_id_map (fs), REISERFS_ROOT_OBJECTID);
fsck_progress ("\n");
if (fsck_save_leaf_bitmap (fs)) {
reiserfs_bitmap_save (stats (fs)->new_bitmap_file_name, leaves_bitmap);
}
}
void pack_partition (struct super_block * s)
{
int i, j, k;
uint32_t blocknumber32;
uint16_t reclen16, data16;
__u32 done = 0;
char * data;
long long bytes_to_transfer = 0;
struct buffer_head * bh;
int total_block_number;
total_block_number = get_total_block_number ();
/* write filesystem's block size to stdout as 16 bit number */
reclen16 = htons (s->s_blocksize);
if (opt_pack == 'p' || opt_pack_all == 'p')
write (1, &reclen16, sizeof (uint16_t));
bytes_to_transfer = sizeof (uint16_t);
/* go through blocks which are marked used in cautious bitmap */
for (i = 0; i < SB_BMAP_NR (s); i ++) {
for (j = 0; j < s->s_blocksize; j ++) {
/* make sure, that we are not out of the device */
if (i * s->s_blocksize * 8 + j * 8 == SB_BLOCK_COUNT (s))
goto out_of_bitmap;
if (i * s->s_blocksize * 8 + j * 8 + 8 > SB_BLOCK_COUNT (s))
die ("build_the_tree: Out of bitmap");
if (opt_pack_all == 0)
if (SB_AP_BITMAP (s)[i]->b_data[j] == 0) {
/* skip busy block if 'a' not specified */
continue;
}
/* read 8 blocks at once */
bh = bread (s->s_dev, i * s->s_blocksize + j, s->s_blocksize * 8);
for (k = 0; k < 8; k ++) {
__u32 block;
block = i * s->s_blocksize * 8 + j * 8 + k;
if (opt_pack_all == 0 && (SB_AP_BITMAP (s)[i]->b_data[j] & (1 << k)) == 0)
continue;
#if 0
if ((SB_AP_BITMAP (s)[i]->b_data[j] & (1 << k)) == 0 || /* k-th block is free */
block < SB_BUFFER_WITH_SB (s)->b_blocknr) /* is in skipped for drive manager area */
continue;
#endif
print_how_far (&done, total_block_number);
data = bh->b_data + k * s->s_blocksize;
if (not_formatted_node (data, s->s_blocksize)) {
/* ok, could not find formatted node here. But
this can be commit block, or bitmap which has
to be transferred */
if (!not_data_block (s, block)) {
/* this is usual unformatted node. Transfer
its number only to erase previously existed
formatted nodes on the partition we will
apply transferred metadata to */
/* size of following record in network byte order */
reclen16 = htons (2);
/* the record record */
data16 = htons (MAX_HEIGHT + 1);/*?*/
data = (char *)&data16;
} else {
/* write super block and bitmap block must be transferred as are */
/* size of record */
reclen16 = htons (s->s_blocksize);
/* the record itself */
data = data;
}
} else {
/* any kind of formatted nodes gets here (super
block, desc block of journal): FIXME: it would
be useful to be able to find commit blocks */
zero_direct_items (data);
/* FIXME: do other packing */
/* write size of following record */
reclen16 = htons (s->s_blocksize);
/* the record itself */
data = data;
#if 0
if (blkh->blk_level > DISK_LEAF_NODE_LEVEL) {
/* block must look like internal node on the target
partition. But (currently) fsck do not consider internal
nodes, therefore we do not have to transfer contents of
internal nodes */
/* size of following record in network byte order */
reclen16 = htons (2);
/* the record itself */
data16 = htons (DISK_LEAF_NODE_LEVEL + 1);
data = (char *)&data16;
} else {
/* leaf node found */
ih = (struct item_head *)(blkh + 1);
/* fill direct items with 0s */
for (l = 0; l < blkh->blk_nr_item; l ++, ih ++)
if (I_IS_DIRECT_ITEM (ih)) {
direct_items ++;
direct_item_total_length += ih->ih_item_len;
memset ((char *)blkh + ih->ih_item_location, 0, ih->ih_item_len);
}
/* write size of following record */
reclen16 = htons (s->s_blocksize);
/* the record itself */
data = (char *)blkh;
}
#endif
}
/*fprintf (stderr, "block %d, reclen %d\n", block, ntohs (reclen16));*/
/* write block number */
blocknumber32 = htonl (block);
bytes_to_transfer += sizeof (uint32_t) + sizeof (uint16_t) + ntohs (reclen16);
if (opt_pack == 'p' || opt_pack_all == 'p') {
write (1, &blocknumber32, sizeof (uint32_t));
/* write record len */
write (1, &reclen16, sizeof (uint16_t));
/* write the record */
write (1, data, ntohs (reclen16));
}
}
bforget (bh);
}
}
out_of_bitmap:
fprintf (stderr, "done\n");
if (opt_pack == 'c' || opt_pack_all == 'c')
fprintf (stderr, "Bytes to transfer %Ld, sequential 0s %d in %d sequeneces (%items (%d unreacable))\n",
bytes_to_transfer, direct_item_total_length, direct_items, items, unreachable_items);
else
fprintf (stderr, "Bytes dumped %Ld, sequential 0s %d in %d sequeneces\n",
bytes_to_transfer, direct_item_total_length, direct_items);
}
