X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=mkfs%2Fmain.c;h=5a717f701cd5996feac23d81d5b2ffe48b72d81e;hb=546cea6f364cb5d51e589186503764595543123a;hp=61f746b30e7c454f31d390028feaf865bc93d634;hpb=b8888cb17659047c5964785d11ef0a1374ed4447;p=platform%2Fupstream%2Fbtrfs-progs.git diff --git a/mkfs/main.c b/mkfs/main.c index 61f746b..5a717f7 100644 --- a/mkfs/main.c +++ b/mkfs/main.c @@ -24,19 +24,14 @@ #include "ioctl.h" #include #include -#include -#include /* #include included via androidcompat.h */ #include +#include #include #include #include #include -#include -#include -#include #include -#include #include "ctree.h" #include "disk-io.h" #include "volumes.h" @@ -45,18 +40,11 @@ #include "list_sort.h" #include "help.h" #include "mkfs/common.h" +#include "mkfs/rootdir.h" #include "fsfeatures.h" -static u64 index_cnt = 2; static int verbose = 1; -struct directory_name_entry { - const char *dir_name; - const char *path; - ino_t inum; - struct list_head list; -}; - struct mkfs_allocation { u64 data; u64 metadata; @@ -67,6 +55,7 @@ struct mkfs_allocation { static int create_metadata_block_groups(struct btrfs_root *root, int mixed, struct mkfs_allocation *allocation) { + struct btrfs_fs_info *fs_info = root->fs_info; struct btrfs_trans_handle *trans; u64 bytes_used; u64 chunk_start = 0; @@ -74,19 +63,24 @@ static int create_metadata_block_groups(struct btrfs_root *root, int mixed, int ret; trans = btrfs_start_transaction(root, 1); - bytes_used = btrfs_super_bytes_used(root->fs_info->super_copy); + BUG_ON(IS_ERR(trans)); + bytes_used = btrfs_super_bytes_used(fs_info->super_copy); root->fs_info->system_allocs = 1; - ret = btrfs_make_block_group(trans, root, bytes_used, + /* + * First temporary system chunk must match the chunk layout + * created in make_btrfs(). + */ + ret = btrfs_make_block_group(trans, fs_info, bytes_used, BTRFS_BLOCK_GROUP_SYSTEM, - BTRFS_FIRST_CHUNK_TREE_OBJECTID, - 0, BTRFS_MKFS_SYSTEM_GROUP_SIZE); + BTRFS_BLOCK_RESERVED_1M_FOR_SUPER, + BTRFS_MKFS_SYSTEM_GROUP_SIZE); allocation->system += BTRFS_MKFS_SYSTEM_GROUP_SIZE; if (ret) return ret; if (mixed) { - ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root, + ret = btrfs_alloc_chunk(trans, fs_info, &chunk_start, &chunk_size, BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA); @@ -96,16 +90,15 @@ static int create_metadata_block_groups(struct btrfs_root *root, int mixed, } if (ret) return ret; - ret = btrfs_make_block_group(trans, root, 0, + ret = btrfs_make_block_group(trans, fs_info, 0, BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA, - BTRFS_FIRST_CHUNK_TREE_OBJECTID, chunk_start, chunk_size); if (ret) return ret; allocation->mixed += chunk_size; } else { - ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root, + ret = btrfs_alloc_chunk(trans, fs_info, &chunk_start, &chunk_size, BTRFS_BLOCK_GROUP_METADATA); if (ret == -ENOSPC) { @@ -114,9 +107,8 @@ static int create_metadata_block_groups(struct btrfs_root *root, int mixed, } if (ret) return ret; - ret = btrfs_make_block_group(trans, root, 0, + ret = btrfs_make_block_group(trans, fs_info, 0, BTRFS_BLOCK_GROUP_METADATA, - BTRFS_FIRST_CHUNK_TREE_OBJECTID, chunk_start, chunk_size); allocation->metadata += chunk_size; if (ret) @@ -134,12 +126,13 @@ static int create_data_block_groups(struct btrfs_trans_handle *trans, struct btrfs_root *root, int mixed, struct mkfs_allocation *allocation) { + struct btrfs_fs_info *fs_info = root->fs_info; u64 chunk_start = 0; u64 chunk_size = 0; int ret = 0; if (!mixed) { - ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root, + ret = btrfs_alloc_chunk(trans, fs_info, &chunk_start, &chunk_size, BTRFS_BLOCK_GROUP_DATA); if (ret == -ENOSPC) { @@ -148,9 +141,8 @@ static int create_data_block_groups(struct btrfs_trans_handle *trans, } if (ret) return ret; - ret = btrfs_make_block_group(trans, root, 0, + ret = btrfs_make_block_group(trans, fs_info, 0, BTRFS_BLOCK_GROUP_DATA, - BTRFS_FIRST_CHUNK_TREE_OBJECTID, chunk_start, chunk_size); allocation->data += chunk_size; if (ret) @@ -244,11 +236,12 @@ static int create_one_raid_group(struct btrfs_trans_handle *trans, struct mkfs_allocation *allocation) { + struct btrfs_fs_info *fs_info = root->fs_info; u64 chunk_start; u64 chunk_size; int ret; - ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root, + ret = btrfs_alloc_chunk(trans, fs_info, &chunk_start, &chunk_size, type); if (ret == -ENOSPC) { error("not enough free space to allocate chunk"); @@ -257,9 +250,8 @@ static int create_one_raid_group(struct btrfs_trans_handle *trans, if (ret) return ret; - ret = btrfs_make_block_group(trans, root->fs_info->extent_root, 0, - type, BTRFS_FIRST_CHUNK_TREE_OBJECTID, - chunk_start, chunk_size); + ret = btrfs_make_block_group(trans, fs_info, 0, + type, chunk_start, chunk_size); type &= BTRFS_BLOCK_GROUP_TYPE_MASK; if (type == BTRFS_BLOCK_GROUP_DATA) { @@ -317,13 +309,12 @@ static int create_raid_groups(struct btrfs_trans_handle *trans, return ret; } -static int create_data_reloc_tree(struct btrfs_trans_handle *trans, - struct btrfs_root *root) +static int create_tree(struct btrfs_trans_handle *trans, + struct btrfs_root *root, u64 objectid) { struct btrfs_key location; struct btrfs_root_item root_item; struct extent_buffer *tmp; - u64 objectid = BTRFS_DATA_RELOC_TREE_OBJECTID; int ret; ret = btrfs_copy_root(trans, root, root->node, &tmp, objectid); @@ -362,6 +353,7 @@ static void print_usage(int ret) printf(" creation:\n"); printf("\t-b|--byte-count SIZE set filesystem size to SIZE (on the first device)\n"); printf("\t-r|--rootdir DIR copy files from DIR to the image root directory\n"); + printf("\t--shrink (with --rootdir) shrink the filled filesystem to minimal size\n"); printf("\t-K|--nodiscard do not perform whole device TRIM\n"); printf("\t-f|--force force overwrite of existing filesystem\n"); printf(" general:\n"); @@ -410,742 +402,29 @@ static char *parse_label(const char *input) return strdup(input); } -static int add_directory_items(struct btrfs_trans_handle *trans, - struct btrfs_root *root, u64 objectid, - ino_t parent_inum, const char *name, - struct stat *st, int *dir_index_cnt) -{ - int ret; - int name_len; - struct btrfs_key location; - u8 filetype = 0; - - name_len = strlen(name); - - location.objectid = objectid; - location.offset = 0; - location.type = BTRFS_INODE_ITEM_KEY; - - if (S_ISDIR(st->st_mode)) - filetype = BTRFS_FT_DIR; - if (S_ISREG(st->st_mode)) - filetype = BTRFS_FT_REG_FILE; - if (S_ISLNK(st->st_mode)) - filetype = BTRFS_FT_SYMLINK; - - ret = btrfs_insert_dir_item(trans, root, name, name_len, - parent_inum, &location, - filetype, index_cnt); - if (ret) - return ret; - ret = btrfs_insert_inode_ref(trans, root, name, name_len, - objectid, parent_inum, index_cnt); - *dir_index_cnt = index_cnt; - index_cnt++; - - return ret; -} - -static int fill_inode_item(struct btrfs_trans_handle *trans, - struct btrfs_root *root, - struct btrfs_inode_item *dst, struct stat *src) -{ - u64 blocks = 0; - u64 sectorsize = root->sectorsize; - - /* - * btrfs_inode_item has some reserved fields - * and represents on-disk inode entry, so - * zero everything to prevent information leak - */ - memset(dst, 0, sizeof (*dst)); - - btrfs_set_stack_inode_generation(dst, trans->transid); - btrfs_set_stack_inode_size(dst, src->st_size); - btrfs_set_stack_inode_nbytes(dst, 0); - btrfs_set_stack_inode_block_group(dst, 0); - btrfs_set_stack_inode_nlink(dst, src->st_nlink); - btrfs_set_stack_inode_uid(dst, src->st_uid); - btrfs_set_stack_inode_gid(dst, src->st_gid); - btrfs_set_stack_inode_mode(dst, src->st_mode); - btrfs_set_stack_inode_rdev(dst, 0); - btrfs_set_stack_inode_flags(dst, 0); - btrfs_set_stack_timespec_sec(&dst->atime, src->st_atime); - btrfs_set_stack_timespec_nsec(&dst->atime, 0); - btrfs_set_stack_timespec_sec(&dst->ctime, src->st_ctime); - btrfs_set_stack_timespec_nsec(&dst->ctime, 0); - btrfs_set_stack_timespec_sec(&dst->mtime, src->st_mtime); - btrfs_set_stack_timespec_nsec(&dst->mtime, 0); - btrfs_set_stack_timespec_sec(&dst->otime, 0); - btrfs_set_stack_timespec_nsec(&dst->otime, 0); - - if (S_ISDIR(src->st_mode)) { - btrfs_set_stack_inode_size(dst, 0); - btrfs_set_stack_inode_nlink(dst, 1); - } - if (S_ISREG(src->st_mode)) { - btrfs_set_stack_inode_size(dst, (u64)src->st_size); - if (src->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) - btrfs_set_stack_inode_nbytes(dst, src->st_size); - else { - blocks = src->st_size / sectorsize; - if (src->st_size % sectorsize) - blocks += 1; - blocks *= sectorsize; - btrfs_set_stack_inode_nbytes(dst, blocks); - } - } - if (S_ISLNK(src->st_mode)) - btrfs_set_stack_inode_nbytes(dst, src->st_size + 1); - - return 0; -} - -static int directory_select(const struct direct *entry) -{ - if (entry->d_name[0] == '.' && - (entry->d_name[1] == 0 || - (entry->d_name[1] == '.' && entry->d_name[2] == 0))) - return 0; - return 1; -} - -static void free_namelist(struct direct **files, int count) -{ - int i; - - if (count < 0) - return; - - for (i = 0; i < count; ++i) - free(files[i]); - free(files); -} - -static u64 calculate_dir_inode_size(const char *dirname) -{ - int count, i; - struct direct **files, *cur_file; - u64 dir_inode_size = 0; - - count = scandir(dirname, &files, directory_select, NULL); - - for (i = 0; i < count; i++) { - cur_file = files[i]; - dir_inode_size += strlen(cur_file->d_name); - } - - free_namelist(files, count); - - dir_inode_size *= 2; - return dir_inode_size; -} - -static int add_inode_items(struct btrfs_trans_handle *trans, - struct btrfs_root *root, - struct stat *st, const char *name, - u64 self_objectid, - struct btrfs_inode_item *inode_ret) -{ - int ret; - struct btrfs_inode_item btrfs_inode; - u64 objectid; - u64 inode_size = 0; - - fill_inode_item(trans, root, &btrfs_inode, st); - objectid = self_objectid; - - if (S_ISDIR(st->st_mode)) { - inode_size = calculate_dir_inode_size(name); - btrfs_set_stack_inode_size(&btrfs_inode, inode_size); - } - - ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode); - - *inode_ret = btrfs_inode; - return ret; -} - -static int add_xattr_item(struct btrfs_trans_handle *trans, - struct btrfs_root *root, u64 objectid, - const char *file_name) -{ - int ret; - int cur_name_len; - char xattr_list[XATTR_LIST_MAX]; - char *cur_name; - char cur_value[XATTR_SIZE_MAX]; - char delimiter = '\0'; - char *next_location = xattr_list; - - ret = llistxattr(file_name, xattr_list, XATTR_LIST_MAX); - if (ret < 0) { - if(errno == ENOTSUP) - return 0; - error("getting a list of xattr failed for %s: %s", file_name, - strerror(errno)); - return ret; - } - if (ret == 0) - return ret; - - cur_name = strtok(xattr_list, &delimiter); - while (cur_name != NULL) { - cur_name_len = strlen(cur_name); - next_location += cur_name_len + 1; - - ret = getxattr(file_name, cur_name, cur_value, XATTR_SIZE_MAX); - if (ret < 0) { - if(errno == ENOTSUP) - return 0; - error("gettig a xattr value failed for %s attr %s: %s", - file_name, cur_name, strerror(errno)); - return ret; - } - - ret = btrfs_insert_xattr_item(trans, root, cur_name, - cur_name_len, cur_value, - ret, objectid); - if (ret) { - error("inserting a xattr item failed for %s: %s", - file_name, strerror(-ret)); - } - - cur_name = strtok(next_location, &delimiter); - } - - return ret; -} - -static int add_symbolic_link(struct btrfs_trans_handle *trans, - struct btrfs_root *root, - u64 objectid, const char *path_name) -{ - int ret; - char buf[PATH_MAX]; - - ret = readlink(path_name, buf, sizeof(buf)); - if (ret <= 0) { - error("readlink failed for %s: %s", path_name, strerror(errno)); - goto fail; - } - if (ret >= sizeof(buf)) { - error("symlink too long for %s", path_name); - ret = -1; - goto fail; - } - - buf[ret] = '\0'; /* readlink does not do it for us */ - ret = btrfs_insert_inline_extent(trans, root, objectid, 0, - buf, ret + 1); -fail: - return ret; -} - -static int add_file_items(struct btrfs_trans_handle *trans, - struct btrfs_root *root, - struct btrfs_inode_item *btrfs_inode, u64 objectid, - struct stat *st, const char *path_name) -{ - int ret = -1; - ssize_t ret_read; - u64 bytes_read = 0; - struct btrfs_key key; - int blocks; - u32 sectorsize = root->sectorsize; - u64 first_block = 0; - u64 file_pos = 0; - u64 cur_bytes; - u64 total_bytes; - struct extent_buffer *eb = NULL; - int fd; - - if (st->st_size == 0) - return 0; - - fd = open(path_name, O_RDONLY); - if (fd == -1) { - error("cannot open %s: %s", path_name, strerror(errno)); - return ret; - } - - blocks = st->st_size / sectorsize; - if (st->st_size % sectorsize) - blocks += 1; - - if (st->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) { - char *buffer = malloc(st->st_size); - - if (!buffer) { - ret = -ENOMEM; - goto end; - } - - ret_read = pread64(fd, buffer, st->st_size, bytes_read); - if (ret_read == -1) { - error("cannot read %s at offset %llu length %llu: %s", - path_name, (unsigned long long)bytes_read, - (unsigned long long)st->st_size, - strerror(errno)); - free(buffer); - goto end; - } - - ret = btrfs_insert_inline_extent(trans, root, objectid, 0, - buffer, st->st_size); - free(buffer); - goto end; - } - - /* round up our st_size to the FS blocksize */ - total_bytes = (u64)blocks * sectorsize; - - /* - * do our IO in extent buffers so it can work - * against any raid type - */ - eb = calloc(1, sizeof(*eb) + sectorsize); - if (!eb) { - ret = -ENOMEM; - goto end; - } - -again: - - /* - * keep our extent size at 1MB max, this makes it easier to work inside - * the tiny block groups created during mkfs - */ - cur_bytes = min(total_bytes, 1024ULL * 1024); - ret = btrfs_reserve_extent(trans, root, cur_bytes, 0, 0, (u64)-1, - &key, 1); - if (ret) - goto end; - - first_block = key.objectid; - bytes_read = 0; - - while (bytes_read < cur_bytes) { - - memset(eb->data, 0, sectorsize); - - ret_read = pread64(fd, eb->data, sectorsize, file_pos + bytes_read); - if (ret_read == -1) { - error("cannot read %s at offset %llu length %llu: %s", - path_name, - (unsigned long long)file_pos + bytes_read, - (unsigned long long)sectorsize, - strerror(errno)); - goto end; - } - - eb->start = first_block + bytes_read; - eb->len = sectorsize; - - /* - * we're doing the csum before we record the extent, but - * that's ok - */ - ret = btrfs_csum_file_block(trans, root->fs_info->csum_root, - first_block + bytes_read + sectorsize, - first_block + bytes_read, - eb->data, sectorsize); - if (ret) - goto end; - - ret = write_and_map_eb(root, eb); - if (ret) { - error("failed to write %s", path_name); - goto end; - } - - bytes_read += sectorsize; - } - - if (bytes_read) { - ret = btrfs_record_file_extent(trans, root, objectid, btrfs_inode, - file_pos, first_block, cur_bytes); - if (ret) - goto end; - - } - - file_pos += cur_bytes; - total_bytes -= cur_bytes; - - if (total_bytes) - goto again; - -end: - free(eb); - close(fd); - return ret; -} - -static char *make_path(const char *dir, const char *name) -{ - char *path; - - path = malloc(strlen(dir) + strlen(name) + 2); - if (!path) - return NULL; - strcpy(path, dir); - if (dir[strlen(dir) - 1] != '/') - strcat(path, "/"); - strcat(path, name); - return path; -} - -static int traverse_directory(struct btrfs_trans_handle *trans, - struct btrfs_root *root, const char *dir_name, - struct directory_name_entry *dir_head, int out_fd) -{ - int ret = 0; - - struct btrfs_inode_item cur_inode; - struct btrfs_inode_item *inode_item; - int count, i, dir_index_cnt; - struct direct **files; - struct stat st; - struct directory_name_entry *dir_entry, *parent_dir_entry; - struct direct *cur_file; - ino_t parent_inum, cur_inum; - ino_t highest_inum = 0; - const char *parent_dir_name; - char real_path[PATH_MAX]; - struct btrfs_path path; - struct extent_buffer *leaf; - struct btrfs_key root_dir_key; - u64 root_dir_inode_size = 0; - - /* Add list for source directory */ - dir_entry = malloc(sizeof(struct directory_name_entry)); - if (!dir_entry) - return -ENOMEM; - dir_entry->dir_name = dir_name; - dir_entry->path = realpath(dir_name, real_path); - if (!dir_entry->path) { - error("realpath failed for %s: %s", dir_name, strerror(errno)); - ret = -1; - goto fail_no_dir; - } - - parent_inum = highest_inum + BTRFS_FIRST_FREE_OBJECTID; - dir_entry->inum = parent_inum; - list_add_tail(&dir_entry->list, &dir_head->list); - - btrfs_init_path(&path); - - root_dir_key.objectid = btrfs_root_dirid(&root->root_item); - root_dir_key.offset = 0; - root_dir_key.type = BTRFS_INODE_ITEM_KEY; - ret = btrfs_lookup_inode(trans, root, &path, &root_dir_key, 1); - if (ret) { - error("failed to lookup root dir: %d", ret); - goto fail_no_dir; - } - - leaf = path.nodes[0]; - inode_item = btrfs_item_ptr(leaf, path.slots[0], - struct btrfs_inode_item); - - root_dir_inode_size = calculate_dir_inode_size(dir_name); - btrfs_set_inode_size(leaf, inode_item, root_dir_inode_size); - btrfs_mark_buffer_dirty(leaf); - - btrfs_release_path(&path); - - do { - parent_dir_entry = list_entry(dir_head->list.next, - struct directory_name_entry, - list); - list_del(&parent_dir_entry->list); - - parent_inum = parent_dir_entry->inum; - parent_dir_name = parent_dir_entry->dir_name; - if (chdir(parent_dir_entry->path)) { - error("chdir failed for %s: %s", - parent_dir_name, strerror(errno)); - ret = -1; - goto fail_no_files; - } - - count = scandir(parent_dir_entry->path, &files, - directory_select, NULL); - if (count == -1) - { - error("scandir failed for %s: %s", - parent_dir_name, strerror (errno)); - ret = -1; - goto fail; - } - - for (i = 0; i < count; i++) { - cur_file = files[i]; - - if (lstat(cur_file->d_name, &st) == -1) { - error("lstat failed for %s: %s", - cur_file->d_name, strerror(errno)); - ret = -1; - goto fail; - } - - cur_inum = st.st_ino; - ret = add_directory_items(trans, root, - cur_inum, parent_inum, - cur_file->d_name, - &st, &dir_index_cnt); - if (ret) { - error("unable to add directory items for %s: %d", - cur_file->d_name, ret); - goto fail; - } - - ret = add_inode_items(trans, root, &st, - cur_file->d_name, cur_inum, - &cur_inode); - if (ret == -EEXIST) { - if (st.st_nlink <= 1) { - error( - "item %s already exists but has wrong st_nlink %lu <= 1", - cur_file->d_name, - (unsigned long)st.st_nlink); - goto fail; - } - continue; - } - if (ret) { - error("unable to add inode items for %s: %d", - cur_file->d_name, ret); - goto fail; - } - - ret = add_xattr_item(trans, root, - cur_inum, cur_file->d_name); - if (ret) { - error("unable to add xattr items for %s: %d", - cur_file->d_name, ret); - if(ret != -ENOTSUP) - goto fail; - } - - if (S_ISDIR(st.st_mode)) { - dir_entry = malloc(sizeof(struct directory_name_entry)); - if (!dir_entry) { - ret = -ENOMEM; - goto fail; - } - dir_entry->dir_name = cur_file->d_name; - dir_entry->path = make_path(parent_dir_entry->path, - cur_file->d_name); - dir_entry->inum = cur_inum; - list_add_tail(&dir_entry->list, &dir_head->list); - } else if (S_ISREG(st.st_mode)) { - ret = add_file_items(trans, root, &cur_inode, - cur_inum, &st, - cur_file->d_name); - if (ret) { - error("unable to add file items for %s: %d", - cur_file->d_name, ret); - goto fail; - } - } else if (S_ISLNK(st.st_mode)) { - ret = add_symbolic_link(trans, root, - cur_inum, cur_file->d_name); - if (ret) { - error("unable to add symlink for %s: %d", - cur_file->d_name, ret); - goto fail; - } - } - } - - free_namelist(files, count); - free(parent_dir_entry); - - index_cnt = 2; - - } while (!list_empty(&dir_head->list)); - -out: - return !!ret; -fail: - free_namelist(files, count); -fail_no_files: - free(parent_dir_entry); - goto out; -fail_no_dir: - free(dir_entry); - goto out; -} - -static int create_chunks(struct btrfs_trans_handle *trans, - struct btrfs_root *root, u64 num_of_meta_chunks, - u64 size_of_data, - struct mkfs_allocation *allocation) -{ - u64 chunk_start; - u64 chunk_size; - u64 meta_type = BTRFS_BLOCK_GROUP_METADATA; - u64 data_type = BTRFS_BLOCK_GROUP_DATA; - u64 minimum_data_chunk_size = 8 * 1024 * 1024; - u64 i; - int ret; - - for (i = 0; i < num_of_meta_chunks; i++) { - ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root, - &chunk_start, &chunk_size, meta_type); - if (ret) - return ret; - ret = btrfs_make_block_group(trans, root->fs_info->extent_root, 0, - meta_type, BTRFS_FIRST_CHUNK_TREE_OBJECTID, - chunk_start, chunk_size); - allocation->metadata += chunk_size; - if (ret) - return ret; - set_extent_dirty(&root->fs_info->free_space_cache, - chunk_start, chunk_start + chunk_size - 1); - } - - if (size_of_data < minimum_data_chunk_size) - size_of_data = minimum_data_chunk_size; - - ret = btrfs_alloc_data_chunk(trans, root->fs_info->extent_root, - &chunk_start, size_of_data, data_type, 0); - if (ret) - return ret; - ret = btrfs_make_block_group(trans, root->fs_info->extent_root, 0, - data_type, BTRFS_FIRST_CHUNK_TREE_OBJECTID, - chunk_start, size_of_data); - allocation->data += size_of_data; - if (ret) - return ret; - set_extent_dirty(&root->fs_info->free_space_cache, - chunk_start, chunk_start + size_of_data - 1); - return ret; -} - -static int make_image(const char *source_dir, struct btrfs_root *root, - int out_fd) -{ - int ret; - struct btrfs_trans_handle *trans; - struct stat root_st; - struct directory_name_entry dir_head; - struct directory_name_entry *dir_entry = NULL; - - ret = lstat(source_dir, &root_st); - if (ret) { - error("unable to lstat %s: %s", source_dir, strerror(errno)); - ret = -errno; - goto out; - } - - INIT_LIST_HEAD(&dir_head.list); - - trans = btrfs_start_transaction(root, 1); - ret = traverse_directory(trans, root, source_dir, &dir_head, out_fd); - if (ret) { - error("unable to traverse directory %s: %d", source_dir, ret); - goto fail; - } - ret = btrfs_commit_transaction(trans, root); - if (ret) { - error("transaction commit failed: %d", ret); - goto out; - } - - if (verbose) - printf("Making image is completed.\n"); - return 0; -fail: - while (!list_empty(&dir_head.list)) { - dir_entry = list_entry(dir_head.list.next, - struct directory_name_entry, list); - list_del(&dir_entry->list); - free(dir_entry); - } -out: - return ret; -} - -/* - * This ignores symlinks with unreadable targets and subdirs that can't - * be read. It's a best-effort to give a rough estimate of the size of - * a subdir. It doesn't guarantee that prepopulating btrfs from this - * tree won't still run out of space. - */ -static u64 global_total_size; -static u64 fs_block_size; -static int ftw_add_entry_size(const char *fpath, const struct stat *st, - int type) -{ - if (type == FTW_F || type == FTW_D) - global_total_size += round_up(st->st_size, fs_block_size); - - return 0; -} - -static u64 size_sourcedir(const char *dir_name, u64 sectorsize, - u64 *num_of_meta_chunks_ret, u64 *size_of_data_ret) -{ - u64 dir_size = 0; - u64 total_size = 0; - int ret; - u64 default_chunk_size = 8 * 1024 * 1024; /* 8MB */ - u64 allocated_meta_size = 8 * 1024 * 1024; /* 8MB */ - u64 allocated_total_size = 20 * 1024 * 1024; /* 20MB */ - u64 num_of_meta_chunks = 0; - u64 num_of_data_chunks = 0; - u64 num_of_allocated_meta_chunks = - allocated_meta_size / default_chunk_size; - - global_total_size = 0; - fs_block_size = sectorsize; - ret = ftw(dir_name, ftw_add_entry_size, 10); - dir_size = global_total_size; - if (ret < 0) { - error("ftw subdir walk of %s failed: %s", dir_name, - strerror(errno)); - exit(1); - } - - num_of_data_chunks = (dir_size + default_chunk_size - 1) / - default_chunk_size; - - num_of_meta_chunks = (dir_size / 2) / default_chunk_size; - if (((dir_size / 2) % default_chunk_size) != 0) - num_of_meta_chunks++; - if (num_of_meta_chunks <= num_of_allocated_meta_chunks) - num_of_meta_chunks = 0; - else - num_of_meta_chunks -= num_of_allocated_meta_chunks; - - total_size = allocated_total_size + - (num_of_data_chunks * default_chunk_size) + - (num_of_meta_chunks * default_chunk_size); - - *num_of_meta_chunks_ret = num_of_meta_chunks; - *size_of_data_ret = num_of_data_chunks * default_chunk_size; - return total_size; -} - static int zero_output_file(int out_fd, u64 size) { int loop_num; u64 location = 0; - char buf[4096]; + char buf[SZ_4K]; int ret = 0, i; ssize_t written; - memset(buf, 0, 4096); - loop_num = size / 4096; + memset(buf, 0, SZ_4K); + + /* Only zero out the first 1M */ + loop_num = SZ_1M / SZ_4K; for (i = 0; i < loop_num; i++) { - written = pwrite64(out_fd, buf, 4096, location); - if (written != 4096) + written = pwrite64(out_fd, buf, SZ_4K, location); + if (written != SZ_4K) ret = -EIO; - location += 4096; + location += SZ_4K; } + + /* Then enlarge the file to size */ + written = pwrite64(out_fd, buf, 1, size - 1); + if (written < 1) + ret = -EIO; return ret; } @@ -1322,6 +601,7 @@ static int cleanup_temp_chunks(struct btrfs_fs_info *fs_info, btrfs_init_path(&path); trans = btrfs_start_transaction(root, 1); + BUG_ON(IS_ERR(trans)); key.objectid = 0; key.type = BTRFS_BLOCK_GROUP_ITEM_KEY; @@ -1335,6 +615,9 @@ static int cleanup_temp_chunks(struct btrfs_fs_info *fs_info, ret = btrfs_search_slot(trans, root, &key, &path, 0, 0); if (ret < 0) goto out; + /* Don't pollute ret for >0 case */ + if (ret > 0) + ret = 0; btrfs_item_key_to_cpu(path.nodes[0], &found_key, path.slots[0]); @@ -1389,6 +672,38 @@ out: return ret; } +/* + * Just update chunk allocation info, since --rootdir may allocate new + * chunks which is not updated in @allocation structure. + */ +static void update_chunk_allocation(struct btrfs_fs_info *fs_info, + struct mkfs_allocation *allocation) +{ + struct btrfs_block_group_cache *bg_cache; + const u64 mixed_flag = BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA; + u64 search_start = 0; + + allocation->mixed = 0; + allocation->data = 0; + allocation->metadata = 0; + allocation->system = 0; + while (1) { + bg_cache = btrfs_lookup_first_block_group(fs_info, + search_start); + if (!bg_cache) + break; + if ((bg_cache->flags & mixed_flag) == mixed_flag) + allocation->mixed += bg_cache->key.offset; + else if (bg_cache->flags & BTRFS_BLOCK_GROUP_DATA) + allocation->data += bg_cache->key.offset; + else if (bg_cache->flags & BTRFS_BLOCK_GROUP_METADATA) + allocation->metadata += bg_cache->key.offset; + else + allocation->system += bg_cache->key.offset; + search_start = bg_cache->key.objectid + bg_cache->key.offset; + } +} + int main(int argc, char **argv) { char *file; @@ -1406,8 +721,9 @@ int main(int argc, char **argv) u32 sectorsize = 4096; u32 stripesize = 4096; int zero_end = 1; - int fd; - int ret; + int fd = -1; + int ret = 0; + int close_ret; int i; int mixed = 0; int nodesize_forced = 0; @@ -1417,10 +733,11 @@ int main(int argc, char **argv) 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; + bool source_dir_set = false; + bool shrink_rootdir = false; u64 source_dir_size = 0; + u64 min_dev_size; + u64 shrink_size; int dev_cnt = 0; int saved_optind; char fs_uuid[BTRFS_UUID_UNPARSED_SIZE] = { 0 }; @@ -1430,6 +747,7 @@ int main(int argc, char **argv) while(1) { int c; + enum { GETOPT_VAL_SHRINK = 257 }; static const struct option long_options[] = { { "alloc-start", required_argument, NULL, 'A'}, { "byte-count", required_argument, NULL, 'b' }, @@ -1447,6 +765,7 @@ int main(int argc, char **argv) { "features", required_argument, NULL, 'O' }, { "uuid", required_argument, NULL, 'U' }, { "quiet", 0, NULL, 'q' }, + { "shrink", no_argument, NULL, GETOPT_VAL_SHRINK }, { "help", no_argument, NULL, GETOPT_VAL_HELP }, { NULL, 0, NULL, 0} }; @@ -1492,12 +811,12 @@ int main(int argc, char **argv) error("unrecognized filesystem feature '%s'", tmp); free(orig); - exit(1); + goto error; } free(orig); if (features & BTRFS_FEATURE_LIST_ALL) { btrfs_list_all_fs_features(0); - exit(0); + goto success; } break; } @@ -1511,11 +830,10 @@ int main(int argc, char **argv) case 'V': printf("mkfs.btrfs, part of %s\n", PACKAGE_STRING); - exit(0); - break; + goto success; case 'r': source_dir = optarg; - source_dir_set = 1; + source_dir_set = true; break; case 'U': strncpy(fs_uuid, optarg, @@ -1527,6 +845,9 @@ int main(int argc, char **argv) case 'q': verbose = 0; break; + case GETOPT_VAL_SHRINK: + shrink_rootdir = true; + break; case GETOPT_VAL_HELP: default: print_usage(c != GETOPT_VAL_HELP); @@ -1547,7 +868,11 @@ int main(int argc, char **argv) if (source_dir_set && dev_cnt > 1) { error("the option -r is limited to a single device"); - exit(1); + goto error; + } + if (shrink_rootdir && !source_dir_set) { + error("the option --shrink must be used with --rootdir"); + goto error; } if (*fs_uuid) { @@ -1555,19 +880,25 @@ int main(int argc, char **argv) if (uuid_parse(fs_uuid, dummy_uuid) != 0) { error("could not parse UUID: %s", fs_uuid); - exit(1); + goto error; } if (!test_uuid_unique(fs_uuid)) { error("non-unique UUID: %s", fs_uuid); - exit(1); + goto error; } } while (dev_cnt-- > 0) { file = argv[optind++]; - if (is_block_device(file) == 1) - if (test_dev_for_mkfs(file, force_overwrite)) - exit(1); + if (source_dir_set && is_path_exist(file) == 0) + ret = 0; + else if (is_block_device(file) == 1) + ret = test_dev_for_mkfs(file, force_overwrite); + else + ret = test_status_for_mkfs(file, force_overwrite); + + if (ret) + goto error; } optind = saved_optind; @@ -1602,7 +933,7 @@ int main(int argc, char **argv) if (metadata_profile != data_profile) { error( "with mixed block groups data and metadata profiles must be the same"); - exit(1); + goto error; } } @@ -1624,100 +955,123 @@ int main(int argc, char **argv) if (btrfs_check_nodesize(nodesize, sectorsize, features)) - exit(1); + goto error; if (sectorsize < sizeof(struct btrfs_super_block)) { error("sectorsize smaller than superblock: %u < %zu", sectorsize, sizeof(struct btrfs_super_block)); - exit(1); + goto error; } + min_dev_size = btrfs_min_dev_size(nodesize, mixed, metadata_profile, + data_profile); + /* + * Enlarge the destination file or create a new one, using the size + * calculated from source dir. + * + * This must be done before minimal device size checks. + */ + if (source_dir_set) { + int oflags = O_RDWR; + struct stat statbuf; + + if (is_path_exist(file) == 0) + oflags |= O_CREAT; + + fd = open(file, oflags, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | + S_IROTH); + if (fd < 0) { + error("unable to open %s: %m", file); + goto error; + } + + ret = fstat(fd, &statbuf); + if (ret < 0) { + error("unable to stat %s: %m", file); + ret = -errno; + goto error; + } + + /* + * Block_count not specified, use file/device size first. + * Or we will always use source_dir_size calculated for mkfs. + */ + if (!block_count) + block_count = btrfs_device_size(fd, &statbuf); + source_dir_size = btrfs_mkfs_size_dir(source_dir, sectorsize, + min_dev_size, metadata_profile, data_profile); + if (block_count < source_dir_size) + block_count = source_dir_size; + ret = zero_output_file(fd, block_count); + if (ret) { + error("unable to zero the output file"); + close(fd); + goto error; + } + /* our "device" is the new image file */ + dev_block_count = block_count; + close(fd); + } /* Check device/block_count after the nodesize is determined */ - if (block_count && block_count < btrfs_min_dev_size(nodesize)) { + if (block_count && block_count < min_dev_size) { error("size %llu is too small to make a usable filesystem", block_count); error("minimum size for btrfs filesystem is %llu", - btrfs_min_dev_size(nodesize)); - exit(1); + min_dev_size); + goto error; } for (i = saved_optind; i < saved_optind + dev_cnt; i++) { char *path; path = argv[i]; - ret = test_minimum_size(path, nodesize); + ret = test_minimum_size(path, min_dev_size); if (ret < 0) { - error("failed to check size for %s: %s", - path, strerror(-ret)); - exit (1); + error("failed to check size for %s: %m", path); + goto error; } if (ret > 0) { error("'%s' is too small to make a usable filesystem", path); error("minimum size for each btrfs device is %llu", - btrfs_min_dev_size(nodesize)); - exit(1); + min_dev_size); + goto error; } } ret = test_num_disk_vs_raid(metadata_profile, data_profile, dev_cnt, mixed, ssd); if (ret) - exit(1); + goto error; 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) { - error("unable to open %s: %s", file, strerror(errno)); - exit(1); - } - ret = btrfs_prepare_device(fd, file, &dev_block_count, - block_count, - (zero_end ? PREP_DEVICE_ZERO_END : 0) | - (discard ? PREP_DEVICE_DISCARD : 0) | - (verbose ? PREP_DEVICE_VERBOSE : 0)); - if (ret) { - close(fd); - exit(1); - } - if (block_count && block_count > dev_block_count) { - error("%s is smaller than requested size, expected %llu, found %llu", - file, - (unsigned long long)block_count, - (unsigned long long)dev_block_count); - exit(1); - } - } else { - fd = open(file, O_CREAT | O_RDWR, - S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH); - if (fd < 0) { - error("unable to open %s: %s", file, strerror(errno)); - exit(1); - } - - 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); - if (ret) { - error("unable to zero the output file"); - exit(1); - } - /* our "device" is the new image file */ - dev_block_count = block_count; + /* + * Open without O_EXCL so that the problem should not occur by the + * following operation in kernel: + * (btrfs_register_one_device() fails if O_EXCL is on) + */ + fd = open(file, O_RDWR); + if (fd < 0) { + error("unable to open %s: %m", file); + goto error; + } + ret = btrfs_prepare_device(fd, file, &dev_block_count, block_count, + (zero_end ? PREP_DEVICE_ZERO_END : 0) | + (discard ? PREP_DEVICE_DISCARD : 0) | + (verbose ? PREP_DEVICE_VERBOSE : 0)); + if (ret) + goto error; + if (block_count && block_count > dev_block_count) { + error("%s is smaller than requested size, expected %llu, found %llu", + file, (unsigned long long)block_count, + (unsigned long long)dev_block_count); + goto error; } /* To create the first block group and chunk 0 in make_btrfs */ if (dev_block_count < BTRFS_MKFS_SYSTEM_GROUP_SIZE) { error("device is too small to make filesystem, must be at least %llu", (unsigned long long)BTRFS_MKFS_SYSTEM_GROUP_SIZE); - exit(1); + goto error; } if (group_profile_max_safe_loss(metadata_profile) < @@ -1736,41 +1090,42 @@ int main(int argc, char **argv) ret = make_btrfs(fd, &mkfs_cfg); if (ret) { error("error during mkfs: %s", strerror(-ret)); - exit(1); + goto error; } fs_info = open_ctree_fs_info(file, 0, 0, 0, OPEN_CTREE_WRITES | OPEN_CTREE_FS_PARTIAL); if (!fs_info) { error("open ctree failed"); - close(fd); - exit(1); + goto error; } + close(fd); + fd = -1; root = fs_info->fs_root; fs_info->alloc_start = alloc_start; ret = create_metadata_block_groups(root, mixed, &allocation); if (ret) { error("failed to create default block groups: %d", ret); - exit(1); + goto error; } trans = btrfs_start_transaction(root, 1); - if (!trans) { + if (IS_ERR(trans)) { error("failed to start transaction"); - exit(1); + goto error; } ret = create_data_block_groups(trans, root, mixed, &allocation); if (ret) { error("failed to create default data block groups: %d", ret); - exit(1); + goto error; } ret = make_root_dir(trans, root); if (ret) { error("failed to setup the root directory: %d", ret); - exit(1); + goto error; } ret = btrfs_commit_transaction(trans, root); @@ -1780,9 +1135,9 @@ int main(int argc, char **argv) } trans = btrfs_start_transaction(root, 1); - if (!trans) { + if (IS_ERR(trans)) { error("failed to start transaction"); - exit(1); + goto error; } if (dev_cnt == 0) @@ -1798,8 +1153,8 @@ int main(int argc, char **argv) */ fd = open(file, O_RDWR); if (fd < 0) { - error("unable to open %s: %s", file, strerror(errno)); - exit(1); + error("unable to open %s: %m", file); + goto error; } ret = btrfs_device_already_in_root(root, fd, BTRFS_SUPER_INFO_OFFSET); @@ -1815,8 +1170,7 @@ int main(int argc, char **argv) (zero_end ? PREP_DEVICE_ZERO_END : 0) | (discard ? PREP_DEVICE_DISCARD : 0)); if (ret) { - close(fd); - exit(1); + goto error; } ret = btrfs_add_to_fsid(trans, root, fd, file, dev_block_count, @@ -1836,16 +1190,14 @@ int main(int argc, char **argv) } raid_groups: - if (!source_dir_set) { - ret = create_raid_groups(trans, root, data_profile, - metadata_profile, mixed, &allocation); - if (ret) { - error("unable to create raid groups: %d", ret); - goto out; - } + ret = create_raid_groups(trans, root, data_profile, + metadata_profile, mixed, &allocation); + if (ret) { + error("unable to create raid groups: %d", ret); + goto out; } - ret = create_data_reloc_tree(trans, root); + ret = create_tree(trans, root, BTRFS_DATA_RELOC_TREE_OBJECTID); if (ret) { error("unable to create data reloc tree: %d", ret); goto out; @@ -1857,27 +1209,6 @@ raid_groups: goto out; } - if (source_dir_set) { - trans = btrfs_start_transaction(root, 1); - ret = create_chunks(trans, root, - num_of_meta_chunks, size_of_data, - &allocation); - if (ret) { - error("unable to create chunks: %d", ret); - goto out; - } - ret = btrfs_commit_transaction(trans, root); - if (ret) { - error("transaction commit failed: %d", ret); - goto out; - } - - ret = make_image(source_dir, root, fd); - if (ret) { - error("error wihle filling filesystem: %d", ret); - goto out; - } - } ret = cleanup_temp_chunks(fs_info, &allocation, data_profile, metadata_profile, metadata_profile); if (ret < 0) { @@ -1885,9 +1216,27 @@ raid_groups: goto out; } + if (source_dir_set) { + ret = btrfs_mkfs_fill_dir(source_dir, root, verbose); + if (ret) { + error("error wihle filling filesystem: %d", ret); + goto out; + } + if (shrink_rootdir) { + ret = btrfs_mkfs_shrink_fs(fs_info, &shrink_size, + shrink_rootdir); + if (ret < 0) { + error("error while shrinking filesystem: %d", + ret); + goto out; + } + } + } + if (verbose) { char features_buf[64]; + update_chunk_allocation(fs_info, &allocation); printf("Label: %s\n", label); printf("UUID: %s\n", mkfs_cfg.fs_uuid); printf("Node size: %u\n", nodesize); @@ -1924,9 +1273,9 @@ raid_groups: */ fs_info->finalize_on_close = 1; out: - ret = close_ctree(root); + close_ret = close_ctree(root); - if (!ret) { + if (!close_ret) { optind = saved_optind; dev_cnt = argc - optind; while (dev_cnt-- > 0) { @@ -1940,4 +1289,12 @@ out: free(label); return !!ret; +error: + if (fd > 0) + close(fd); + + free(label); + exit(1); +success: + exit(0); }