super.c

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

	    
	journal_dev_name = fsck_data (fs)->journal_dev_name;	    
	retval = stat(journal_dev_name, &stat_buf);
	    
	if (retval == -1)
	    reiserfs_exit (EXIT_USER, "rebuild_sb: error while detecting the "
		"specified journal device (%s): %s\n", journal_dev_name,
		strerror(errno));
	
	retval = 0;
	if (magic_was_found) {
	    /* Super block was found. Try to open the journal on the base of its 
	     * journal parameters. */
	    
	    retval = reiserfs_open_journal(fs, journal_dev_name, 
		O_RDWR | O_LARGEFILE);
	    
	    if (retval == 0) {
		j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
		retval = memcmp(&j_head->jh_journal, sb_jp(sb), 
		    sizeof(struct journal_params));
	    
		if (retval) {
		    /* journal parameters from the SB and from the J_Header does not 
		     * match. Close the jouranl, ask the user about correct journal 
		     * parameters. */
		    reiserfs_close_journal(fs);
		}
	    }

	    if (!reiserfs_journal_opened(fs)) {
		fsck_log ("Journal cannot be opened, assuming specified "
			  "journal device is correct\n");
	    }
	}
	
	if (!reiserfs_journal_opened(fs)) {
	    __u64 default_value;

	    /* journal was not found or SB and J_Header parameters does not match. */
	    if (magic_was_found == 0)
                default_value = (!strcmp(fs->fs_file_name, journal_dev_name)) ? 
		    p_jp_journal_1st_block : 0;
            else
                default_value = get_jp_journal_1st_block (sb_jp(sb));

            printf("\nEnter journal offset on %s in blocks [%Lu]: \n",
            		journal_dev_name, (unsigned long long)default_value);

            getline (&answer, &n, stdin);
            if (strcmp(answer, "\n")) {
                retval = (int) strtol (answer, &tmp, 0);
                if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
                    reiserfs_exit(EXIT_USER, "rebuild_sb: wrong offset specified\n");

                set_jp_journal_1st_block (sb_jp(sb), retval);
            } else
                set_jp_journal_1st_block (sb_jp(sb), default_value);

            if (!(p_jp_dev_size = count_blocks (journal_dev_name, fs->fs_blocksize)))
		    exit(EXIT_OPER);

            /* some checks for journal offset */
            if (strcmp(fs->fs_file_name, journal_dev_name) != 0) {
                if (p_jp_dev_size < get_jp_journal_1st_block (sb_jp(sb)) + 1)
        	    reiserfs_exit(EXIT_USER, "rebuild_sb: offset is much than device size\n");
            }

            /* default size if magic was not found is device size - journal_1st_block;
               default size if magic was found is found value + 1 block for journal 
	       header */
            if (magic_was_found == 0)
                default_value = (!strcmp(fs->fs_file_name, journal_dev_name)) ?
                    journal_default_size (fs->fs_super_bh->b_blocknr,
					  fs->fs_blocksize) + 1 :
                    p_jp_dev_size - get_jp_journal_1st_block (sb_jp(sb));
            else
                default_value = get_jp_journal_size (sb_jp(sb)) + 1;
		

            printf("\nEnter journal size (including 1 block for journal header) on "
		"%s in blocks [%Lu]: \n", journal_dev_name, 
		(unsigned long long)default_value);

            getline (&answer, &n, stdin);
            if (strcmp(answer, "\n")) {
                retval = (int) strtol (answer, &tmp, 0);
                if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
        	    reiserfs_exit(EXIT_USER, "rebuild_sb: wrong offset specified\n");

                set_jp_journal_size (sb_jp(sb), retval - 1);
            } else {
                set_jp_journal_size (sb_jp(sb), default_value - 1);
            }

            /* some checks for journal size */
            if (get_jp_journal_size (sb_jp(sb)) +
                get_jp_journal_1st_block (sb_jp(sb)) + 1 > p_jp_dev_size)
        	    reiserfs_exit(EXIT_USER, "rebuild_sb: journal offset + journal size is "
			"greater than device size\n");
            
	    /* some checks for journal size */
            if (get_jp_journal_size (sb_jp(sb)) < JOURNAL_MIN_SIZE)
        	    reiserfs_exit(EXIT_USER, "rebuild_sb: journal size cannot be less than "
			"%lu blocks.\n", JOURNAL_MIN_SIZE + 1);

	    if ((retval = reiserfs_open_journal(fs, journal_dev_name, 
		O_RDWR | O_LARGEFILE)))
	    {
		fsck_log("\nrebuild-sb: Failed to open a journal device (%s).", 
		    journal_dev_name);
		
		exit(retval < 0 ? EXIT_OPER : EXIT_USER);
	    }
	
	    /* SB was found, but journal params were broken and have been recovered. 
	     * Futher work goes as SB would not be found. */
	    magic_was_found = 0;
	}
	
	if (strcmp (fs->fs_file_name, journal_dev_name))
	    set_jp_journal_dev (sb_jp(sb), stat_buf.st_rdev);
	else
	    set_jp_journal_dev (sb_jp(sb), 0);

    } else {
	fsck_log ("\nJournal was specified as not available. reiserfstune is "
	    "needed.\n\n");
	
	set_jp_journal_magic (sb_jp(sb), NEED_TUNE);
    }

    if (reiserfs_journal_opened(fs)) {
	/* Journal was openned. Check/fix journal parameters and copy it the journal 
	 * header. */
	
        if (get_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))
	{
 	    fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal max "
		"transaction length occured (%lu), fixed (%d)\n",
		get_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_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));
        }
	
        if (get_jp_journal_max_batch (sb_jp(sb)) != 
	    advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb)))) 
	{
 	    fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal max "
		"batch size occured (%lu), fixed (%d)\n", 
		get_jp_journal_max_batch (sb_jp(sb)), 
		advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))));
	    
 	    set_jp_journal_max_batch (sb_jp(sb), 
		advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))));
        }

        if (get_jp_journal_max_commit_age (sb_jp(sb)) != 
	    advise_journal_max_commit_age()) 
	{
 	    fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal "
		"max commit age occured (%lu), fixed (%d)\n", 
 	        get_jp_journal_max_commit_age (sb_jp(sb)), advise_journal_max_commit_age());
	    
 	    set_jp_journal_max_commit_age (sb_jp(sb), advise_journal_max_commit_age());
        }
	
        if (get_jp_journal_max_trans_age (sb_jp(sb)) != advise_journal_max_trans_age()) {
 	    fsck_log ("rebuild-sb: wrong journal  max commit age occured (%u), "
		"fixed (%u)\n", get_jp_journal_max_trans_age (sb_jp(sb)), 
		advise_journal_max_trans_age());
	    
 	    set_jp_journal_max_trans_age (sb_jp(sb), advise_journal_max_trans_age());
        }
		
	j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);

	if (standard_journal == 0) {
	    if (get_jp_journal_magic (sb_jp(sb)) == 0 || 
		get_jp_journal_magic (sb_jp(sb)) == NEED_TUNE) 
	    {
		int magic;
		
		magic = random();
		fsck_log ("rebuild-sb: genarate the new journal magic (%d)\n", magic);
		set_jp_journal_magic (sb_jp(sb), magic);
		set_jp_journal_magic (&j_head->jh_journal, magic);

	    }
	}
	
	retval = memcmp(&j_head->jh_journal, sb_jp(sb), sizeof(struct journal_params));
	
	if (retval) {
	    if (standard_journal == 1) {
		fsck_log("\nrebuild-sb: You either have a corrupted journal or have just "
		    "changed\nthe start of the partition with some partition table editor. "
		    "If you are\nsure that the start of the partition is ok, rebuild the "
		    "journal header.\n");
	    } else if (!magic_was_found) {
		fsck_log("\nrebuild-sb: journal header is not found. You either have "
		    "a corrupted,\nbad configured(device/offset/size), not available "
		    "journal or have just changed\nthe start of the journal partition "
		    "with some partition table editor. In the \ncase of corrupted "
		    "journal you need to use --no-journal-available. If you are\n"
		    "sure that the start of the partition is ok and journal is "
		    "available, rebuild\nthe journal header.\n");
	    }
	    
	    if (standard_journal || !magic_was_found) {
		if (!user_confirmed (stdout, "Do you want to rebuild the journal header? "
		    "(y/n)[n]: ", "y\n"))
		{
		    exit(EXIT_USER);
		} else 
		    exit_code = EXIT_FIXED;
	    }
	    
	    memcpy(&j_head->jh_journal, sb_jp(sb), sizeof(struct journal_params));
	    mark_buffer_dirty(fs->fs_jh_bh);
	    bwrite (fs->fs_jh_bh);
	}
    }
    
    /*  whether journal header contains params with the same dev, offset, size will be 
	checked in open_journal */

    if (version == 1 || version == 3)
        sb_size = SB_SIZE;
    else
        sb_size = SB_SIZE_V1;

    if (ondisk_sb == NULL || 
	memcmp(ondisk_sb, sb, sb_size - ((sb_size == SB_SIZE) ? 
	    sizeof(fs->fs_ondisk_sb->s_unused) : 0))) 
    {
        /* smth was changed in SB or a new one has been built */
	set_sb_fs_state (sb, get_sb_fs_state (sb) | FS_ERROR);
	
	if (ondisk_sb) {
	    /* if super_block was found, we keep sb in ondisk_sb */
	    fs->fs_ondisk_sb = ondisk_sb;
	    memcpy (ondisk_sb, sb, sb_size);
	    freemem(sb);
	}

	fflush(stdout); 
	print_block (stderr, fs, fs->fs_super_bh);
	
	if (user_confirmed (stderr, "Is this ok ? (y/n)[n]: ", "y\n")) {
	    mark_buffer_uptodate (fs->fs_super_bh, 1);
	    mark_buffer_dirty (fs->fs_super_bh);
	    bwrite (fs->fs_super_bh);
	    fsck_progress ("The fs may still be unconsistent. Run reiserfsck --check.\n\n");
	    exit_code = EXIT_FIXED;
	} else {
	    mark_buffer_clean (fs->fs_super_bh);
	    fsck_progress ("Super block was not written\n");
	}
    } else {
	print_block (stderr, fs, fs->fs_super_bh);
	
	mark_buffer_clean (fs->fs_super_bh);
	fsck_progress ("\nSuper block seems to be correct\n\n");
    }

    exit(exit_code);
}

/*	if (version == 0) {
	    brelse (fs->fs_super_bh);
            freemem (fs);
            close (fs->fs_dev);
            fs = NULL;
	}
*/