From df4de2c089a4213ffad4681d90bd333db8d2192a Mon Sep 17 00:00:00 2001 From: David Sterba Date: Wed, 1 Jul 2015 17:49:21 +0200 Subject: [PATCH] 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 --- btrfs-convert.c | 15 ++++-- mkfs.c | 14 ++++-- utils.c | 154 ++++++++++++++++++++++++++++---------------------------- utils.h | 15 ++++-- 4 files changed, 112 insertions(+), 86 deletions(-) diff --git a/btrfs-convert.c b/btrfs-convert.c index 6cbba23..9bdf2be 100644 --- a/btrfs-convert.c +++ b/btrfs-convert.c @@ -2289,6 +2289,7 @@ static int do_convert(const char *devname, int datacsum, int packing, int noxatt struct btrfs_root *image_root; struct task_ctx ctx; char features_buf[64]; + struct btrfs_mkfs_config mkfs_cfg; ret = open_ext2fs(devname, &ext2_fs); 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("\tnodesize: %u\n", nodesize); printf("\tfeatures: %s\n", features_buf); - ret = make_btrfs(fd, devname, ext2_fs->super->s_volume_name, - NULL, blocks, total_bytes, nodesize, - blocksize, blocksize, features); + + mkfs_cfg.label = ext2_fs->super->s_volume_name; + 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) { fprintf(stderr, "unable to create initial ctree: %s\n", strerror(-ret)); diff --git a/mkfs.c b/mkfs.c index c5e1a6b..1cddaad 100644 --- a/mkfs.c +++ b/mkfs.c @@ -1187,7 +1187,6 @@ int main(int ac, char **av) 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; @@ -1198,6 +1197,7 @@ int main(int ac, char **av) char fs_uuid[BTRFS_UUID_UNPARSED_SIZE] = { 0 }; u64 features = BTRFS_MKFS_DEFAULT_FEATURES; struct mkfs_allocation allocation = { 0 }; + struct btrfs_mkfs_config mkfs_cfg; while(1) { int c; @@ -1507,8 +1507,16 @@ int main(int ac, char **av) features |= BTRFS_FEATURE_INCOMPAT_RAID56; } - ret = make_btrfs(fd, file, label, fs_uuid, blocks, dev_block_count, - nodesize, sectorsize, stripesize, features); + mkfs_cfg.label = label; + 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) { fprintf(stderr, "error during mkfs: %s\n", strerror(-ret)); exit(1); diff --git a/utils.c b/utils.c index b458e6b..fdb654c 100644 --- a/utils.c +++ b/utils.c @@ -177,9 +177,7 @@ int test_uuid_unique(char *fs_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, - u64 blocks[7], u64 num_bytes, u32 nodesize, - u32 sectorsize, u32 stripesize, u64 features) +int make_btrfs(int fd, const char *device, struct btrfs_mkfs_config *cfg) { struct btrfs_super_block super; 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; u32 array_size; u32 item_size; - int skinny_metadata = !!(features & + int skinny_metadata = !!(cfg->features & BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA); + u64 num_bytes; - first_free = BTRFS_SUPER_INFO_OFFSET + sectorsize * 2 - 1; - first_free &= ~((u64)sectorsize - 1); + first_free = BTRFS_SUPER_INFO_OFFSET + cfg->sectorsize * 2 - 1; + first_free &= ~((u64)cfg->sectorsize - 1); memset(&super, 0, sizeof(super)); - num_bytes = (num_bytes / sectorsize) * sectorsize; - if (fs_uuid && *fs_uuid) { - if (uuid_parse(fs_uuid, super.fsid) != 0) { - fprintf(stderr, "could not parse UUID: %s\n", fs_uuid); + num_bytes = (cfg->num_bytes / cfg->sectorsize) * cfg->sectorsize; + if (cfg->fs_uuid && *cfg->fs_uuid) { + if (uuid_parse(cfg->fs_uuid, super.fsid) != 0) { + fprintf(stderr, "could not parse UUID: %s\n", + cfg->fs_uuid); ret = -EINVAL; goto out; } - if (!test_uuid_unique(fs_uuid)) { - fprintf(stderr, "non-unique UUID: %s\n", fs_uuid); + if (!test_uuid_unique(cfg->fs_uuid)) { + fprintf(stderr, "non-unique UUID: %s\n", cfg->fs_uuid); ret = -EBUSY; goto out; } } else { uuid_generate(super.fsid); - if (fs_uuid) - uuid_unparse(super.fsid, fs_uuid); + if (cfg->fs_uuid) + uuid_unparse(super.fsid, cfg->fs_uuid); } uuid_generate(super.dev_item.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_magic(&super, BTRFS_MAGIC); btrfs_set_super_generation(&super, 1); - btrfs_set_super_root(&super, blocks[1]); - btrfs_set_super_chunk_root(&super, blocks[3]); + btrfs_set_super_root(&super, cfg->blocks[1]); + btrfs_set_super_chunk_root(&super, cfg->blocks[3]); btrfs_set_super_total_bytes(&super, num_bytes); - btrfs_set_super_bytes_used(&super, 6 * nodesize); - btrfs_set_super_sectorsize(&super, sectorsize); - btrfs_set_super_leafsize(&super, nodesize); - btrfs_set_super_nodesize(&super, nodesize); - btrfs_set_super_stripesize(&super, stripesize); + btrfs_set_super_bytes_used(&super, 6 * cfg->nodesize); + btrfs_set_super_sectorsize(&super, cfg->sectorsize); + btrfs_set_super_leafsize(&super, cfg->nodesize); + btrfs_set_super_nodesize(&super, cfg->nodesize); + btrfs_set_super_stripesize(&super, cfg->stripesize); btrfs_set_super_csum_type(&super, BTRFS_CSUM_TYPE_CRC32); btrfs_set_super_chunk_root_generation(&super, 1); btrfs_set_super_cache_generation(&super, -1); - btrfs_set_super_incompat_flags(&super, features); - if (label) - strncpy(super.label, label, BTRFS_LABEL_SIZE - 1); + btrfs_set_super_incompat_flags(&super, cfg->features); + if (cfg->label) + 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 */ - memset(buf->data, 0, nodesize); - buf->len = nodesize; - btrfs_set_header_bytenr(buf, blocks[1]); + memset(buf->data, 0, cfg->nodesize); + buf->len = cfg->nodesize; + btrfs_set_header_bytenr(buf, cfg->blocks[1]); btrfs_set_header_nritems(buf, 4); btrfs_set_header_generation(buf, 1); 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_size(inode_item, 3); 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_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); 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); nritems = 0; - itemoff = __BTRFS_LEAF_DATA_SIZE(nodesize) - sizeof(root_item); - btrfs_set_root_bytenr(&root_item, blocks[2]); + itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - sizeof(root_item); + btrfs_set_root_bytenr(&root_item, cfg->blocks[2]); btrfs_set_disk_key_objectid(&disk_key, BTRFS_EXTENT_TREE_OBJECTID); btrfs_set_item_key(buf, &disk_key, nritems); 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++; 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_item_key(buf, &disk_key, nritems); 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++; 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_item_key(buf, &disk_key, nritems); 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++; 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_item_key(buf, &disk_key, nritems); 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); - ret = pwrite(fd, buf->data, nodesize, blocks[1]); - if (ret != nodesize) { + ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[1]); + if (ret != cfg->nodesize) { ret = (ret < 0 ? -errno : -EIO); goto out; } /* create the items for the extent tree */ memset(buf->data + sizeof(struct btrfs_header), 0, - nodesize - sizeof(struct btrfs_header)); + cfg->nodesize - sizeof(struct btrfs_header)); nritems = 0; - itemoff = __BTRFS_LEAF_DATA_SIZE(nodesize); + itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize); for (i = 1; i < 7; i++) { item_size = sizeof(struct btrfs_extent_item); if (!skinny_metadata) item_size += sizeof(struct btrfs_tree_block_info); - BUG_ON(blocks[i] < first_free); - BUG_ON(blocks[i] < blocks[i - 1]); + BUG_ON(cfg->blocks[i] < first_free); + BUG_ON(cfg->blocks[i] < cfg->blocks[i - 1]); /* create extent item */ 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) { btrfs_set_disk_key_type(&disk_key, BTRFS_METADATA_ITEM_KEY); @@ -359,7 +359,7 @@ int make_btrfs(int fd, const char *device, const char *label, char *fs_uuid, } else { btrfs_set_disk_key_type(&disk_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_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 */ 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_type(&disk_key, BTRFS_TREE_BLOCK_REF_KEY); 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); 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_nritems(buf, nritems); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); - ret = pwrite(fd, buf->data, nodesize, blocks[2]); - if (ret != nodesize) { + ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[2]); + if (ret != cfg->nodesize) { ret = (ret < 0 ? -errno : -EIO); goto out; } /* create the chunk tree */ memset(buf->data + sizeof(struct btrfs_header), 0, - nodesize - sizeof(struct btrfs_header)); + cfg->nodesize - sizeof(struct btrfs_header)); nritems = 0; 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) */ 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_bytes_used(buf, dev_item, BTRFS_MKFS_SYSTEM_GROUP_SIZE); - btrfs_set_device_io_align(buf, dev_item, sectorsize); - btrfs_set_device_io_width(buf, dev_item, sectorsize); - btrfs_set_device_sector_size(buf, dev_item, sectorsize); + btrfs_set_device_io_align(buf, dev_item, cfg->sectorsize); + btrfs_set_device_io_width(buf, dev_item, cfg->sectorsize); + btrfs_set_device_sector_size(buf, dev_item, cfg->sectorsize); btrfs_set_device_type(buf, dev_item, 0); 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_stripe_len(buf, chunk, 64 * 1024); btrfs_set_chunk_type(buf, chunk, BTRFS_BLOCK_GROUP_SYSTEM); - btrfs_set_chunk_io_align(buf, chunk, sectorsize); - btrfs_set_chunk_io_width(buf, chunk, sectorsize); - btrfs_set_chunk_sector_size(buf, chunk, sectorsize); + btrfs_set_chunk_io_align(buf, chunk, cfg->sectorsize); + btrfs_set_chunk_io_width(buf, chunk, cfg->sectorsize); + btrfs_set_chunk_sector_size(buf, chunk, cfg->sectorsize); btrfs_set_chunk_num_stripes(buf, chunk, 1); btrfs_set_stripe_devid_nr(buf, chunk, 0, 1); 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; 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_nritems(buf, nritems); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); - ret = pwrite(fd, buf->data, nodesize, blocks[3]); - if (ret != nodesize) { + ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[3]); + if (ret != cfg->nodesize) { ret = (ret < 0 ? -errno : -EIO); goto out; } /* create the device tree */ memset(buf->data + sizeof(struct btrfs_header), 0, - nodesize - sizeof(struct btrfs_header)); + cfg->nodesize - sizeof(struct btrfs_header)); nritems = 0; - itemoff = __BTRFS_LEAF_DATA_SIZE(nodesize) - + itemoff = __BTRFS_LEAF_DATA_SIZE(cfg->nodesize) - sizeof(struct btrfs_dev_extent); 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); 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_nritems(buf, nritems); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); - ret = pwrite(fd, buf->data, nodesize, blocks[4]); - if (ret != nodesize) { + ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[4]); + if (ret != cfg->nodesize) { ret = (ret < 0 ? -errno : -EIO); goto out; } /* create the FS root */ memset(buf->data + sizeof(struct btrfs_header), 0, - nodesize - sizeof(struct btrfs_header)); - btrfs_set_header_bytenr(buf, blocks[5]); + cfg->nodesize - sizeof(struct btrfs_header)); + btrfs_set_header_bytenr(buf, cfg->blocks[5]); btrfs_set_header_owner(buf, BTRFS_FS_TREE_OBJECTID); btrfs_set_header_nritems(buf, 0); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); - ret = pwrite(fd, buf->data, nodesize, blocks[5]); - if (ret != nodesize) { + ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[5]); + if (ret != cfg->nodesize) { ret = (ret < 0 ? -errno : -EIO); goto out; } /* finally create the csum root */ memset(buf->data + sizeof(struct btrfs_header), 0, - nodesize - sizeof(struct btrfs_header)); - btrfs_set_header_bytenr(buf, blocks[6]); + cfg->nodesize - sizeof(struct btrfs_header)); + btrfs_set_header_bytenr(buf, cfg->blocks[6]); btrfs_set_header_owner(buf, BTRFS_CSUM_TREE_OBJECTID); btrfs_set_header_nritems(buf, 0); csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); - ret = pwrite(fd, buf->data, nodesize, blocks[6]); - if (ret != nodesize) { + ret = pwrite(fd, buf->data, cfg->nodesize, cfg->blocks[6]); + if (ret != cfg->nodesize) { ret = (ret < 0 ? -errno : -EIO); goto out; } /* and write out the super block */ - BUG_ON(sizeof(super) > sectorsize); - memset(buf->data, 0, sectorsize); + BUG_ON(sizeof(super) > cfg->sectorsize); + memset(buf->data, 0, cfg->sectorsize); memcpy(buf->data, &super, sizeof(super)); - buf->len = sectorsize; + buf->len = cfg->sectorsize; csum_tree_block_size(buf, BTRFS_CRC32_SIZE, 0); - ret = pwrite(fd, buf->data, sectorsize, blocks[0]); - if (ret != sectorsize) { + ret = pwrite(fd, buf->data, cfg->sectorsize, cfg->blocks[0]); + if (ret != cfg->sectorsize) { ret = (ret < 0 ? -errno : -EIO); goto out; } diff --git a/utils.h b/utils.h index 8ed18e1..1c76345 100644 --- a/utils.h +++ b/utils.h @@ -105,9 +105,18 @@ char* btrfs_parse_fs_features(char *namelist, u64 *flags); void btrfs_process_fs_features(u64 flags); void btrfs_parse_features_to_string(char *buf, u64 flags); -int make_btrfs(int fd, const char *device, const char *label, - char *fs_uuid, u64 blocks[6], u64 num_bytes, u32 nodesize, - u32 sectorsize, u32 stripesize, u64 features); +struct btrfs_mkfs_config { + char *label; + 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, struct btrfs_root *root, u64 objectid); int btrfs_prepare_device(int fd, char *file, int zero_end, u64 *block_count_ret, -- 2.7.4