int main(int ac, char **av)
{
char *file;
struct btrfs_root *root;
struct btrfs_trans_handle *trans;
char *label = NULL;
char *first_file;
u64 block_count = 0;
u64 dev_block_count = 0;
u64 blocks[7];
u64 alloc_start = 0;
u64 metadata_profile = 0;
u64 data_profile = 0;
u32 leafsize = sysconf(_SC_PAGESIZE);
u32 sectorsize = 4096;
u32 nodesize = leafsize;
u32 stripesize = 4096;
int zero_end = 1;
int option_index = 0;
int fd;
int ret;
int i;
int mixed = 0;
int data_profile_opt = 0;
int metadata_profile_opt = 0;
int discard = 1;
int ssd = 0;
int force_overwrite = 0;
char *source_dir = NULL;
int source_dir_set = 0;
u64 num_of_meta_chunks = 0;
u64 size_of_data = 0;
u64 source_dir_size = 0;
int dev_cnt = 0;
int saved_optind;
char estr[100];
u64 features = 0;
while(1) {
int c;
c = getopt_long(ac, av, "A:b:fl:n:s:m:d:L:O:r:VMK",
long_options, &option_index);
if (c < 0)
break;
switch(c) {
case 'A':
alloc_start = parse_size(optarg);
break;
case 'f':
force_overwrite = 1;
break;
case 'd':
data_profile = parse_profile(optarg);
data_profile_opt = 1;
break;
case 'l':
case 'n':
nodesize = parse_size(optarg);
leafsize = parse_size(optarg);
break;
case 'L':
label = parse_label(optarg);
break;
case 'm':
metadata_profile = parse_profile(optarg);
metadata_profile_opt = 1;
break;
case 'M':
mixed = 1;
break;
case 'O': {
char *orig = strdup(optarg);
char *tmp = orig;
tmp = parse_fs_features(tmp, &features);
if (tmp) {
fprintf(stderr,
"Unrecognized filesystem feature '%s'\n",
tmp);
free(orig);
exit(1);
}
free(orig);
if (features & BTRFS_FEATURE_LIST_ALL) {
list_all_fs_features();
exit(0);
}
break;
}
case 's':
sectorsize = parse_size(optarg);
break;
case 'b':
block_count = parse_size(optarg);
if (block_count <= 1024*1024*1024) {
printf("SMALL VOLUME: forcing mixed "
"metadata/data groups\n");
mixed = 1;
}
zero_end = 0;
break;
case 'V':
print_version();
break;
case 'r':
source_dir = optarg;
source_dir_set = 1;
break;
case 'K':
discard = 0;
break;
default:
print_usage();
}
}
sectorsize = max(sectorsize, (u32)sysconf(_SC_PAGESIZE));
if (check_leaf_or_node_size(leafsize, sectorsize))
exit(1);
if (check_leaf_or_node_size(nodesize, sectorsize))
exit(1);
saved_optind = optind;
dev_cnt = ac - optind;
if (dev_cnt == 0)
print_usage();
if (source_dir_set && dev_cnt > 1) {
fprintf(stderr,
"The -r option is limited to a single device\n");
exit(1);
}
while (dev_cnt-- > 0) {
file = av[optind++];
if (is_block_device(file))
if (test_dev_for_mkfs(file, force_overwrite, estr)) {
fprintf(stderr, "Error: %s", estr);
exit(1);
}
}
optind = saved_optind;
dev_cnt = ac - optind;
file = av[optind++];
ssd = is_ssd(file);
if (is_vol_small(file)) {
printf("SMALL VOLUME: forcing mixed metadata/data groups\n");
mixed = 1;
if (metadata_profile != data_profile) {
if (metadata_profile_opt || data_profile_opt) {
fprintf(stderr,
"With mixed block groups data and metadata profiles must be the same\n");
exit(1);
}
}
}
/*
* Set default profiles according to number of added devices.
* For mixed groups defaults are single/single.
*/
if (!mixed) {
if (!metadata_profile_opt) {
if (dev_cnt == 1 && ssd)
printf("Detected a SSD, turning off metadata "
"duplication. Mkfs with -m dup if you want to "
"force metadata duplication.\n");
metadata_profile = (dev_cnt > 1) ?
BTRFS_BLOCK_GROUP_RAID1 : (ssd) ?
0: BTRFS_BLOCK_GROUP_DUP;
}
if (!data_profile_opt) {
data_profile = (dev_cnt > 1) ?
BTRFS_BLOCK_GROUP_RAID0 : 0; /* raid0 or single */
}
} else {
metadata_profile = 0;
data_profile = 0;
}
ret = test_num_disk_vs_raid(metadata_profile, data_profile,
dev_cnt, mixed, estr);
if (ret) {
fprintf(stderr, "Error: %s\n", estr);
exit(1);
}
/* if we are here that means all devs are good to btrfsify */
printf("\nWARNING! - %s IS EXPERIMENTAL\n", BTRFS_BUILD_VERSION);
printf("WARNING! - see http://btrfs.wiki.kernel.org before using\n\n");
dev_cnt--;
if (!source_dir_set) {
/*
* open without O_EXCL so that the problem should not
* occur by the following processing.
* (btrfs_register_one_device() fails if O_EXCL is on)
*/
fd = open(file, O_RDWR);
if (fd < 0) {
fprintf(stderr, "unable to open %s: %s\n", file,
strerror(errno));
exit(1);
}
first_file = file;
ret = btrfs_prepare_device(fd, file, zero_end, &dev_block_count,
block_count, &mixed, discard);
if (block_count && block_count > dev_block_count) {
fprintf(stderr, "%s is smaller than requested size\n", file);
exit(1);
}
} else {
fd = open_target(file);
if (fd < 0) {
fprintf(stderr, "unable to open the %s\n", file);
exit(1);
}
first_file = file;
source_dir_size = size_sourcedir(source_dir, sectorsize,
&num_of_meta_chunks, &size_of_data);
if(block_count < source_dir_size)
block_count = source_dir_size;
ret = zero_output_file(fd, block_count, sectorsize);
if (ret) {
fprintf(stderr, "unable to zero the output file\n");
exit(1);
}
/* our "device" is the new image file */
dev_block_count = block_count;
}
/* To create the first block group and chunk 0 in make_btrfs */
if (dev_block_count < BTRFS_MKFS_SYSTEM_GROUP_SIZE) {
fprintf(stderr, "device is too small to make filesystem\n");
exit(1);
}
blocks[0] = BTRFS_SUPER_INFO_OFFSET;
for (i = 1; i < 7; i++) {
blocks[i] = BTRFS_SUPER_INFO_OFFSET + 1024 * 1024 +
leafsize * i;
}
/*
* FS features that can be set by other means than -O
* just set the bit here
*/
if (mixed)
features |= BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS;
if ((data_profile | metadata_profile) &
(BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6)) {
features |= BTRFS_FEATURE_INCOMPAT_RAID56;
}
process_fs_features(features);
ret = make_btrfs(fd, file, label, blocks, dev_block_count,
nodesize, leafsize,
sectorsize, stripesize, features);
if (ret) {
fprintf(stderr, "error during mkfs: %s\n", strerror(-ret));
exit(1);
}
root = open_ctree(file, 0, OPEN_CTREE_WRITES);
if (!root) {
fprintf(stderr, "Open ctree failed\n");
close(fd);
exit(1);
}
root->fs_info->alloc_start = alloc_start;
ret = make_root_dir(root, mixed);
if (ret) {
fprintf(stderr, "failed to setup the root directory\n");
exit(1);
}
trans = btrfs_start_transaction(root, 1);
if (dev_cnt == 0)
goto raid_groups;
btrfs_register_one_device(file);
zero_end = 1;
while (dev_cnt-- > 0) {
int old_mixed = mixed;
file = av[optind++];
/*
* open without O_EXCL so that the problem should not
* occur by the following processing.
* (btrfs_register_one_device() fails if O_EXCL is on)
*/
fd = open(file, O_RDWR);
if (fd < 0) {
fprintf(stderr, "unable to open %s: %s\n", file,
strerror(errno));
exit(1);
}
ret = btrfs_device_already_in_root(root, fd,
BTRFS_SUPER_INFO_OFFSET);
if (ret) {
fprintf(stderr, "skipping duplicate device %s in FS\n",
file);
close(fd);
continue;
}
ret = btrfs_prepare_device(fd, file, zero_end, &dev_block_count,
block_count, &mixed, discard);
mixed = old_mixed;
BUG_ON(ret);
ret = btrfs_add_to_fsid(trans, root, fd, file, dev_block_count,
sectorsize, sectorsize, sectorsize);
BUG_ON(ret);
btrfs_register_one_device(file);
}
raid_groups:
if (!source_dir_set) {
ret = create_raid_groups(trans, root, data_profile,
data_profile_opt, metadata_profile,
metadata_profile_opt, mixed, ssd);
BUG_ON(ret);
}
ret = create_data_reloc_tree(trans, root);
BUG_ON(ret);
printf("fs created label %s on %s\n\tnodesize %u leafsize %u "
"sectorsize %u size %s\n",
label, first_file, nodesize, leafsize, sectorsize,
pretty_size(btrfs_super_total_bytes(root->fs_info->super_copy)));
printf("%s\n", BTRFS_BUILD_VERSION);
btrfs_commit_transaction(trans, root);
if (source_dir_set) {
trans = btrfs_start_transaction(root, 1);
ret = create_chunks(trans, root,
num_of_meta_chunks, size_of_data);
BUG_ON(ret);
btrfs_commit_transaction(trans, root);
ret = make_image(source_dir, root, fd);
BUG_ON(ret);
}
ret = close_ctree(root);
BUG_ON(ret);
free(label);
return 0;
}
int
main(int argc, char **argv)
{
FILE *fs;
int root_ino;
int len;
int ch;
extern int optind;
extern char *optarg;
fs = stdout; /* Send constructed file system to stdout by default */
while ((ch = getopt(argc, argv, "qa:d:e:v::o:h?")) != -1) {
switch((char)ch) {
case 'd':
len = strlen(optarg);
root_directory_name = (char *)malloc(len + 2);
memcpy(root_directory_name, optarg, len);
if (root_directory_name[len - 1] != '/')
{
root_directory_name[len++] = '/';
}
root_directory_name[len] = '\0';
break;
case 'v':
if (!optarg || strlen(optarg) == 0) {
verbose = 1;
}
else if (strlen(optarg) > 1 || !isdigit(optarg[0])) {
fprintf(stderr, "verbose level must be between 0 and 9!\n");
usage();
exit(1);
}
else {
verbose = strtol(optarg, NULL, 0);
}
break;
case 'o':
fs = fopen(optarg, "w");
if (!fs) {
fprintf(stderr, "unable to open file %s for output.\n", optarg);
exit(1);
}
break;
case 'a':
if (strcmp(optarg, "little") == 0) {
endian = ENDIAN_LITTLE;
}
else if (strcmp(optarg, "big") == 0) {
endian = ENDIAN_BIG;
}
else {
usage();
exit(1);
}
break;
case 'e':
MAX_CHUNK_SIZE = strtol(optarg, NULL, 0) / 2;
break;
case 'q':
squash = 1;
break;
case 'h':
case '?':
default:
usage();
exit(0);
}
}
if ((argc -= optind)) {
usage();
exit(1);
}
if (root_directory_name == NULL) {
fprintf(stderr, "Error: must specify a root directory\n");
usage();
exit(1);
}
if (verbose >= 1)
{
fprintf(stderr, "Constructing JFFS filesystem...\n");
}
root_ino = make_root_dir(fs, JFFS_MIN_INO, root_directory_name, 0);
mkfs(fs, root_directory_name, root_ino + 1, root_ino, 1);
fclose(fs);
free(root_directory_name);
exit(0);
}
int
main(int argc, char **argv)
{
FILE *fs;
int root_ino;
int len;
switch (argc)
{
case 1:
fprintf(stderr, "Too few arguments!\n");
usage();
exit(0);
case 2:
if ((strlen(argv[1]) <= 2) || (argv[1][0] != '-'))
{
usage();
exit(0);
}
if (argv[1][1] == 'd')
{
len = strlen(&argv[1][2]);
root_directory_name = (char *)malloc(len + 2);
memcpy(root_directory_name, &argv[1][2], len);
if (root_directory_name[len - 1] != '/')
{
root_directory_name[len++] = '/';
}
root_directory_name[len] = '\0';
}
else
{
fprintf(stderr, "Invalid option -- %c\n", argv[1][1]);
usage();
exit(0);
}
break;
case 3:
if ((strlen(argv[1]) != 2) || (argv[1][0] != '-'))
{
usage();
exit(0);
}
if (argv[1][1] != 'd')
{
fprintf(stderr, "Invalid option -- %c\n", argv[1][1]);
usage();
exit(0);
}
len = strlen(argv[2]);
root_directory_name = (char *)malloc(len + 2);
memcpy(root_directory_name, argv[2], len);
if (root_directory_name[len - 1] != '/')
{
root_directory_name[len++] = '/';
}
root_directory_name[len] = '\0';
break;
default:
fprintf(stderr, "Too many arguments!\n");
usage();
exit(0);
break;
}
fs = stdout; /* For now... */
if (verbose >= 1)
{
fprintf(stderr, "Constructing JFFS filesystem...\n");
}
root_ino = make_root_dir(fs, JFFS_MIN_INO, root_directory_name, 0);
mkfs(fs, root_directory_name, root_ino + 1, root_ino, 1);
fclose(fs);
free(root_directory_name);
exit(0);
}
