super.c

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

                /* non-standard magic + bad sb_format */
                version = 0;
                magic_was_found = 3;
            }
        } else
            reiserfs_exit (EXIT_USER, "We opened device but there is no magic "
		"and there is no correct superblock format found.");

        if (magic_was_found == 1 || magic_was_found == 2)
            standard_journal = 1;
        else
            standard_journal = 0;

        if (version == 0)
            version = what_fs_version ();

        if (get_sb_block_count (sb) != block_count) {
            do {
                printf("\nDid you use resizer(y/n)[n]: ");
                getline (&answer, &n, stdin);
            } while(strcmp ("y\n", answer) && 
		    strcmp ("n\n", answer) && 
		    strcmp ("\n", answer));

            if (!strcmp ("y\n", answer)) {
                printf("\nEnter partition size [%lu]: ", block_count);
                getline (&answer, &n, stdin);
                if (strcmp ("\n", answer))
                    block_count = atoi (answer);
            } else {
                fsck_conditional_log (magic_was_found, "rebuild-sb: wrong block count "
		    "occured (%lu), fixed (%lu)\n", get_sb_block_count(sb), block_count);
            }

	    set_sb_block_count (sb, block_count);
        }

        if (get_sb_block_size (sb) != fs->fs_blocksize) {
            fsck_log("rebuild-sb: wrong block size occured (%lu), fixed (%lu)\n", 
		    get_sb_block_size (sb), fs->fs_blocksize);
  	    set_sb_block_size (sb, fs->fs_blocksize);
        }
    }

    /* if no reiserfs_found or bad data found in that SB, what was checked in previous 
     * clause */
    if (no_reiserfs_found (fs)) {
        int fd;

        fd = open (filename, O_RDWR | O_LARGEFILE);

        if (fd == -1) {
            reiserfs_exit (EXIT_OPER, "rebuils_sb: cannot open device %s", 
		filename);
	}

        version = what_fs_version ();

        if (version == 3 || version == 4) {
            retval = 4096;
        } else {
	    printf("\nEnter block size [4096]: \n");
	    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 block size specified\n");
		if (!is_blocksize_correct (retval))
		    reiserfs_exit (EXIT_USER, "rebuild_sb: wrong block size specified, "
			"only divisible by 1024 are supported currently\n");
	    } else
		retval = 4096;
	}

        if (!(block_count = count_blocks (filename, retval)))
		exit(EXIT_OPER);

        switch(version){
        case 1:
            fs = reiserfs_create (filename, REISERFS_FORMAT_3_6, block_count, retval, 1, 1);
            break;
        case 2:
            fs = reiserfs_create (filename, REISERFS_FORMAT_3_5, block_count, retval, 1, 1);
            break;
        case 3:
            fs = reiserfs_create (filename, REISERFS_FORMAT_3_6, block_count, retval, 1, 0);
            break;
        case 4:
            fs = reiserfs_create (filename, REISERFS_FORMAT_3_5, block_count, retval, 1, 0);
            break;
        }

	if (fs == NULL)
	    return;
	
        sb = fs->fs_ondisk_sb;
        fs->fs_vp = data;

        if (!fsck_skip_journal (fs)) {
            if (!fsck_data (fs)->journal_dev_name) {
                do {
                    printf("\nNo journal device was specified. (If journal is not "
			"available, re-run with --no-journal-available option specified).\n"
                        "Is journal default? (y/n)[y]: ");
		    
                    getline (&answer, &n, stdin);
                } while(strcmp ("y\n", answer) && 
			strcmp ("n\n", answer) && 
			strcmp ("\n", answer));
		
                if (!strcmp ("n\n", answer)) {
                    printf("\nSpecify journal device with -j option.\n");
                    exit(EXIT_USER);
                }
                standard_journal = 1;
            } else {
                standard_journal = 0;
                memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_JR_SUPER_MAGIC_STRING,
                    strlen (REISERFS_JR_SUPER_MAGIC_STRING));
            }
        }

        do {
            printf("\nDid you use resizer(y/n)[n]: ");
            getline (&answer, &n, stdin);
        } while (strcmp ("y\n", answer) && strcmp ("n\n", answer) && strcmp ("\n", answer));
        if (!strcmp ("y\n", answer)) {
            printf("\nEnter partition size [%lu]: ", block_count);
            getline (&answer, &n, stdin);
            if (strcmp ("\n", answer))
                block_count = atoi (answer);
            set_sb_block_count (sb, block_count);
        }
	
	set_sb_fs_state (sb, FS_ERROR);
    }


    if (version == 1 || version == 3) {
        if (get_reiserfs_format (sb) != REISERFS_FORMAT_3_6) {
            fsck_log("rebuild-sb: wrong reiserfs version occured (%lu), fixed (%lu)\n", 
		    get_reiserfs_format (sb), REISERFS_FORMAT_3_6);
            set_sb_version (sb, REISERFS_FORMAT_3_6);
        }
    } else if (version == 2 || version == 4) {
        if (get_reiserfs_format (sb) != REISERFS_FORMAT_3_5) {
            fsck_log("rebuild-sb: wrong reiserfs version occured (%lu), fixed (%lu)\n", 
		    get_reiserfs_format (sb), REISERFS_FORMAT_3_5);
            set_sb_version (sb, REISERFS_FORMAT_3_5);
        }
    }

    p_oid_maxsize = (fs->fs_blocksize - reiserfs_super_block_size (sb)) / 
	sizeof(__u32) / 2 * 2;
    
    if (get_sb_oid_maxsize (sb) != p_oid_maxsize) {
	fsck_log("rebuild-sb: wrong objectid map max size occured (%lu), fixed (%lu)\n", 
		get_sb_oid_maxsize (sb), p_oid_maxsize);
	set_sb_oid_maxsize (sb, p_oid_maxsize);
    }

    p_bmap_nr = (block_count + (fs->fs_blocksize * 8 - 1)) / (fs->fs_blocksize * 8);
    if (get_sb_bmap_nr (sb) != p_bmap_nr) {
	fsck_log("rebuild-sb: wrong bitmap number occured (%lu), fixed (%lu)\n", 
		get_sb_bmap_nr (sb), p_bmap_nr);
	set_sb_bmap_nr (sb, 
		(block_count + (fs->fs_blocksize * 8 - 1)) / (fs->fs_blocksize * 8));
    }

    if (get_sb_root_block (sb) > block_count) {
	fsck_log("rebuild-sb: wrong root block occured (%lu), zeroed\n", 
		get_sb_root_block (sb));
	set_sb_root_block (sb, 0);
    }

    if (get_sb_free_blocks (sb) > block_count) {
	fsck_log ("rebuild-sb: wrong free block count occured (%lu), zeroed\n", 
		get_sb_free_blocks (sb));
        set_sb_free_blocks (sb, 0);
    }

    if (get_sb_umount_state (sb) != FS_CLEANLY_UMOUNTED && 
	get_sb_umount_state (sb) != FS_NOT_CLEANLY_UMOUNTED) 
    {
	fsck_conditional_log (magic_was_found, "rebuild-sb: wrong umount state (%u), "
	    "fixed to (FS_NOT_CLEANLY_UMOUNTED)\n", get_sb_umount_state (sb));
        set_sb_umount_state (sb, FS_NOT_CLEANLY_UMOUNTED);
    }

    if (get_sb_oid_cursize (sb) == 1 || 
	get_sb_oid_cursize (sb) > get_sb_oid_maxsize (sb)) 
    {
        fsck_log("rebuild-sb: wrong objectid map occured (%lu), zeroed\n", 
	    get_sb_oid_cursize (sb));
	
        set_sb_oid_cursize (sb, 0);
    }

    if ( get_sb_tree_height (sb) &&
        ((get_sb_tree_height (sb) < DISK_LEAF_NODE_LEVEL + 1) ||
	(get_sb_tree_height (sb) > MAX_HEIGHT)) ) {
	fsck_log("rebuild-sb: wrong tree height occured (%u), zeroed\n", 
	    get_sb_tree_height (sb));

	set_sb_tree_height (sb, 0);
    }

    if (get_sb_hash_code (sb) && code2name (get_sb_hash_code (sb)) == 0) {
	fsck_log("rebuild-sb: wrong hash occured (%lu), zeroed\n", 
	    get_sb_hash_code (sb));
	
	set_sb_hash_code (sb, 0);
    }

    if (version == 1 || version == 3) {
#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
        if (uuid_is_null(sb->s_uuid)) {
	    uuid_generate(sb->s_uuid);
	    fsck_log ("rebuild-sb: no uuid found, a new uuid was "
		      "generated (%U)\n", sb->s_uuid);
        }
#endif
	if (sb->s_flags != 0 && sb->s_flags != 1) {
	    fsck_log ("rebuild-sb: super block flags found (%u), zeroed\n",
                  sb->s_flags);
	    sb->s_flags = 0;
	}
    }


    /*
    if we have a standard journal
        reserved = 0
        dev - same
        size = journal_default_size(fs->fs_super_bh->b_blocknr, fs)
        offset = journal_default_size(fs)
    if we have a non standard journal
        if we found magic string
            try to find a jhead and comare dev, size, offset there
            if params are not equal move to "if we did not find a magic string" clause
        if we did not find a magic string
            ask user about his journal
            try to find a jhead and comare dev, size, offset there
            if params are not equal exit with error
    */


    p_jp_journal_1st_block = get_journal_start_must (fs);

    if (standard_journal == 1) {
	if (get_jp_journal_dev (sb_jp(sb)) != 0) {
 	    fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal device "
		"occured (%lu), fixed (0)\n", get_jp_journal_dev (sb_jp(sb)));
 	    set_jp_journal_dev (sb_jp(sb), 0);
        }
        if (get_sb_reserved_for_journal (sb) != 0) {
 	    fsck_log ("rebuild-sb: wrong size reserved for default journal occured "
		"(%lu), fixed (0)\n", get_sb_reserved_for_journal (sb));
            set_sb_reserved_for_journal (sb, 0);
        }
        if (get_jp_journal_1st_block (sb_jp(sb)) != p_jp_journal_1st_block) {
            fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal first "
		"block occured (%lu), fixed (%lu)\n", get_jp_journal_1st_block (sb_jp(sb)),
		p_jp_journal_1st_block);
	    
            set_jp_journal_1st_block (sb_jp(sb) , p_jp_journal_1st_block);
        }
        if (get_jp_journal_size (sb_jp(sb)) != 
	    journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize)) 
	{
 	    fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal size "
		"occured (%lu), fixed (%lu)\n", get_jp_journal_size (sb_jp(sb)) + 1,
 	        journal_default_size (fs->fs_super_bh->b_blocknr, 
		fs->fs_blocksize) + 1);
	    
            set_jp_journal_size (sb_jp(sb), 
		journal_default_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize));
        }

	if ((retval = reiserfs_open_journal(fs, filename, O_RDWR | O_LARGEFILE))) {
	    fsck_log("\nrebuild-sb: Failed to open the journal device (%s).\n", 
		filename);

	    exit(retval < 0 ? EXIT_OPER : EXIT_USER);
	}	
    } else if (!fsck_skip_journal(fs)) {
	/* Check that specified non-standard journal device exists. */