/* * Copyright 1996-2004 by Hans Reiser, licensing governed by * reiserfsprogs/README */ #include "fsck.h" reiserfs_bitmap_t * bad_unfm_in_tree_once_bitmap; //int step = 0; // 0 - find stat_data or any item ; 1 - find item ; 2 - already found /* allocates buffer head and copy buffer content */ struct buffer_head * make_buffer (int dev, unsigned long blocknr, int size, char * data) { struct buffer_head * bh; bh = getblk (dev, blocknr, size); if (buffer_uptodate (bh)) return bh; // die ("make_buffer: uptodate buffer found"); memcpy (bh->b_data, data, size); misc_set_bit (BH_Uptodate, (char *)&bh->b_state); return bh; } int find_not_of_one_file(struct key * to_find, struct key * key) { if ((get_key_objectid (to_find) != ~(__u32)0) && (get_key_objectid (to_find) != get_key_objectid (key))) return 1; if ((get_key_dirid (to_find) != ~(__u32)0) && (get_key_dirid (to_find) != get_key_dirid (key))) return 1; return 0; } int is_item_reachable (struct item_head * ih) { return ih_reachable (ih) ? 1 : 0; } void mark_item_unreachable (struct item_head * ih) { clean_ih_flags (ih); mark_ih_unreachable (ih); if (is_indirect_ih (ih)) set_ih_free_space (ih, 0); } void mark_item_reachable (struct item_head * ih, struct buffer_head * bh) { mark_ih_reachable (ih); mark_buffer_dirty (bh); } static void stat_data_in_tree (struct buffer_head *bh, struct item_head * ih) { #if 0 __u32 objectid; objectid = get_key_objectid (&ih->ih_key); if (mark_objectid_really_used (proper_id_map (fs), objectid)) { stat_shared_objectid_found (fs); mark_objectid_really_used (shared_id_map (fs), objectid); } #endif zero_nlink (ih, B_I_PITEM (bh, ih)); } static char *still_bad_unfm_ptr_to_string (int val) { switch (val) { case 1: return "a leaf"; case 2: return "shared between a few files"; case 3: return "not a data block"; case 4: return "not used in on-disk bitmap"; case 5: return "out of partition boundary"; } return ""; } /* this just marks blocks pointed by an indirect item as used in the new bitmap */ static void indirect_in_tree (struct buffer_head * bh, struct item_head * ih) { unsigned int i; __u32 * unp; __u32 unfm_ptr; int ret; unp = (__u32 *)B_I_PITEM (bh, ih); for (i = 0; i < I_UNFM_NUM (ih); i ++) { unfm_ptr = d32_get (unp, i); if (unfm_ptr == 0) continue; if ((ret = still_bad_unfm_ptr_1 (unfm_ptr))) reiserfs_panic ("%s: block %lu: The file %k points to the block (%u) which is %s", __FUNCTION__, bh->b_blocknr, &ih->ih_key, unfm_ptr, still_bad_unfm_ptr_to_string(ret)); mark_block_used (unfm_ptr, 1); } } static void leaf_is_in_tree_now (struct buffer_head * bh) { item_action_t actions[] = {stat_data_in_tree, indirect_in_tree, 0, 0}; mark_block_used ((bh)->b_blocknr, 1); for_every_item (bh, mark_item_unreachable, actions); pass_1_stat (fs)->inserted_leaves ++; mark_buffer_dirty (bh); } static void insert_pointer (struct buffer_head * bh, struct path * path) { struct item_head * ih; char * body; int retval; struct tree_balance tb; init_tb_struct (&tb, fs, path, 0x7fff); /* fix_nodes & do_balance must work for internal nodes only */ ih = 0; retval = fix_nodes (/*tb.transaction_handle,*/ M_INTERNAL, &tb, ih); if (retval != CARRY_ON) die ("insert_pointer: fix_nodes failed with retval == %d", retval); /* child_pos: we insert after position child_pos: this feature of the insert_child */ /* there is special case: we insert pointer after (-1)-st key (before 0-th key) in the parent */ if (PATH_LAST_POSITION (path) == 0 && path->pos_in_item == 0) PATH_H_B_ITEM_ORDER (path, 0) = -1; else { if (PATH_H_PPARENT (path, 0) == 0) PATH_H_B_ITEM_ORDER (path, 0) = 0; /* PATH_H_B_ITEM_ORDER (path, 0) = PATH_H_PPARENT (path, 0) ? PATH_H_B_ITEM_ORDER (path, 0) : 0;*/ } ih = 0; body = (char *)bh; //memmode = 0; do_balance (&tb, ih, body, M_INTERNAL, 0); leaf_is_in_tree_now (bh); } /* return 1 if left and right can be joined. 0 otherwise */ int balance_condition_fails (struct buffer_head * left, struct buffer_head * right) { if (B_FREE_SPACE (left) >= B_CHILD_SIZE (right) - (are_items_mergeable (B_N_PITEM_HEAD (left, B_NR_ITEMS (left) - 1), B_N_PITEM_HEAD (right, 0), left->b_size) ? IH_SIZE : 0)) return 1; return 0; } /* return 1 if new can be joined with last node on the path or with its right neighbor, 0 otherwise */ int balance_condition_2_fails (struct buffer_head * new, struct path * path) { struct buffer_head * bh; struct key * right_dkey; int pos, used_space; bh = PATH_PLAST_BUFFER (path); if (balance_condition_fails (bh, new)) /* new node can be joined with last buffer on the path */ return 1; /* new node can not be joined with its left neighbor */ right_dkey = uget_rkey (path); if (right_dkey == 0) /* there is no right neighbor */ return 0; pos = PATH_H_POSITION (path, 1); if (pos == B_NR_ITEMS (bh = PATH_H_PBUFFER (path, 1))) { /* we have to read parent of right neighbor. For simplicity we call search_by_key, which will read right neighbor as well */ INITIALIZE_PATH(path_to_right_neighbor); if (reiserfs_search_by_key_4 (fs, right_dkey, &path_to_right_neighbor) != ITEM_FOUND) reiserfs_panic ("%s: block %lu, pointer %d: The left delimiting key %k of the block (%lu) is wrong," "the item cannot be found", __FUNCTION__, PATH_H_PBUFFER(path, 1)->b_blocknr, pos, right_dkey, get_dc_child_blocknr(B_N_CHILD (bh, pos + 1))); used_space = B_CHILD_SIZE (PATH_PLAST_BUFFER (&path_to_right_neighbor)); pathrelse (&path_to_right_neighbor); } else used_space = get_dc_child_size (B_N_CHILD (bh, pos + 1)); if (B_FREE_SPACE (new) >= used_space - (are_items_mergeable (B_N_PITEM_HEAD (new, B_NR_ITEMS (new) - 1), (struct item_head *)right_dkey, new->b_size) ? IH_SIZE : 0)) return 1; return 0; } static void get_max_buffer_key (struct buffer_head * bh, struct key * key) { struct item_head * ih; ih = B_N_PITEM_HEAD (bh, B_NR_ITEMS (bh) - 1); copy_key (key, &(ih->ih_key)); if (is_direntry_key (key)) { /* copy deh_offset 3-rd and 4-th key components of the last entry */ set_offset (KEY_FORMAT_1, key, get_deh_offset (B_I_DEH (bh, ih) + get_ih_entry_count (ih) - 1)); } else if (!is_stat_data_key (key)) /* get key of the last byte, which is contained in the item */ set_offset (key_format (key), key, get_offset (key) + get_bytes_number (ih, bh->b_size) - 1); } int tree_is_empty (void) { return (get_sb_root_block (fs->fs_ondisk_sb) == ~(__u32)0 || get_sb_root_block (fs->fs_ondisk_sb) == 0) ? 1 : 0; } void make_single_leaf_tree (struct buffer_head * bh) { /* tree is empty, make tree root */ set_sb_root_block (fs->fs_ondisk_sb, bh->b_blocknr); set_sb_tree_height (fs->fs_ondisk_sb, 2); mark_buffer_dirty (fs->fs_super_bh); leaf_is_in_tree_now (bh); } /* inserts pointer to leaf into tree if possible. If not, marks node as uninsertable in special bitmap */ static void try_to_insert_pointer_to_leaf (struct buffer_head * new_bh) { INITIALIZE_PATH (path); struct buffer_head * bh; /* last path buffer */ struct key * first_bh_key, last_bh_key; /* first and last keys of new buffer */ struct key last_path_buffer_last_key, * right_dkey; int ret_value; if (tree_is_empty () == 1) { make_single_leaf_tree (new_bh); return; } first_bh_key = B_N_PKEY (new_bh, 0); /* try to find place in the tree for the first key of the coming node */ ret_value = reiserfs_search_by_key_4 (fs, first_bh_key, &path); if (ret_value == ITEM_FOUND) goto cannot_insert; /* get max key in the new node */ get_max_buffer_key (new_bh, &last_bh_key); bh = PATH_PLAST_BUFFER (&path); if (comp_keys (B_N_PKEY (bh, 0), &last_bh_key) == 1/* first is greater*/) { /* new buffer falls before the leftmost leaf */ if (balance_condition_fails (new_bh, bh)) goto cannot_insert; if (uget_lkey (&path) != 0 || PATH_LAST_POSITION (&path) != 0) die ("try_to_insert_pointer_to_leaf: bad search result"); path.pos_in_item = 0; goto insert; } /* get max key of buffer, that is in tree */ get_max_buffer_key (bh, &last_path_buffer_last_key); if (comp_keys (&last_path_buffer_last_key, first_bh_key) != -1/* second is greater */) /* first key of new buffer falls in the middle of node that is in tree */ goto cannot_insert; right_dkey = uget_rkey (&path); if (right_dkey && comp_keys (right_dkey, &last_bh_key) != 1 /* first is greater */) goto cannot_insert; if (balance_condition_2_fails (new_bh, &path)) goto cannot_insert; insert: insert_pointer (new_bh, &path); goto out; cannot_insert: /* statistic */ mark_block_uninsertable (new_bh->b_blocknr); out: pathrelse (&path); return; } /* everything should be correct already in the leaf but contents of indirect items. So we only 1. zero slots pointing to a leaf 2. zero pointers to blocks which are pointed already 3. what we should do with directory entries hashed by another hash? they are deleted for now */ static void pass1_correct_leaf (reiserfs_filsys_t * fs, struct buffer_head * bh) { unsigned int i, j; struct item_head * ih; __u32 * ind_item; __u32 unfm_ptr; int dirty = 0; ih = B_N_PITEM_HEAD (bh, 0); for (i = 0; i < B_NR_ITEMS (bh); i ++, ih ++) { if (is_direntry_ih (ih)) { struct reiserfs_de_head * deh; __u32 offset; char * name; int name_len; unsigned int hash_code; deh = B_I_DEH (bh, ih); offset = 0; for (j = 0; j < get_ih_entry_count (ih); j ++) { name = name_in_entry (deh + j, j); name_len = name_in_entry_length (ih, deh + j, j); if ((j == 0 && is_dot (name, name_len)) || (j == 1 && is_dot_dot (name, name_len))) { continue; } hash_code = find_hash_in_use (name, name_len, get_deh_offset (deh + j), get_sb_hash_code (fs->fs_ondisk_sb)); if (hash_code != get_sb_hash_code (fs->fs_ondisk_sb)) { fsck_log ("pass1: block %lu, item %d, entry %d: The entry \"%.*s\" of the %k is hashed with %s " "whereas proper hash is %s", bh->b_blocknr, i, j, name_len, name, &ih->ih_key, code2name (hash_code), code2name (get_sb_hash_code (fs->fs_ondisk_sb))); if (get_ih_entry_count (ih) == 1) { delete_item (fs, bh, i); fsck_log(" - the only entry - item was deleted\n"); i --; ih --; break; } else { cut_entry (fs, bh, i, j, 1); fsck_log(" - deleted\n"); j --; deh = B_I_DEH (bh, ih); continue; } } if (j && offset >= get_deh_offset (deh + j)) { fsck_log ("pass1: block %lu, item %d, entry %d: The entry " "\"%.*s\" of the %k has hash offset %lu not " "larger smaller than the previous one %lu. The " "entry is deleted.\n", bh->b_blocknr, i, j, name_len, name, &ih->ih_key, get_deh_offset(deh + j), offset); cut_entry (fs, bh, i, j, 1); j --; deh = B_I_DEH (bh, ih); continue; } offset = get_deh_offset (deh + j); } continue; } if (!is_indirect_ih (ih)) continue; /* correct indirect items */ ind_item = (__u32 *)B_I_PITEM (bh, ih); for (j = 0; j < I_UNFM_NUM (ih); j ++) { unfm_ptr = d32_get (ind_item, j); if (!unfm_ptr) continue; /* this corruption of indirect item had to be fixed in pass0 */ if (not_data_block (fs, unfm_ptr) || unfm_ptr >= get_sb_block_count (fs->fs_ondisk_sb)) /*!was_block_used (unfm_ptr))*/ reiserfs_panic ("%s: block %lu, item %d, pointer %d: The wrong pointer (%u) in the file %K. " "Must be fixed on pass0.", __FUNCTION__, bh->b_blocknr, i, j, unfm_ptr, &ih->ih_key); /* 1. zero slots pointing to a leaf */ if (is_used_leaf (unfm_ptr)) { dirty ++; d32_put (ind_item, j, 0); pass_1_stat (fs)->pointed_leaves ++; continue; } /* 2. zero pointers to blocks which are pointed already */ if (is_bad_unformatted (unfm_ptr)) { /* this unformatted pointed more than once. Did we see it already? */ if (!is_bad_unfm_in_tree_once (unfm_ptr)) /* keep first reference to it and mark about that in special bitmap */ mark_bad_unfm_in_tree_once (unfm_ptr); else { /* Yes, we have seen this pointer already, zero other pointers to it. */ dirty ++; d32_put (ind_item, j, 0); pass_1_stat (fs)->non_unique_pointers ++; continue; } } else pass_1_stat (fs)->correct_pointers ++; } } if (dirty) mark_buffer_dirty (bh); } struct si * remove_saved_item (struct si * si) { struct si * tmp = si->si_next; freemem (si->si_dnm_data); freemem (si); return tmp; } /* fsck starts creating of this bitmap on pass 1. It will then become on-disk bitmap */ static void init_new_bitmap (reiserfs_filsys_t * fs) { unsigned int i; unsigned long block; unsigned long reserved; fsck_new_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb)); /* mark_block_used skips 0, set the bit explicitly */ reiserfs_bitmap_set_bit (fsck_new_bitmap (fs), 0); /* mark other skipped blocks and super block used */ for (i = 1; i <= fs->fs_super_bh->b_blocknr; i ++) mark_block_used (i, 1); /* mark bitmap blocks as used */ block = fs->fs_super_bh->b_blocknr + 1; for (i = 0; i < reiserfs_fs_bmap_nr(fs); i ++) { mark_block_used (block, 1); if (spread_bitmaps (fs)) block = (block / (fs->fs_blocksize * 8) + 1) * (fs->fs_blocksize * 8); else block ++; } reserved = get_size_of_journal_or_reserved_area (fs->fs_ondisk_sb); /* where does journal area (or reserved journal area) start from */ if (!is_new_sb_location (fs->fs_super_bh->b_blocknr, fs->fs_blocksize) && !is_old_sb_location (fs->fs_super_bh->b_blocknr, fs->fs_blocksize)) die ("init_new_bitmap: Wrong super block location, you must run --rebuild-sb."); block = get_journal_start_must (fs); for (i = block; i < reserved + block; i ++) mark_block_used (i, 1); if (fs->fs_badblocks_bm) for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) { if (reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i)) { if (reiserfs_bitmap_test_bit (fsck_new_bitmap (fs), i)) reiserfs_panic ("%s: The block pointer to not data area, must be fixed on the pass0.\n", __FUNCTION__); reiserfs_bitmap_set_bit (fsck_new_bitmap (fs), i); } } #if 0 /* mark journal area as used if journal is standard or it is non standard and initialy has been created on a main device */ reserved = 0; if (!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb)) reserved = get_jp_journal_size (sb_jp (fs->fs_ondisk_sb)); if (get_sb_reserved_for_journal (fs->fs_ondisk_sb)) reserved = get_sb_reserved_for_journal (fs->fs_ondisk_sb); if (reserved) { for (i = 0; i <= reserved; i ++) mark_block_used (i + get_jp_journal_1st_block (sb_jp (fs->fs_ondisk_sb))); } #endif } /* this makes a map of blocks which can be allocated when fsck will continue */ static void find_allocable_blocks (reiserfs_filsys_t * fs) { unsigned long i; fsck_progress ("Looking for allocable blocks .. "); fsck_allocable_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb)); reiserfs_bitmap_fill (fsck_allocable_bitmap (fs)); /* find how many leaves are not pointed by any indirect items */ for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) { if (not_data_block (fs, i)) /* journal (or reserved for it area), bitmaps, super block and blocks before it */ continue; if (is_good_unformatted (i) && is_bad_unformatted (i)) die ("find_allocable_blocks: The block (%lu) is masr as good and as bad at once.", i); if (is_good_unformatted (i) || is_bad_unformatted (i)) { /* blocks which were pointed once or more thn onec from indirect items - they will not be allocated */ continue; } /* make allocable not leaves, not bad blocks */ if (!is_used_leaf (i) && (!fs->fs_badblocks_bm || !reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i))) { /* this is not leaf and it is not pointed by found indirect items, so it does not contains anything valuable */ make_allocable (i); pass_1_stat (fs)->allocable_blocks ++; } } fsck_progress ("finished\n"); fs->block_allocator = reiserfsck_reiserfs_new_blocknrs; fs->block_deallocator = reiserfsck_reiserfs_free_block; } static void before_pass_1 (reiserfs_filsys_t * fs) { /* this will become an on-disk bitmap */ init_new_bitmap (fs); /* bitmap of leaves which could not be inserted on pass 1. FIXME: no need to have 1 bit per block */ fsck_uninsertables (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb)); reiserfs_bitmap_fill (fsck_uninsertables (fs)); /* find blocks which can be allocated */ find_allocable_blocks (fs); /* bitmap of bad unformatted nodes which are in the tree already */ bad_unfm_in_tree_once_bitmap = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb)); /* pass 1 does not deal with objectid */ } static void save_pass_1_result (reiserfs_filsys_t * fs) { FILE * file; int retval; file = open_file("temp_fsck_file.deleteme", "w+"); if (!file) return; /* to be able to get a new bitmap on pass2 we should flush it on disk new_bitmap should not be flushed on disk if run without -d option, as if fsck fails on pass1 we get wrong bitmap on the next fsck start */ reiserfs_flush_to_ondisk_bitmap (fsck_new_bitmap (fs), fs); /* to be able to restart with pass 2 we need bitmap of uninsertable blocks and bitmap of alocable blocks */ reiserfs_begin_stage_info_save(file, PASS_1_DONE); reiserfs_bitmap_save (file, fsck_uninsertables (fs)); reiserfs_bitmap_save (file, fsck_allocable_bitmap(fs)); reiserfs_end_stage_info_save (file); close_file (file); retval = rename ("temp_fsck_file.deleteme", state_dump_file (fs)); if (retval != 0) fsck_progress ("pass 1: Could not rename the temporary file temp_fsck_file.deleteme to %s", state_dump_file (fs)); } void load_pass_1_result (FILE * fp, reiserfs_filsys_t * fs) { fsck_new_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb)); reiserfs_bitmap_copy (fsck_new_bitmap (fs), fs->fs_bitmap2); fsck_uninsertables (fs) = reiserfs_bitmap_load (fp); fsck_allocable_bitmap (fs) = reiserfs_bitmap_load (fp); fs->block_allocator = reiserfsck_reiserfs_new_blocknrs; fs->block_deallocator = reiserfsck_reiserfs_free_block; if (!fsck_new_bitmap (fs) || !fsck_allocable_bitmap (fs) || !fsck_allocable_bitmap (fs)) fsck_exit ("State dump file seems corrupted. Run without -d"); /* we need objectid map on pass 2 to be able to relocate files */ proper_id_map (fs) = id_map_init(); /* Not implemented yet. fetch_objectid_map (proper_id_map (fs), fs); */ fsck_progress ("Pass 1 result loaded. %u blocks used, %u allocable, " "still to be inserted %u\n", reiserfs_bitmap_ones (fsck_new_bitmap (fs)), reiserfs_bitmap_zeros (fsck_allocable_bitmap (fs)), reiserfs_bitmap_zeros (fsck_uninsertables (fs))); } extern reiserfs_bitmap_t * leaves_bitmap; /* reads blocks marked in leaves_bitmap and tries to insert them into tree */ static void do_pass_1 (reiserfs_filsys_t * fs) { struct buffer_head * bh; unsigned long i; int what_node; unsigned long done = 0, total; /* on pass0 we have found that amount of leaves */ total = reiserfs_bitmap_ones (leaves_bitmap); /* read all leaves found on the pass 0 */ for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) { if (!is_used_leaf (i)) continue; print_how_far (fsck_progress_file (fs), &done, total, 1, fsck_quiet (fs)); /* at least one of nr_to_read blocks is to be checked */ bh = bread (fs->fs_dev, i, fs->fs_blocksize); if (!bh) { /* we were reading one block at time, and failed, so mark block bad */ fsck_progress ("pass1: Reading of the block %lu failed\n", i); continue; } what_node = who_is_this (bh->b_data, bh->b_size); if ( what_node != THE_LEAF ) { check_memory_msg(); die ("build_the_tree: Nothing but leaves are expected. Block %lu - %s\n", i, which_block(what_node)); } if (is_block_used (i) && !(block_of_journal (fs, i) && fsck_data(fs)->rebuild.use_journal_area)) /* block is in new tree already */ die ("build_the_tree: The leaf (%lu) is in the tree already\n", i); /* fprintf (block_list, "leaf %d\n", i + j);*/ pass_1_stat (fs)->leaves ++; /* the leaf may still contain indirect items with wrong slots. Fix that */ pass1_correct_leaf (fs, bh); if (get_blkh_nr_items (B_BLK_HEAD (bh)) == 0) { /* all items were deleted on pass 0 or pass 1 */ mark_buffer_clean (bh); brelse (bh); continue; } if (is_leaf_bad (bh)) { /* FIXME: will die */ fsck_log ("is_leaf_bad: WARNING: The leaf (%lu) is formatted badly. Will be handled on the the pass2.\n", bh->b_blocknr); mark_block_uninsertable (bh->b_blocknr); brelse (bh); continue; } if (block_of_journal (fs, i) && fsck_data(fs)->rebuild.use_journal_area) { /* FIXME: temporary thing */ if (tree_is_empty ()) { /* we insert inot tree only first leaf of journal */ unsigned long block; struct buffer_head * new_bh; block = alloc_block (); if (!block) die ("could not allocate block"); new_bh = getblk (bh->b_dev, block, bh->b_size); memcpy (new_bh->b_data, bh->b_data, bh->b_size); mark_buffer_uptodate (new_bh, 1); mark_buffer_dirty (new_bh); make_single_leaf_tree (new_bh); brelse (new_bh); brelse (bh); continue; } /* other blocks of journal will be inserted in pass 2 */ mark_block_uninsertable (bh->b_blocknr); brelse (bh); continue; } try_to_insert_pointer_to_leaf (bh); brelse (bh); } fsck_progress ("\n"); } static void after_pass_1 (reiserfs_filsys_t * fs) { time_t t; /* update fsck_state */ /* we should not flush bitmaps on disk after pass1, because new_bitmap contains only those blocks which are good leaves or just allocated internal blocks. */ set_sb_fs_state (fs->fs_ondisk_sb, PASS_1_DONE); mark_buffer_dirty (fs->fs_super_bh); /* write all dirty blocks */ fsck_progress ("Flushing.."); fs->fs_dirt = 1; reiserfs_flush (fs); fsck_progress ("finished\n"); stage_report (1, fs); /* we do not need this anymore */ delete_aux_bitmaps (); reiserfs_delete_bitmap (bad_unfm_in_tree_once_bitmap); if (!fsck_run_one_step (fs)) { if (fsck_user_confirmed (fs, "Continue? (Yes):", "Yes\n", 1)) /* reiserfsck continues */ return; } else save_pass_1_result (fs); if (proper_id_map (fs)) { /* when we run pass 1 only - we do not have proper_id_map */ id_map_free(proper_id_map (fs)); proper_id_map (fs) = 0; } time (&t); fsck_progress ("###########\n" "reiserfsck finished pass 1 at %s" "###########\n", ctime (&t)); fs->fs_dirt = 1; reiserfs_close (fs); exit(0); } void pass_1 (reiserfs_filsys_t * fs) { fsck_progress ("\nPass 1 (will try to insert %lu leaves):\n", reiserfs_bitmap_ones (fsck_source_bitmap (fs))); if (fsck_log_file (fs) != stderr) fsck_log ("####### Pass 1 #######\n"); before_pass_1 (fs); /* try to insert leaves found during pass 0 */ do_pass_1 (fs); after_pass_1 (fs); }