marko10_000
/
btrfs-progs
forked from Mirrors/btrfs-progs
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

btrfs-progs: move make_btrfs arguments to a struct 

No functional change, just introduce the structure and switch current
users.

Signed-off-by: David Sterba <dsterba@suse.com>
master
David Sterba 2015-07-01 17:49:21 +02:00
parent f7a18e4cab
commit df4de2c089
4 changed files with 112 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
btrfs-convert.c
View File

@ -2289,6 +2289,7 @@ static int do_convert(const char *devname, int datacsum, int packing, int noxatt
struct btrfs_root *image_root; struct btrfs_root *image_root;
struct task_ctx ctx; struct task_ctx ctx;
char features_buf[64]; char features_buf[64];
struct btrfs_mkfs_config mkfs_cfg;
ret = open_ext2fs(devname, &ext2_fs); ret = open_ext2fs(devname, &ext2_fs);
if (ret) { if (ret) {
@ -2337,9 +2338,17 @@ static int do_convert(const char *devname, int datacsum, int packing, int noxatt
printf("\tblocksize: %u\n", blocksize); printf("\tblocksize: %u\n", blocksize);
printf("\tnodesize: %u\n", nodesize); printf("\tnodesize: %u\n", nodesize);
printf("\tfeatures: %s\n", features_buf); printf("\tfeatures: %s\n", features_buf);
ret = make_btrfs(fd, devname, ext2_fs->super->s_volume_name,
NULL, blocks, total_bytes, nodesize, mkfs_cfg.label = ext2_fs->super->s_volume_name;
blocksize, blocksize, features); mkfs_cfg.fs_uuid = NULL;
memcpy(mkfs_cfg.blocks, blocks, sizeof(blocks));
mkfs_cfg.num_bytes = total_bytes;
mkfs_cfg.nodesize = nodesize;
mkfs_cfg.sectorsize = blocksize;
mkfs_cfg.stripesize = blocksize;
mkfs_cfg.features = features;
ret = make_btrfs(fd, devname, &mkfs_cfg);
if (ret) { if (ret) {
fprintf(stderr, "unable to create initial ctree: %s\n", fprintf(stderr, "unable to create initial ctree: %s\n",
strerror(-ret)); strerror(-ret));

14
mkfs.c
View File

@ -1187,7 +1187,6 @@ int main(int ac, char **av)
int discard = 1; int discard = 1;
int ssd = 0; int ssd = 0;
int force_overwrite = 0; int force_overwrite = 0;
char *source_dir = NULL; char *source_dir = NULL;
int source_dir_set = 0; int source_dir_set = 0;
u64 num_of_meta_chunks = 0; u64 num_of_meta_chunks = 0;
@ -1198,6 +1197,7 @@ int main(int ac, char **av)
char fs_uuid[BTRFS_UUID_UNPARSED_SIZE] = { 0 }; char fs_uuid[BTRFS_UUID_UNPARSED_SIZE] = { 0 };
u64 features = BTRFS_MKFS_DEFAULT_FEATURES; u64 features = BTRFS_MKFS_DEFAULT_FEATURES;
struct mkfs_allocation allocation = { 0 }; struct mkfs_allocation allocation = { 0 };
struct btrfs_mkfs_config mkfs_cfg;
while(1) { while(1) {
int c; int c;
@ -1507,8 +1507,16 @@ int main(int ac, char **av)
features |= BTRFS_FEATURE_INCOMPAT_RAID56; features |= BTRFS_FEATURE_INCOMPAT_RAID56;
} }
ret = make_btrfs(fd, file, label, fs_uuid, blocks, dev_block_count, mkfs_cfg.label = label;
nodesize, sectorsize, stripesize, features); mkfs_cfg.fs_uuid = fs_uuid;
memcpy(mkfs_cfg.blocks, blocks, sizeof(blocks));
mkfs_cfg.num_bytes = dev_block_count;
mkfs_cfg.nodesize = nodesize;
mkfs_cfg.sectorsize = sectorsize;
mkfs_cfg.stripesize = stripesize;
mkfs_cfg.features = features;
ret = make_btrfs(fd, file, &mkfs_cfg);
if (ret) { if (ret) {
fprintf(stderr, "error during mkfs: %s\n", strerror(-ret)); fprintf(stderr, "error during mkfs: %s\n", strerror(-ret));
exit(1); exit(1);

154
utils.c
View File

@ -177,9 +177,7 @@ int test_uuid_unique(char *fs_uuid)
/* /*
* @fs_uuid - if NULL, generates a UUID, returns back the new filesystem UUID * @fs_uuid - if NULL, generates a UUID, returns back the new filesystem UUID
*/ */
int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid, int make_btrfs(int fd, const char *device, struct btrfs_mkfs_config *cfg)
u64 blocks[7], u64 num_bytes, u32 nodesize,
u32 sectorsize, u32 stripesize, u64 features)
{ {
struct btrfs_super_block super; struct btrfs_super_block super;
struct extent_buffer *buf = NULL; struct extent_buffer *buf = NULL;
@ -200,59 +198,61 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
u64 ref_root; u64 ref_root;
u32 array_size; u32 array_size;
u32 item_size; u32 item_size;
int skinny_metadata = !!(features & int skinny_metadata = !!(cfg->features &
BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA); BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA);
u64 num_bytes;
first_free = BTRFS_SUPER_INFO_OFFSET + sectorsize * 2 - 1; first_free = BTRFS_SUPER_INFO_OFFSET + cfg->sectorsize * 2 - 1;
first_free &= ~((u64)sectorsize - 1); first_free &= ~((u64)cfg->sectorsize - 1);
memset(&super, 0, sizeof(super)); memset(&super, 0, sizeof(super));
num_bytes = (num_bytes / sectorsize) * sectorsize; num_bytes = (cfg->num_bytes / cfg->sectorsize) * cfg->sectorsize;
if (fs_uuid && *fs_uuid) { if (cfg->fs_uuid && *cfg->fs_uuid) {
if (uuid_parse(fs_uuid, super.fsid) != 0) { if (uuid_parse(cfg->fs_uuid, super.fsid) != 0) {
fprintf(stderr, "could not parse UUID: %s\n", fs_uuid); fprintf(stderr, "could not parse UUID: %s\n",
cfg->fs_uuid);
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
} }
if (!test_uuid_unique(fs_uuid)) { if (!test_uuid_unique(cfg->fs_uuid)) {
fprintf(stderr, "non-unique UUID: %s\n", fs_uuid); fprintf(stderr, "non-unique UUID: %s\n", cfg->fs_uuid);
ret = -EBUSY; ret = -EBUSY;
goto out; goto out;
} }
} else { } else {
uuid_generate(super.fsid); uuid_generate(super.fsid);
if (fs_uuid) if (cfg->fs_uuid)
uuid_unparse(super.fsid, fs_uuid); uuid_unparse(super.fsid, cfg->fs_uuid);
} }
uuid_generate(super.dev_item.uuid); uuid_generate(super.dev_item.uuid);
uuid_generate(chunk_tree_uuid); uuid_generate(chunk_tree_uuid);
btrfs_set_super_bytenr(&super, blocks[0]); btrfs_set_super_bytenr(&super, cfg->blocks[0]);
btrfs_set_super_num_devices(&super, 1); btrfs_set_super_num_devices(&super, 1);
btrfs_set_super_magic(&super, BTRFS_MAGIC); btrfs_set_super_magic(&super, BTRFS_MAGIC);
btrfs_set_super_generation(&super, 1); btrfs_set_super_generation(&super, 1);
btrfs_set_super_root(&super, blocks[1]); btrfs_set_super_root(&super, cfg->blocks[1]);
btrfs_set_super_chunk_root(&super, blocks[3]); btrfs_set_super_chunk_root(&super, cfg->blocks[3]);
btrfs_set_super_total_bytes(&super, num_bytes); btrfs_set_super_total_bytes(&super, num_bytes);
btrfs_set_super_bytes_used(&super, 6 * nodesize); btrfs_set_super_bytes_used(&super, 6 * cfg->nodesize);
btrfs_set_super_sectorsize(&super, sectorsize); btrfs_set_super_sectorsize(&super, cfg->sectorsize);
btrfs_set_super_leafsize(&super, nodesize); btrfs_set_super_leafsize(&super, cfg->nodesize);
btrfs_set_super_nodesize(&super, nodesize); btrfs_set_super_nodesize(&super, cfg->nodesize);
btrfs_set_super_stripesize(&super, stripesize); btrfs_set_super_stripesize(&super, cfg->stripesize);
btrfs_set_super_csum_type(&super, BTRFS_CSUM_TYPE_CRC32); btrfs_set_super_csum_type(&super, BTRFS_CSUM_TYPE_CRC32);
btrfs_set_super_chunk_root_generation(&super, 1); btrfs_set_super_chunk_root_generation(&super, 1);
btrfs_set_super_cache_generation(&super, -1); btrfs_set_super_cache_generation(&super, -1);
btrfs_set_super_incompat_flags(&super, features); btrfs_set_super_incompat_flags(&super, cfg->features);
if (label) if (cfg->label)
strncpy(super.label, label, BTRFS_LABEL_SIZE - 1); strncpy(super.label, cfg->label, BTRFS_LABEL_SIZE - 1);
buf = malloc(sizeof(*buf) + max(sectorsize, nodesize)); buf = malloc(sizeof(*buf) + max(cfg->sectorsize, cfg->nodesize));
/* create the tree of root objects */ /* create the tree of root objects */
memset(buf->data, 0, nodesize); memset(buf->data, 0, cfg->nodesize);
buf->len = nodesize; buf->len = cfg->nodesize;
btrfs_set_header_bytenr(buf, blocks[1]); btrfs_set_header_bytenr(buf, cfg->blocks[1]);
btrfs_set_header_nritems(buf, 4); btrfs_set_header_nritems(buf, 4);
btrfs_set_header_generation(buf, 1); btrfs_set_header_generation(buf, 1);
btrfs_set_header_backref_rev(buf, BTRFS_MIXED_BACKREF_REV); btrfs_set_header_backref_rev(buf, BTRFS_MIXED_BACKREF_REV);
@ -270,10 +270,10 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
btrfs_set_stack_inode_generation(inode_item, 1); btrfs_set_stack_inode_generation(inode_item, 1);
btrfs_set_stack_inode_size(inode_item, 3); btrfs_set_stack_inode_size(inode_item, 3);
btrfs_set_stack_inode_nlink(inode_item, 1); btrfs_set_stack_inode_nlink(inode_item, 1);
btrfs_set_stack_inode_nbytes(inode_item, nodesize); btrfs_set_stack_inode_nbytes(inode_item, cfg->nodesize);
btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755); btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
btrfs_set_root_refs(&root_item, 1); btrfs_set_root_refs(&root_item, 1);
btrfs_set_root_used(&root_item, nodesize); btrfs_set_root_used(&root_item, cfg->nodesize);
btrfs_set_root_generation(&root_item, 1); btrfs_set_root_generation(&root_item, 1);
memset(&disk_key, 0, sizeof(disk_key)); memset(&disk_key, 0, sizeof(disk_key));
@ -281,8 +281,8 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
btrfs_set_disk_key_offset(&disk_key, 0); btrfs_set_disk_key_offset(&disk_key, 0);
nritems = 0; nritems = 0;
itemoff = __BTRFS_LEAF_DATA_SIZE(nodesize) - sizeof(root_item); itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - sizeof(root_item);
btrfs_set_root_bytenr(&root_item, blocks[2]); btrfs_set_root_bytenr(&root_item, cfg->blocks[2]);
btrfs_set_disk_key_objectid(&disk_key, BTRFS_EXTENT_TREE_OBJECTID); btrfs_set_disk_key_objectid(&disk_key, BTRFS_EXTENT_TREE_OBJECTID);
btrfs_set_item_key(buf, &disk_key, nritems); btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
@ -293,7 +293,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
nritems++; nritems++;
itemoff = itemoff - sizeof(root_item); itemoff = itemoff - sizeof(root_item);
btrfs_set_root_bytenr(&root_item, blocks[4]); btrfs_set_root_bytenr(&root_item, cfg->blocks[4]);
btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_TREE_OBJECTID); btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_TREE_OBJECTID);
btrfs_set_item_key(buf, &disk_key, nritems); btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
@ -305,7 +305,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
nritems++; nritems++;
itemoff = itemoff - sizeof(root_item); itemoff = itemoff - sizeof(root_item);
btrfs_set_root_bytenr(&root_item, blocks[5]); btrfs_set_root_bytenr(&root_item, cfg->blocks[5]);
btrfs_set_disk_key_objectid(&disk_key, BTRFS_FS_TREE_OBJECTID); btrfs_set_disk_key_objectid(&disk_key, BTRFS_FS_TREE_OBJECTID);
btrfs_set_item_key(buf, &disk_key, nritems); btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
@ -317,7 +317,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
nritems++; nritems++;
itemoff = itemoff - sizeof(root_item); itemoff = itemoff - sizeof(root_item);
btrfs_set_root_bytenr(&root_item, blocks[6]); btrfs_set_root_bytenr(&root_item, cfg->blocks[6]);
btrfs_set_disk_key_objectid(&disk_key, BTRFS_CSUM_TREE_OBJECTID); btrfs_set_disk_key_objectid(&disk_key, BTRFS_CSUM_TREE_OBJECTID);
btrfs_set_item_key(buf, &disk_key, nritems); btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff); btrfs_set_item_offset(buf, btrfs_item_nr(nritems), itemoff);
@ -330,28 +330,28 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
ret = pwrite(fd, buf->data, nodesize, blocks[1]); ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[1]);
if (ret != nodesize) { if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO); ret = (ret < 0 ? -errno : -EIO);
goto out; goto out;
} }
/* create the items for the extent tree */ /* create the items for the extent tree */
memset(buf->data + sizeof(struct btrfs_header), 0, memset(buf->data + sizeof(struct btrfs_header), 0,
nodesize - sizeof(struct btrfs_header)); cfg->nodesize - sizeof(struct btrfs_header));
nritems = 0; nritems = 0;
itemoff = __BTRFS_LEAF_DATA_SIZE(nodesize); itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize);
for (i = 1; i < 7; i++) { for (i = 1; i < 7; i++) {
item_size = sizeof(struct btrfs_extent_item); item_size = sizeof(struct btrfs_extent_item);
if (!skinny_metadata) if (!skinny_metadata)
item_size += sizeof(struct btrfs_tree_block_info); item_size += sizeof(struct btrfs_tree_block_info);
BUG_ON(blocks[i] < first_free); BUG_ON(cfg->blocks[i] < first_free);
BUG_ON(blocks[i] < blocks[i - 1]); BUG_ON(cfg->blocks[i] < cfg->blocks[i - 1]);
/* create extent item */ /* create extent item */
itemoff -= item_size; itemoff -= item_size;
btrfs_set_disk_key_objectid(&disk_key, blocks[i]); btrfs_set_disk_key_objectid(&disk_key, cfg->blocks[i]);
if (skinny_metadata) { if (skinny_metadata) {
btrfs_set_disk_key_type(&disk_key, btrfs_set_disk_key_type(&disk_key,
BTRFS_METADATA_ITEM_KEY); BTRFS_METADATA_ITEM_KEY);
@ -359,7 +359,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
} else { } else {
btrfs_set_disk_key_type(&disk_key, btrfs_set_disk_key_type(&disk_key,
BTRFS_EXTENT_ITEM_KEY); BTRFS_EXTENT_ITEM_KEY);
btrfs_set_disk_key_offset(&disk_key, nodesize); btrfs_set_disk_key_offset(&disk_key, cfg->nodesize);
} }
btrfs_set_item_key(buf, &disk_key, nritems); btrfs_set_item_key(buf, &disk_key, nritems);
btrfs_set_item_offset(buf, btrfs_item_nr(nritems), btrfs_set_item_offset(buf, btrfs_item_nr(nritems),
@ -376,7 +376,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
/* create extent ref */ /* create extent ref */
ref_root = reference_root_table[i]; ref_root = reference_root_table[i];
btrfs_set_disk_key_objectid(&disk_key, blocks[i]); btrfs_set_disk_key_objectid(&disk_key, cfg->blocks[i]);
btrfs_set_disk_key_offset(&disk_key, ref_root); btrfs_set_disk_key_offset(&disk_key, ref_root);
btrfs_set_disk_key_type(&disk_key, BTRFS_TREE_BLOCK_REF_KEY); btrfs_set_disk_key_type(&disk_key, BTRFS_TREE_BLOCK_REF_KEY);
btrfs_set_item_key(buf, &disk_key, nritems); btrfs_set_item_key(buf, &disk_key, nritems);
@ -385,22 +385,22 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
btrfs_set_item_size(buf, btrfs_item_nr(nritems), 0); btrfs_set_item_size(buf, btrfs_item_nr(nritems), 0);
nritems++; nritems++;
} }
btrfs_set_header_bytenr(buf, blocks[2]); btrfs_set_header_bytenr(buf, cfg->blocks[2]);
btrfs_set_header_owner(buf, BTRFS_EXTENT_TREE_OBJECTID); btrfs_set_header_owner(buf, BTRFS_EXTENT_TREE_OBJECTID);
btrfs_set_header_nritems(buf, nritems); btrfs_set_header_nritems(buf, nritems);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
ret = pwrite(fd, buf->data, nodesize, blocks[2]); ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[2]);
if (ret != nodesize) { if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO); ret = (ret < 0 ? -errno : -EIO);
goto out; goto out;
} }
/* create the chunk tree */ /* create the chunk tree */
memset(buf->data + sizeof(struct btrfs_header), 0, memset(buf->data + sizeof(struct btrfs_header), 0,
nodesize - sizeof(struct btrfs_header)); cfg->nodesize - sizeof(struct btrfs_header));
nritems = 0; nritems = 0;
item_size = sizeof(*dev_item); item_size = sizeof(*dev_item);
itemoff = __BTRFS_LEAF_DATA_SIZE(nodesize) - item_size; itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - item_size;
/* first device 1 (there is no device 0) */ /* first device 1 (there is no device 0) */
btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID); btrfs_set_disk_key_objectid(&disk_key, BTRFS_DEV_ITEMS_OBJECTID);
@ -416,9 +416,9 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
btrfs_set_device_total_bytes(buf, dev_item, num_bytes); btrfs_set_device_total_bytes(buf, dev_item, num_bytes);
btrfs_set_device_bytes_used(buf, dev_item, btrfs_set_device_bytes_used(buf, dev_item,
BTRFS_MKFS_SYSTEM_GROUP_SIZE); BTRFS_MKFS_SYSTEM_GROUP_SIZE);
btrfs_set_device_io_align(buf, dev_item, sectorsize); btrfs_set_device_io_align(buf, dev_item, cfg->sectorsize);
btrfs_set_device_io_width(buf, dev_item, sectorsize); btrfs_set_device_io_width(buf, dev_item, cfg->sectorsize);
btrfs_set_device_sector_size(buf, dev_item, sectorsize); btrfs_set_device_sector_size(buf, dev_item, cfg->sectorsize);
btrfs_set_device_type(buf, dev_item, 0); btrfs_set_device_type(buf, dev_item, 0);
write_extent_buffer(buf, super.dev_item.uuid, write_extent_buffer(buf, super.dev_item.uuid,
@ -447,9 +447,9 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
btrfs_set_chunk_owner(buf, chunk, BTRFS_EXTENT_TREE_OBJECTID); btrfs_set_chunk_owner(buf, chunk, BTRFS_EXTENT_TREE_OBJECTID);
btrfs_set_chunk_stripe_len(buf, chunk, 64 * 1024); btrfs_set_chunk_stripe_len(buf, chunk, 64 * 1024);
btrfs_set_chunk_type(buf, chunk, BTRFS_BLOCK_GROUP_SYSTEM); btrfs_set_chunk_type(buf, chunk, BTRFS_BLOCK_GROUP_SYSTEM);
btrfs_set_chunk_io_align(buf, chunk, sectorsize); btrfs_set_chunk_io_align(buf, chunk, cfg->sectorsize);
btrfs_set_chunk_io_width(buf, chunk, sectorsize); btrfs_set_chunk_io_width(buf, chunk, cfg->sectorsize);
btrfs_set_chunk_sector_size(buf, chunk, sectorsize); btrfs_set_chunk_sector_size(buf, chunk, cfg->sectorsize);
btrfs_set_chunk_num_stripes(buf, chunk, 1); btrfs_set_chunk_num_stripes(buf, chunk, 1);
btrfs_set_stripe_devid_nr(buf, chunk, 0, 1); btrfs_set_stripe_devid_nr(buf, chunk, 0, 1);
btrfs_set_stripe_offset_nr(buf, chunk, 0, 0); btrfs_set_stripe_offset_nr(buf, chunk, 0, 0);
@ -472,21 +472,21 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
ptr += item_size; ptr += item_size;
btrfs_set_super_sys_array_size(&super, array_size); btrfs_set_super_sys_array_size(&super, array_size);
btrfs_set_header_bytenr(buf, blocks[3]); btrfs_set_header_bytenr(buf, cfg->blocks[3]);
btrfs_set_header_owner(buf, BTRFS_CHUNK_TREE_OBJECTID); btrfs_set_header_owner(buf, BTRFS_CHUNK_TREE_OBJECTID);
btrfs_set_header_nritems(buf, nritems); btrfs_set_header_nritems(buf, nritems);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
ret = pwrite(fd, buf->data, nodesize, blocks[3]); ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[3]);
if (ret != nodesize) { if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO); ret = (ret < 0 ? -errno : -EIO);
goto out; goto out;
} }
/* create the device tree */ /* create the device tree */
memset(buf->data + sizeof(struct btrfs_header), 0, memset(buf->data + sizeof(struct btrfs_header), 0,
nodesize - sizeof(struct btrfs_header)); cfg->nodesize - sizeof(struct btrfs_header));
nritems = 0; nritems = 0;
itemoff = __BTRFS_LEAF_DATA_SIZE(nodesize) - itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) -
sizeof(struct btrfs_dev_extent); sizeof(struct btrfs_dev_extent);
btrfs_set_disk_key_objectid(&disk_key, 1); btrfs_set_disk_key_objectid(&disk_key, 1);
@ -511,49 +511,49 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid,
BTRFS_MKFS_SYSTEM_GROUP_SIZE); BTRFS_MKFS_SYSTEM_GROUP_SIZE);
nritems++; nritems++;
btrfs_set_header_bytenr(buf, blocks[4]); btrfs_set_header_bytenr(buf, cfg->blocks[4]);
btrfs_set_header_owner(buf, BTRFS_DEV_TREE_OBJECTID); btrfs_set_header_owner(buf, BTRFS_DEV_TREE_OBJECTID);
btrfs_set_header_nritems(buf, nritems); btrfs_set_header_nritems(buf, nritems);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
ret = pwrite(fd, buf->data, nodesize, blocks[4]); ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[4]);
if (ret != nodesize) { if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO); ret = (ret < 0 ? -errno : -EIO);
goto out; goto out;
} }
/* create the FS root */ /* create the FS root */
memset(buf->data + sizeof(struct btrfs_header), 0, memset(buf->data + sizeof(struct btrfs_header), 0,
nodesize - sizeof(struct btrfs_header)); cfg->nodesize - sizeof(struct btrfs_header));
btrfs_set_header_bytenr(buf, blocks[5]); btrfs_set_header_bytenr(buf, cfg->blocks[5]);
btrfs_set_header_owner(buf, BTRFS_FS_TREE_OBJECTID); btrfs_set_header_owner(buf, BTRFS_FS_TREE_OBJECTID);
btrfs_set_header_nritems(buf, 0); btrfs_set_header_nritems(buf, 0);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
ret = pwrite(fd, buf->data, nodesize, blocks[5]); ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[5]);
if (ret != nodesize) { if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO); ret = (ret < 0 ? -errno : -EIO);
goto out; goto out;
} }
/* finally create the csum root */ /* finally create the csum root */
memset(buf->data + sizeof(struct btrfs_header), 0, memset(buf->data + sizeof(struct btrfs_header), 0,
nodesize - sizeof(struct btrfs_header)); cfg->nodesize - sizeof(struct btrfs_header));
btrfs_set_header_bytenr(buf, blocks[6]); btrfs_set_header_bytenr(buf, cfg->blocks[6]);
btrfs_set_header_owner(buf, BTRFS_CSUM_TREE_OBJECTID); btrfs_set_header_owner(buf, BTRFS_CSUM_TREE_OBJECTID);
btrfs_set_header_nritems(buf, 0); btrfs_set_header_nritems(buf, 0);
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
ret = pwrite(fd, buf->data, nodesize, blocks[6]); ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[6]);
if (ret != nodesize) { if (ret != cfg->nodesize) {
ret = (ret < 0 ? -errno : -EIO); ret = (ret < 0 ? -errno : -EIO);
goto out; goto out;
} }
/* and write out the super block */ /* and write out the super block */
BUG_ON(sizeof(super) > sectorsize); BUG_ON(sizeof(super) > cfg->sectorsize);
memset(buf->data, 0, sectorsize); memset(buf->data, 0, cfg->sectorsize);
memcpy(buf->data, &super, sizeof(super)); memcpy(buf->data, &super, sizeof(super));
buf->len = sectorsize; buf->len = cfg->sectorsize;
csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0);
ret = pwrite(fd, buf->data, sectorsize, blocks[0]); ret = pwrite(fd, buf->data, cfg->sectorsize, cfg->blocks[0]);
if (ret != sectorsize) { if (ret != cfg->sectorsize) {
ret = (ret < 0 ? -errno : -EIO); ret = (ret < 0 ? -errno : -EIO);
goto out; goto out;
} }

15
utils.h
View File

@ -105,9 +105,18 @@ char* btrfs_parse_fs_features(char *namelist, u64 *flags);
void btrfs_process_fs_features(u64 flags); void btrfs_process_fs_features(u64 flags);
void btrfs_parse_features_to_string(char *buf, u64 flags); void btrfs_parse_features_to_string(char *buf, u64 flags);
int make_btrfs(int fd, const char *device, const char *label, struct btrfs_mkfs_config {
char *fs_uuid, u64 blocks[6], u64 num_bytes, u32 nodesize, char *label;
u32 sectorsize, u32 stripesize, u64 features); char *fs_uuid;
u64 blocks[8];
u64 num_bytes;
u32 nodesize;
u32 sectorsize;
u32 stripesize;
u64 features;
};
int make_btrfs(int fd, const char *device, struct btrfs_mkfs_config *cfg);
int btrfs_make_root_dir(struct btrfs_trans_handle *trans, int btrfs_make_root_dir(struct btrfs_trans_handle *trans,
struct btrfs_root *root, u64 objectid); struct btrfs_root *root, u64 objectid);
int btrfs_prepare_device(int fd, char *file, int zero_end, u64 *block_count_ret, int btrfs_prepare_device(int fd, char *file, int zero_end, u64 *block_count_ret,