main.c

reiserfsprogs-3.6.19.tar.gz 源码 给有需要的人！

	    printf("\n********************************************************************\n");
	    printf("* Warning: It was just detected that dma speed was descreased while*\n");
	    printf("* operating -- probably  due  to some  problem with your hardware. *\n");
	    printf("* Please check your hardware and have a look into the syslog file. *\n");
	    printf("* Note: running with --rebuild-tree on faulty hardware may destroy *\n");
	    printf("* your data.                                                       *\n");
	    printf("********************************************************************\n");
	    if (fsck_log_file (fs) != stdout)
		fsck_log("WARNING: dma speed has been descreased.\n");	    
	}
    }
    
    alarm(1);
}

void register_timer() {
    memset(&dma_info, 0, sizeof(dma_info));
    memset(&old_dma_info, 0, sizeof(old_dma_info));
    
    dma_info.fd = fs->fs_dev;

    if (prepare_dma_check(&dma_info) != 0)
	return;

    if (get_dma_info(&dma_info) == -1) {
	fsck_log("get_dma_info failed %s\n", strerror (errno));
	return;
    }

    if (dma_info.dma == 0) {
	printf("\n******************************************************\n");
	printf("* Warning: The dma on your hard drive is turned off. *\n");
	printf("* This may really slow down the fsck process.        *\n");
	printf("******************************************************\n");
	if (fsck_log_file (fs) != stdout)
	    fsck_log("WARNING: DMA is turned off\n");
    } 
    
    signal(SIGALRM, check_dma);
    alarm(1);
}

static void reset_super_block (reiserfs_filsys_t * fs)
{
    struct reiserfs_super_block * sb;
    struct reiserfs_journal_header * jh;
    
    sb = fs->fs_ondisk_sb;

    set_sb_free_blocks (sb, get_sb_block_count (sb));
    set_sb_root_block (sb, 0);
    set_sb_tree_height (sb, ~0);

    /* make file system invalid unless fsck finished () */
    set_sb_fs_state (sb, get_sb_fs_state (sb) | FS_FATAL);

/*
    if ( is_reiser2fs_jr_magic_string (sb) ) {???
	set_sb_version (sb, REISERFS_VERSION_3);
    }
    if (is_reiser2fs_magic_string (sb)) {
	set_sb_version (sb, REISERFS_FORMAT_3_6);
    }
    if (is_reiserfs_magic_string (sb)) {
	set_sb_version (sb, REISERFS_FORMAT_3_5);
    }
*/
    /* make sure that hash code in super block match to set hash function */
    set_sb_hash_code (sb, func2code (fs->fs_hash_function));
    
    if (fsck_hash_defined (fs)) {
	/* --hash was specifed */
	fs->fs_hash_function = name2func (fsck_data (fs)->rebuild.defined_hash);
	set_sb_hash_code (sb, func2code (fs->fs_hash_function));
    }
    
    if (reiserfs_journal_opened (fs)) {	
	jh = (struct reiserfs_journal_header *)fs->fs_jh_bh->b_data;
    
	/* reset journal params if needed. */
	if (memcmp(sb_jp(sb), &jh->jh_journal, sizeof (struct journal_params))) {
	    if (is_reiserfs_jr_magic_string (sb)) 
		memcpy (sb_jp(sb), &jh->jh_journal, sizeof (struct journal_params));
	    else {
		set_sb_reserved_for_journal (sb, 0);
	    
		set_jp_journal_dev (sb_jp(sb), 0);
		set_jp_journal_magic (sb_jp(sb), get_random());
		set_jp_journal_1st_block (sb_jp(sb), get_journal_start_must (fs));
		set_jp_journal_size (sb_jp(sb),
		    journal_default_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize));	    
		set_jp_journal_max_trans_len (sb_jp(sb),
		    advise_journal_max_trans_len(
			get_jp_journal_max_trans_len (sb_jp(sb)),
			get_jp_journal_size (sb_jp(sb)),
			fs->fs_blocksize, 0));
		set_jp_journal_max_batch (sb_jp(sb), 
		    advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))));
		set_jp_journal_max_commit_age (sb_jp(sb), advise_journal_max_commit_age());
		set_jp_journal_max_trans_age (sb_jp(sb), advise_journal_max_trans_age());
		
		set_jp_journal_dev (&jh->jh_journal, 0);
		set_jp_journal_magic (&jh->jh_journal, 
				      get_jp_journal_magic(sb_jp(sb)));
		set_jp_journal_1st_block (&jh->jh_journal, 
		    get_jp_journal_1st_block(sb_jp(sb)));
		set_jp_journal_size (&jh->jh_journal, get_jp_journal_size(sb_jp(sb)));
		set_jp_journal_max_trans_len (&jh->jh_journal, 
		    get_jp_journal_max_trans_len(sb_jp(sb)));
		set_jp_journal_max_batch (&jh->jh_journal, 
		    get_jp_journal_max_batch(sb_jp(sb)));
		set_jp_journal_max_commit_age (&jh->jh_journal, 
		    get_jp_journal_max_commit_age(sb_jp(sb)));
		set_jp_journal_max_trans_age (&jh->jh_journal, 
		    get_jp_journal_max_trans_age(sb_jp(sb))); 
	    }
	}
    }

    /* objectid map is not touched */
    mark_buffer_dirty (fs->fs_super_bh);
    bwrite (fs->fs_super_bh);
    if (!(fsck_data(fs)->options & OPT_SAVE_PASSES_DUMP))
        mark_buffer_do_not_flush (fs->fs_super_bh);
}


#define START_FROM_THE_BEGINNING 	1
#define START_FROM_PASS_1 		2
#define START_FROM_PASS_2 		3
#define START_FROM_SEMANTIC 		4
#define START_FROM_LOST_FOUND 		5
#define START_FROM_PASS_4 		6

/* this decides where to start from  */
static int where_to_start_from (reiserfs_filsys_t * fs)
{
    int ret;
    FILE * fp = 0;
    int last_run_state;
    
    last_run_state = get_sb_fs_state (fs->fs_ondisk_sb);
    if (last_run_state == 0 || !fsck_run_one_step (fs))
	/**/
	return START_FROM_THE_BEGINNING;
    
    /* We are able to perform the next step only if there is a file with the previous 
     * step results. */
    fp = open_file (state_dump_file (fs), "r");
    if (fp == 0) {
	set_sb_fs_state (fs->fs_ondisk_sb, 0);
	return START_FROM_THE_BEGINNING;
    }

    /* check start and end magics of dump file */
    ret = is_stage_magic_correct (fp);
    
    if (ret <= 0 || ret != last_run_state)
	return START_FROM_THE_BEGINNING;


    switch (last_run_state) {
    case PASS_0_DONE:
	/* skip pass 0 */
	if (!fsck_user_confirmed (fs, "Pass 0 seems finished. Start from pass 1?(Yes)",
				  "Yes\n", 1))
	    fsck_exit ("Run without -d then\n");
	
	load_pass_0_result (fp, fs);
	fclose (fp);
	return START_FROM_PASS_1;
	
    case PASS_1_DONE:
	/* skip pass 1 */
	if (!fsck_user_confirmed (fs, "Passes 0 and 1 seems finished. Start from "
	    "pass 2?(Yes)", "Yes\n", 1)) 
	{
	    fsck_exit ("Run without -d then\n");
	}
	
	load_pass_1_result (fp, fs);
	fclose (fp);
	return START_FROM_PASS_2;
	
    case TREE_IS_BUILT:
	if (!fsck_user_confirmed (fs, "Internal tree of filesystem looks built. "
	    "Skip rebuilding?(Yes)", "Yes\n", 1))
	{
	    fsck_exit ("Run without -d then\n");
	}
	
	load_pass_2_result (fs);
	fclose (fp);
	return START_FROM_SEMANTIC;
    case SEMANTIC_DONE:
	if (!fsck_user_confirmed (fs, "Passes 0 and 1 seems finished. Start from "
	    "pass 2?(Yes)", "Yes\n", 1))
	{
	    fsck_exit ("Run without -d then\n");
	}
	
	load_semantic_result (fp, fs);
	fclose (fp);
	return START_FROM_LOST_FOUND;
    case LOST_FOUND_DONE:
	if (!fsck_user_confirmed (fs, "Passes 0 and 1 seems finished. Start from "
	    "pass 2?(Yes)", "Yes\n", 1))
	{
	    fsck_exit ("Run without -d then\n");
	}
	
	load_lost_found_result (fs);
	fclose (fp);
	return START_FROM_PASS_4;
    }
    
    return START_FROM_THE_BEGINNING;
}


static void mark_filesystem_consistent (reiserfs_filsys_t * fs)
{
    if (!is_opened_rw (fs))
        return;

    if (!reiserfs_journal_opened (fs)) {
	/* make sure journal is not standard */
	if (!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb))
	    reiserfs_exit(EXIT_OPER, "Filesystem with default journal "
			  "must be opened.");
	
	fsck_progress ("WARNING: You must use reiserfstune to specify a new "
	    "journal before mounting it.\n");
	
	/* mark filesystem such that it is not mountable until 
	 * new journaldevice is defined */	
	set_jp_journal_magic (sb_jp (fs->fs_ondisk_sb), NEED_TUNE);
    }

    set_sb_umount_state (fs->fs_ondisk_sb, FS_CLEANLY_UMOUNTED);
    set_sb_fs_state (fs->fs_ondisk_sb, FS_CONSISTENT);
    
    mark_buffer_dirty (fs->fs_super_bh);
}

static void reiserfsck_replay_journal (reiserfs_filsys_t * fs) {
    struct reiserfs_super_block *on_place_sb;
    int sb_size = reiserfs_super_block_size(fs->fs_ondisk_sb);
    
    /* keep the super_block in the separate memory to avoid problems with replaying 
     * broken parameters. */
    on_place_sb = (struct reiserfs_super_block *)fs->fs_super_bh->b_data;
    fs->fs_ondisk_sb = getmem (sb_size);
    memcpy (fs->fs_ondisk_sb, on_place_sb, sb_size);

    replay_journal (fs);

    /* Copy checked reliable sb fields from backed up sb to a new one. */
    set_sb_block_count(on_place_sb, get_sb_block_count(fs->fs_ondisk_sb));
    memcpy(sb_jp(on_place_sb), sb_jp(fs->fs_ondisk_sb), 
	sizeof(struct journal_params));    
    set_sb_block_size(on_place_sb, get_sb_block_size(fs->fs_ondisk_sb));
    set_sb_oid_maxsize(on_place_sb, get_sb_oid_maxsize(fs->fs_ondisk_sb));
    memcpy(on_place_sb->s_v1.s_magic, fs->fs_ondisk_sb->s_v1.s_magic, 10);
    set_sb_hash_code(on_place_sb, get_sb_hash_code(fs->fs_ondisk_sb));
    set_sb_bmap_nr(on_place_sb, get_sb_bmap_nr(fs->fs_ondisk_sb));
    set_sb_version(on_place_sb, get_sb_version(fs->fs_ondisk_sb));
    set_sb_reserved_for_journal(on_place_sb, 
	get_sb_reserved_for_journal(fs->fs_ondisk_sb));
    
    if (sb_size == SB_SIZE) {
	set_sb_v2_flags(on_place_sb, get_sb_v2_flags(fs->fs_ondisk_sb));
	memcpy(on_place_sb->s_uuid, fs->fs_ondisk_sb->s_uuid, 16);
	memcpy(on_place_sb->s_label, fs->fs_ondisk_sb->s_label, 16);
    }

    /* get rid of SB copy */
    freemem (fs->fs_ondisk_sb);
    fs->fs_ondisk_sb = on_place_sb;
}

static int the_end (reiserfs_filsys_t * fs)
{
    struct reiserfs_super_block * sb;
    int ret = EXIT_FIXED;

    sb = fs->fs_ondisk_sb;

    /* put bitmap and objectid map on place */
    reiserfs_delete_bitmap (fs->fs_bitmap2);
    fs->fs_bitmap2 = fsck_new_bitmap (fs);
    if (!fs->fs_bitmap2->bm_dirty)
	die ("Bitmap not dirty");

//    id_map_flush(proper_id_map (fs), fs);
    id_map_flush(semantic_id_map (fs), fs);
    id_map_free(proper_id_map (fs));
    id_map_free(semantic_id_map (fs));

/*    set_sb_free_blocks (sb, reiserfs_bitmap_zeros (fsck_new_bitmap (fs)));*/

    mark_filesystem_consistent (fs);
    clear_buffer_do_not_flush (fs->fs_super_bh);

    if (fsck_data(fs)->mounted == MF_RO) {
	reiserfs_warning(stderr, "\nThe partition is mounted ro. It "
			 "is better to umount and mount it again.\n\n");
	ret = EXIT_REBOOT;
    }

    /* write all dirty blocks */
    fsck_progress ("Syncing..");
    fs->fs_dirt = 1;
    clean_after_dma_check(fs->fs_dev, &dma_info);
    reiserfs_close (fs);
    fsck_progress ("finished\n");

    return ret;
}

/* check umounted or read-only mounted filesystems only */
static void prepare_fs_for_check(reiserfs_filsys_t * fs) {
    /* The method could be called from auto_check already. */
    if (fs->fs_flags == O_RDWR) 
	return;

    reiserfs_reopen (fs, O_RDWR);
    
    fsck_data(fs)->mounted = misc_device_mounted(fs->fs_file_name);
    
    if (fsck_data(fs)->mounted > 0) {
	if (fsck_data(fs)->mounted == MF_RW) {
	    fsck_progress ("Partition %s is mounted with write permissions, "
		"cannot check it\n", fs->fs_file_name);
	    reiserfs_close(fs);
	    exit(EXIT_USER);
	}
	
	/* If not CHECK mode, lock the process in the memory. */
	if (fsck_mode (fs) != FSCK_CHECK) {
	    if (mlockall(MCL_CURRENT)) {
		    reiserfs_exit(EXIT_OPER, "Failed to lock the process to "
				  "fsck the mounted ro partition. %s.\n", 
				  strerror(errno));
	    }
	}
	
	if (fsck_skip_journal (fs)) {
		reiserfs_exit(EXIT_USER, "Jounrnal of the mounted "
			      "filesystem must be specified.\n");
	}
	
	if (!reiserfs_journal_opened (fs)) {
	    /* just to make sure */
	    reiserfs_panic ("Journal is not opened");
	} else if (reiserfs_journal_params_check(fs)) {
	    reiserfs_close (fs);
	    exit(EXIT_FATAL);
	}
	
	fsck_progress ("Filesystem seems mounted read-only. Skipping journal "
	    "replay.\n");
    } else if (!fsck_skip_journal (fs)) {
	if (reiserfs_journal_params_check(fs)) {
	    reiserfs_close (fs);
	    exit(EXIT_FATAL);
	}
	
	/* filesystem is not mounted, replay journal before checking */
        reiserfsck_replay_journal (fs);
    }
}

static void rebuild_tree (reiserfs_filsys_t * fs) {
    time_t t;
    int ret;

    init_rollback_file (state_rollback_file(fs), &fs->fs_blocksize, 
	fsck_data(fs)->log);
    
    prepare_fs_for_check(fs);
    
    ret = reiserfs_open_ondisk_bitmap (fs);
    if (ret < 0) {
        fsck_progress ("reiserfsck: Could not open bitmap\n");
	reiserfs_close (fs);
	exit(EXIT_OPER);
    } else if (ret > 0) {
	fsck_log("Zero bit found in on-disk bitmap after the last valid bit. "
	    "Fixed.\n");
    }
 
    time (&t);
    fsck_progress ("###########\n"
		   "reiserfsck --rebuild-tree started at %s"
		   "###########\n", ctime (&t));

    switch (where_to_start_from (fs)) {
    case START_FROM_THE_BEGINNING:
	reset_super_block (fs);
	pass_0 (fs);

    case START_FROM_PASS_1:
	reset_super_block (fs);
	pass_1 (fs);
	
    case START_FROM_PASS_2:
	pass_2 (fs);

    case START_FROM_SEMANTIC:
	pass_3_semantic (fs);

	/* if --lost+found is set - link unaccessed directories to lost+found
	   directory */
    case START_FROM_LOST_FOUND:	
	pass_3a_look_for_lost (fs);
	
    case START_FROM_PASS_4:
	/* 4. look for unaccessed items in the leaves */
	pass_4_check_unaccessed_items ();
	
	ret = the_end (fs);
    }

    close_rollback_file ();
       
    time (&t);
    fsck_progress ("###########\n"
		   "reiserfsck finished at %s"
		   "###########\n", ctime (&t));
    exit (ret);
}

static void clean_attributes (reiserfs_filsys_t * fs) {
    time_t t;

    time (&t);

    if (get_sb_umount_state (fs->fs_ondisk_sb) != FS_CLEANLY_UMOUNTED) {
        fsck_progress ("Filesystem is not clean\n"
	    "Check consistency of the partition first.\n");
        exit(EXIT_USER);
    }
    if (get_sb_fs_state (fs->fs_ondisk_sb) != FS_CONSISTENT) {
        fsck_progress ("Filesystem seems to be in unconsistent state.\n"
	    "Check consistency of the partition first.\n");
        exit(EXIT_USER);
    }