mkreiserfs.c

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

    }

    return;
}




static void set_hash_function (char * str)
{
    if (!strcmp (str, "tea"))
	    Hash = TEA_HASH;
    else if (!strcmp (str, "rupasov"))
	    Hash = YURA_HASH;
    else if (!strcmp (str, "r5"))
	    Hash = R5_HASH;
    else
	    message("wrong hash type specified. Using default");
}


static void set_reiserfs_version (char * str)
{
    if (!strcmp (str, "3.5"))
	    Format = "3.5";
    else  {
	    Format = "3.6";
	    if (strcmp (str, "3.6"))
		    message("wrong reiserfs version specified. "
			    "Using default 3.6 format");
    }
}

static int str2int (char * str)
{
    int val;
    char * tmp;

    val = (int) strtol (str, &tmp, 0);
    
    if (*tmp) {
	reiserfs_exit (1, "%s: strtol is unable to make an integer of %s\n",
		       program_name, str);
    }
    
    return val;
}


static void set_block_size (char * str, int *b_size)
{
    *b_size = str2int (str);
      
    if (!is_blocksize_correct (*b_size))
        reiserfs_exit (1, "%s: wrong blocksize %s specified, "
		       "only power of 2 from 512-8192 interval "
		       "are supported", program_name, str);
}


static void set_transaction_max_size (char * str)
{
	Max_trans_size = str2int( str );
}


/* reiserfs_create_journal will check this */
static void set_journal_device_size (char * str)
{
    Journal_size = str2int (str);
/*
    if (Journal_size < JOURNAL_MIN_SIZE)
		die ("%s: wrong journal size specified: %lu. Should be at least %u",
			 program_name, 
			 Journal_size + 1, JOURNAL_MIN_SIZE + 1);
*/
}


/* reiserfs_create_journal will check this */
static void set_offset_in_journal_device (char * str)
{
	Offset = str2int( str );
}


static int is_journal_default (char * name, char * jname, int blocksize)
{
    if (jname && strcmp (name, jname))
	return 0;
    
    if (Journal_size && Journal_size != 
	journal_default_size(REISERFS_DISK_OFFSET_IN_BYTES / blocksize, 
			     blocksize) + 1)
	/* journal size is set and it is not default size */
	return 0;
    
    if (Max_trans_size && Max_trans_size != JOURNAL_TRANS_MAX)
	return 0;

    return 1;
}

	
		
/* if running kernel is 2.2 - mkreiserfs creates 3.5 format, if 2.4 - 3.6,
   otherwise - mkreiserfs fails */
static int select_format (void)
{
	struct utsname sysinfo;

	if (Format) {
		if (!strcmp (Format, "3.5"))
			return REISERFS_FORMAT_3_5;

		if (strcmp (Format, "3.6")) {
			message ("Unknown fromat %s specified\n", Format);
			exit (1);
		}
		return REISERFS_FORMAT_3_6;
	}
	
	reiserfs_warning (stdout, "Guessing about desired format.. ");
	
	if (uname (&sysinfo) == -1) {
		message ("could not get system info: %s", strerror(errno));
		exit (1);
	}
	
	reiserfs_warning(stdout, "Kernel %s is running.\n", sysinfo.release);
	
	if (strncmp (sysinfo.release, "2.4", 3) >= 0)
		return REISERFS_FORMAT_3_6;

	if (strncmp (sysinfo.release, "2.2", 3)) {
		message( "You should run either 2.2 or 2.4 or higher to be able "
		    "to create reiserfs filesystem or specify desired format with --format");
		exit (1);
	}

    reiserfs_warning(stdout, "Creating filesystem of format 3.5\n");
    return REISERFS_FORMAT_3_5;
}


int main (int argc, char **argv)
{
    reiserfs_filsys_t * fs;
    int force = 0;
    char * device_name = NULL;
    char * jdevice_name = NULL;
    unsigned long fs_size = 0;
    int c;
    static int flag;

    program_name = strrchr( argv[ 0 ], '/' );
    
    if (program_name)
	program_name++;
    else
	program_name = argv[ 0 ];
    
    if (argc < 2)
	print_usage_and_exit ();
    
    memset(UUID, 0, 16);
    
    while (1) {
		static struct option options[] = {
			{"block-size", required_argument, 0, 'b'},
			{"journal-device", required_argument, 0, 'j'},
			{"journal-size", required_argument, 0, 's'},
			{"transaction-max-size", required_argument, 0, 't'},
			{"journal-offset", required_argument, 0, 'o'},
			{"badblocks", required_argument, 0, 'B'},
			{"hash", required_argument, 0, 'h'},
			{"uuid", required_argument, 0, 'u'},
			{"label", required_argument, 0, 'l'},
			{"format", required_argument, &flag, 1},
			{0, 0, 0, 0}
		};
		int option_index;
      
		c = getopt_long (argc, argv, "b:j:s:t:o:h:u:l:VfdB:q",
						 options, &option_index);
		if (c == -1)
			break;
	
		switch (c) {
		case 0:
			if (flag) {
				Format = optarg;
				flag = 0;
			}
			break;
		case 'b': /* --block-size */
			set_block_size (optarg, &Block_size);
			break;

		case 'j': /* --journal-device */
			Create_default_journal = 0;
			jdevice_name = optarg;
			break;

		case 's': /* --journal-size */
			Create_default_journal = 0;
			set_journal_device_size (optarg);	    
			break;

		case 't': /* --transaction-max-size */
			Create_default_journal = 0;
			set_transaction_max_size (optarg);
			break;

		case 'o': /* --offset */
			Create_default_journal = 0;
			set_offset_in_journal_device (optarg);
			break;

		case 'B': /* --badblock-list */
			asprintf (&badblocks_file, "%s", optarg);			
			break;
		
		case 'h': /* --hash */
			set_hash_function (optarg);
			break;

		case 'v': /* --format */
			set_reiserfs_version (optarg);
			break;

		case 'V':
			mode = DO_NOTHING;
			break;

		case 'f':
			force ++;
			break;

		case 'd':
			mode |= DEBUG_MODE;
			break;
		
		case 'u':
#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
			if (uuid_parse(optarg, UUID) < 0) {
			    reiserfs_warning(stderr, "Invalid UUID '%s' is "
					     "specified\n", optarg);
			    return 1;
			}
#else
			message ("Cannot set up the UUID, uuidlib was not "
				 "found by configure.\n");
			return 1;
#endif
			break;
		
		case 'l':
			LABEL = optarg;
			break;
		case 'q':
			mode |= QUIET_MODE;
			break;
		default:
			print_usage_and_exit();
		}
    }

    print_banner (program_name);

    misc_print_credit(stdout);
    printf("\n");
    
    if (mode & QUIET_MODE)
	fclose(stdout);
    
    if (mode == DO_NOTHING)
	    exit(0);

    /* device to be formatted */
    device_name = argv [optind];
    
    if (optind == argc - 2) {
        /* number of blocks for filesystem is specified */
        fs_size = str2int (argv[optind + 1]);
    } else if (optind == argc - 1) {
        /* number of blocks is not specified */
        if (!(fs_size = count_blocks (device_name, Block_size)))
		exit(1);
    } else {
        print_usage_and_exit ();
    }

    if (is_journal_default (device_name, jdevice_name, Block_size))
        Create_default_journal = 1;
    
    if (!(mode & QUIET_MODE) && !can_we_format_it (device_name, force))
        return 1;
	
    if (jdevice_name)
        if (!(mode & QUIET_MODE) && !can_we_format_it (jdevice_name, force))
            return 1;

    fs = reiserfs_create (device_name, select_format(), fs_size, Block_size, 
	Create_default_journal, 1);
    
    if (!fs) {
        return 1;
    }
		
    if (!reiserfs_create_journal (fs, jdevice_name, Offset, Journal_size, 
	Max_trans_size)) 
    {
        return 1;
    }

    if (!reiserfs_create_ondisk_bitmap (fs)) {
        return 1;
    }

    /* these fill buffers (super block, first bitmap, root block) with
       reiserfs structures */
#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
    if (!uuid_is_null(UUID) && fs->fs_format != REISERFS_FORMAT_3_6) {
	reiserfs_warning(stderr, "UUID can be specified only with 3.6 format\n");
	return 1;
    }
#endif

    if (badblocks_file) {
	if (create_badblock_bitmap (fs, badblocks_file))
	    exit(1);
    }


    make_super_block (fs);
    make_bitmap (fs);
    make_root_block (fs);
    add_badblock_list (fs, 1);

    report (fs, jdevice_name);

    if (!force && !(mode & QUIET_MODE)) {
        fprintf (stderr, "ATTENTION: YOU SHOULD REBOOT AFTER FDISK!\n"
                "\tALL DATA WILL BE LOST ON '%s'", device_name);
        if (jdevice_name && strcmp (jdevice_name, device_name))
            fprintf (stderr, " AND ON JOURNAL DEVICE '%s'", jdevice_name);

        if (!user_confirmed (stderr, "!\nContinue (y/n):", "y\n"))
            return 1;
    }


    invalidate_other_formats (fs->fs_dev);

    zero_journal (fs);

    reiserfs_close (fs);

    printf ("Syncing.."); fflush (stdout);
    sync ();
    printf ("ok\n");
 
    if (mode & DEBUG_MODE)
	return 0;
    
    printf("\nTell your friends to use a kernel based on 2.4.18 or "
	"later, and especially not a\nkernel based on 2.4.9, "
	"when you use reiserFS. Have fun.\n\n");
        
    printf("ReiserFS is successfully created on %s.\n", device_name);

    return 0;
}



/* 
 * Use BSD fomatting.
 * Local variables:
 * c-indentation-style: "bsd"
 * mode-name: "BSDC"
 * c-basic-offset: 4
 * tab-width: 4
 * End:
 */