X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=disk-io.c;h=58eae709e0e8770732fe1a7d669712ebb9822e10;hb=a4cd4ae0b38a79fdc61aebf81267d5e10bb39d8f;hp=75daca8821cf16edec4794a696a6c52ff245fd9a;hpb=df2236d73bdffd69cf6d9aac7d80c880b4413aaa;p=platform%2Fupstream%2Fbtrfs-progs.git diff --git a/disk-io.c b/disk-io.c index 75daca8..58eae70 100644 --- a/disk-io.c +++ b/disk-io.c @@ -56,7 +56,7 @@ static int check_tree_block(struct btrfs_fs_info *fs_info, { struct btrfs_fs_devices *fs_devices; - u32 nodesize = btrfs_super_nodesize(fs_info->super_copy); + u32 nodesize = fs_info->nodesize; int ret = BTRFS_BAD_FSID; if (buf->start != btrfs_header_bytenr(buf)) @@ -67,6 +67,11 @@ static int check_tree_block(struct btrfs_fs_info *fs_info, nodesize)) return BTRFS_BAD_NRITEMS; + /* Only leaf can be empty */ + if (btrfs_header_nritems(buf) == 0 && + btrfs_header_level(buf) != 0) + return BTRFS_BAD_NRITEMS; + fs_devices = fs_info->fs_devices; while (fs_devices) { if (fs_info->ignore_fsid_mismatch || @@ -113,20 +118,20 @@ static void print_tree_block_error(struct btrfs_fs_info *fs_info, } } -u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len) +u32 btrfs_csum_data(char *data, u32 seed, size_t len) { return crc32c(seed, data, len); } -void btrfs_csum_final(u32 crc, char *result) +void btrfs_csum_final(u32 crc, u8 *result) { - *(__le32 *)result = ~cpu_to_le32(crc); + put_unaligned_le32(~crc, result); } static int __csum_tree_block_size(struct extent_buffer *buf, u16 csum_size, int verify, int silent) { - char result[BTRFS_CSUM_SIZE]; + u8 result[BTRFS_CSUM_SIZE]; u32 len; u32 crc = ~(u32)0; @@ -159,8 +164,8 @@ int verify_tree_block_csum_silent(struct extent_buffer *buf, u16 csum_size) return __csum_tree_block_size(buf, csum_size, 1, 1); } -static int csum_tree_block_fs_info(struct btrfs_fs_info *fs_info, - struct extent_buffer *buf, int verify) +int csum_tree_block(struct btrfs_fs_info *fs_info, + struct extent_buffer *buf, int verify) { u16 csum_size = btrfs_super_csum_size(fs_info->super_copy); @@ -169,41 +174,36 @@ static int csum_tree_block_fs_info(struct btrfs_fs_info *fs_info, return csum_tree_block_size(buf, csum_size, verify); } -int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf, - int verify) -{ - return csum_tree_block_fs_info(root->fs_info, buf, verify); -} - -struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root, +struct extent_buffer *btrfs_find_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr, u32 blocksize) { - return find_extent_buffer(&root->fs_info->extent_cache, + return find_extent_buffer(&fs_info->extent_cache, bytenr, blocksize); } struct extent_buffer* btrfs_find_create_tree_block( - struct btrfs_fs_info *fs_info, u64 bytenr, u32 blocksize) + struct btrfs_fs_info *fs_info, u64 bytenr) { - return alloc_extent_buffer(&fs_info->extent_cache, bytenr, blocksize); + return alloc_extent_buffer(&fs_info->extent_cache, bytenr, + fs_info->nodesize); } -void readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize, - u64 parent_transid) +void readahead_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr, + u64 parent_transid) { struct extent_buffer *eb; u64 length; struct btrfs_multi_bio *multi = NULL; struct btrfs_device *device; - eb = btrfs_find_tree_block(root, bytenr, blocksize); + eb = btrfs_find_tree_block(fs_info, bytenr, fs_info->nodesize); if (!(eb && btrfs_buffer_uptodate(eb, parent_transid)) && - !btrfs_map_block(&root->fs_info->mapping_tree, READ, - bytenr, &length, &multi, 0, NULL)) { + !btrfs_map_block(fs_info, READ, bytenr, &length, &multi, 0, + NULL)) { device = multi->stripes[0].dev; device->total_ios++; - blocksize = min(blocksize, (u32)(64 * 1024)); - readahead(device->fd, multi->stripes[0].physical, blocksize); + readahead(device->fd, multi->stripes[0].physical, + fs_info->nodesize); } free_extent_buffer(eb); @@ -236,7 +236,7 @@ static int verify_parent_transid(struct extent_io_tree *io_tree, ret = 1; out: - clear_extent_buffer_uptodate(io_tree, eb); + clear_extent_buffer_uptodate(eb); return ret; } @@ -257,9 +257,8 @@ int read_whole_eb(struct btrfs_fs_info *info, struct extent_buffer *eb, int mirr if (!info->on_restoring && eb->start != BTRFS_SUPER_INFO_OFFSET) { - ret = btrfs_map_block(&info->mapping_tree, READ, - eb->start + offset, &read_len, &multi, - mirror, NULL); + ret = btrfs_map_block(info, READ, eb->start + offset, + &read_len, &multi, mirror, NULL); if (ret) { printk("Couldn't map the block %Lu\n", eb->start + offset); kfree(multi); @@ -301,19 +300,31 @@ int read_whole_eb(struct btrfs_fs_info *info, struct extent_buffer *eb, int mirr return 0; } -struct extent_buffer* read_tree_block_fs_info( - struct btrfs_fs_info *fs_info, u64 bytenr, u32 blocksize, +struct extent_buffer* read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr, u64 parent_transid) { int ret; struct extent_buffer *eb; u64 best_transid = 0; + u32 sectorsize = fs_info->sectorsize; int mirror_num = 0; int good_mirror = 0; int num_copies; int ignore = 0; - eb = btrfs_find_create_tree_block(fs_info, bytenr, blocksize); + /* + * Don't even try to create tree block for unaligned tree block + * bytenr. + * Such unaligned tree block will free overlapping extent buffer, + * causing use-after-free bugs for fuzzed images. + */ + if (bytenr < sectorsize || !IS_ALIGNED(bytenr, sectorsize)) { + error("tree block bytenr %llu is not aligned to sectorsize %u", + bytenr, sectorsize); + return ERR_PTR(-EIO); + } + + eb = btrfs_find_create_tree_block(fs_info, bytenr); if (!eb) return ERR_PTR(-ENOMEM); @@ -322,7 +333,7 @@ struct extent_buffer* read_tree_block_fs_info( while (1) { ret = read_whole_eb(fs_info, eb, mirror_num); - if (ret == 0 && csum_tree_block_fs_info(fs_info, eb, 1) == 0 && + if (ret == 0 && csum_tree_block(fs_info, eb, 1) == 0 && check_tree_block(fs_info, eb) == 0 && verify_parent_transid(eb->tree, eb, parent_transid, ignore) == 0) { @@ -347,8 +358,7 @@ struct extent_buffer* read_tree_block_fs_info( ret = -EIO; break; } - num_copies = btrfs_num_copies(&fs_info->mapping_tree, - eb->start, eb->len); + num_copies = btrfs_num_copies(fs_info, eb->start, eb->len); if (num_copies == 1) { ignore = 1; continue; @@ -368,18 +378,17 @@ struct extent_buffer* read_tree_block_fs_info( return ERR_PTR(ret); } -int read_extent_data(struct btrfs_root *root, char *data, - u64 logical, u64 *len, int mirror) +int read_extent_data(struct btrfs_fs_info *fs_info, char *data, u64 logical, + u64 *len, int mirror) { u64 offset = 0; struct btrfs_multi_bio *multi = NULL; - struct btrfs_fs_info *info = root->fs_info; struct btrfs_device *device; int ret = 0; u64 max_len = *len; - ret = btrfs_map_block(&info->mapping_tree, READ, logical, len, - &multi, mirror, NULL); + ret = btrfs_map_block(fs_info, READ, logical, len, &multi, mirror, + NULL); if (ret) { fprintf(stderr, "Couldn't map the block %llu\n", logical + offset); @@ -387,10 +396,12 @@ int read_extent_data(struct btrfs_root *root, char *data, } device = multi->stripes[0].dev; - if (device->fd <= 0) - goto err; if (*len > max_len) *len = max_len; + if (device->fd < 0) { + ret = -EIO; + goto err; + } ret = pread64(device->fd, data, *len, multi->stripes[0].physical); if (ret != *len) @@ -402,9 +413,7 @@ err: return ret; } -int write_and_map_eb(struct btrfs_trans_handle *trans, - struct btrfs_root *root, - struct extent_buffer *eb) +int write_and_map_eb(struct btrfs_fs_info *fs_info, struct extent_buffer *eb) { int ret; int dev_nr; @@ -414,11 +423,11 @@ int write_and_map_eb(struct btrfs_trans_handle *trans, dev_nr = 0; length = eb->len; - ret = btrfs_map_block(&root->fs_info->mapping_tree, WRITE, - eb->start, &length, &multi, 0, &raid_map); + ret = btrfs_map_block(fs_info, WRITE, eb->start, &length, + &multi, 0, &raid_map); if (raid_map) { - ret = write_raid56_with_parity(root->fs_info, eb, multi, + ret = write_raid56_with_parity(fs_info, eb, multi, length, raid_map); BUG_ON(ret); } else while (dev_nr < multi->num_stripes) { @@ -436,12 +445,12 @@ int write_and_map_eb(struct btrfs_trans_handle *trans, } int write_tree_block(struct btrfs_trans_handle *trans, - struct btrfs_root *root, + struct btrfs_fs_info *fs_info, struct extent_buffer *eb) { - if (check_tree_block(root->fs_info, eb)) { - print_tree_block_error(root->fs_info, eb, - check_tree_block(root->fs_info, eb)); + if (check_tree_block(fs_info, eb)) { + print_tree_block_error(fs_info, eb, + check_tree_block(fs_info, eb)); BUG(); } @@ -449,28 +458,22 @@ int write_tree_block(struct btrfs_trans_handle *trans, BUG(); btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN); - csum_tree_block(root, eb, 0); + csum_tree_block(fs_info, eb, 0); - return write_and_map_eb(trans, root, eb); + return write_and_map_eb(fs_info, eb); } -int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize, - u32 stripesize, struct btrfs_root *root, - struct btrfs_fs_info *fs_info, u64 objectid) +void btrfs_setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info, + u64 objectid) { root->node = NULL; root->commit_root = NULL; - root->sectorsize = sectorsize; - root->nodesize = nodesize; - root->leafsize = leafsize; - root->stripesize = stripesize; root->ref_cows = 0; root->track_dirty = 0; root->fs_info = fs_info; root->objectid = objectid; root->last_trans = 0; - root->highest_inode = 0; root->last_inode_alloc = 0; INIT_LIST_HEAD(&root->dirty_list); @@ -478,129 +481,6 @@ int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize, memset(&root->root_key, 0, sizeof(root->root_key)); memset(&root->root_item, 0, sizeof(root->root_item)); root->root_key.objectid = objectid; - return 0; -} - -static int update_cowonly_root(struct btrfs_trans_handle *trans, - struct btrfs_root *root) -{ - int ret; - u64 old_root_bytenr; - struct btrfs_root *tree_root = root->fs_info->tree_root; - - btrfs_write_dirty_block_groups(trans, root); - while(1) { - old_root_bytenr = btrfs_root_bytenr(&root->root_item); - if (old_root_bytenr == root->node->start) - break; - btrfs_set_root_bytenr(&root->root_item, - root->node->start); - btrfs_set_root_generation(&root->root_item, - trans->transid); - root->root_item.level = btrfs_header_level(root->node); - ret = btrfs_update_root(trans, tree_root, - &root->root_key, - &root->root_item); - BUG_ON(ret); - btrfs_write_dirty_block_groups(trans, root); - } - return 0; -} - -static int commit_tree_roots(struct btrfs_trans_handle *trans, - struct btrfs_fs_info *fs_info) -{ - struct btrfs_root *root; - struct list_head *next; - struct extent_buffer *eb; - int ret; - - if (fs_info->readonly) - return 0; - - eb = fs_info->tree_root->node; - extent_buffer_get(eb); - ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb); - free_extent_buffer(eb); - if (ret) - return ret; - - while(!list_empty(&fs_info->dirty_cowonly_roots)) { - next = fs_info->dirty_cowonly_roots.next; - list_del_init(next); - root = list_entry(next, struct btrfs_root, dirty_list); - update_cowonly_root(trans, root); - free_extent_buffer(root->commit_root); - root->commit_root = NULL; - } - - return 0; -} - -static int __commit_transaction(struct btrfs_trans_handle *trans, - struct btrfs_root *root) -{ - u64 start; - u64 end; - struct extent_buffer *eb; - struct extent_io_tree *tree = &root->fs_info->extent_cache; - int ret; - - while(1) { - ret = find_first_extent_bit(tree, 0, &start, &end, - EXTENT_DIRTY); - if (ret) - break; - while(start <= end) { - eb = find_first_extent_buffer(tree, start); - BUG_ON(!eb || eb->start != start); - ret = write_tree_block(trans, root, eb); - BUG_ON(ret); - start += eb->len; - clear_extent_buffer_dirty(eb); - free_extent_buffer(eb); - } - } - return 0; -} - -int btrfs_commit_transaction(struct btrfs_trans_handle *trans, - struct btrfs_root *root) -{ - u64 transid = trans->transid; - int ret = 0; - struct btrfs_fs_info *fs_info = root->fs_info; - - if (root->commit_root == root->node) - goto commit_tree; - if (root == root->fs_info->tree_root) - goto commit_tree; - if (root == root->fs_info->chunk_root) - goto commit_tree; - - free_extent_buffer(root->commit_root); - root->commit_root = NULL; - - btrfs_set_root_bytenr(&root->root_item, root->node->start); - btrfs_set_root_generation(&root->root_item, trans->transid); - root->root_item.level = btrfs_header_level(root->node); - ret = btrfs_update_root(trans, root->fs_info->tree_root, - &root->root_key, &root->root_item); - BUG_ON(ret); -commit_tree: - ret = commit_tree_roots(trans, fs_info); - BUG_ON(ret); - ret = __commit_transaction(trans, root); - BUG_ON(ret); - write_ctree_super(trans, root); - btrfs_finish_extent_commit(trans, fs_info->extent_root, - &fs_info->pinned_extents); - btrfs_free_transaction(root, trans); - free_extent_buffer(root->commit_root); - root->commit_root = NULL; - fs_info->running_transaction = NULL; - fs_info->last_trans_committed = transid; - return 0; } static int find_and_setup_root(struct btrfs_root *tree_root, @@ -608,21 +488,17 @@ static int find_and_setup_root(struct btrfs_root *tree_root, u64 objectid, struct btrfs_root *root) { int ret; - u32 blocksize; u64 generation; - __setup_root(tree_root->nodesize, tree_root->leafsize, - tree_root->sectorsize, tree_root->stripesize, - root, fs_info, objectid); + btrfs_setup_root(root, fs_info, objectid); ret = btrfs_find_last_root(tree_root, objectid, &root->root_item, &root->root_key); if (ret) return ret; - blocksize = root->nodesize; generation = btrfs_root_generation(&root->root_item); - root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item), - blocksize, generation); + root->node = read_tree_block(fs_info, + btrfs_root_bytenr(&root->root_item), generation); if (!extent_buffer_uptodate(root->node)) return -EIO; @@ -633,7 +509,6 @@ static int find_and_setup_log_root(struct btrfs_root *tree_root, struct btrfs_fs_info *fs_info, struct btrfs_super_block *disk_super) { - u32 blocksize; u64 blocknr = btrfs_super_log_root(disk_super); struct btrfs_root *log_root = malloc(sizeof(struct btrfs_root)); @@ -645,14 +520,10 @@ static int find_and_setup_log_root(struct btrfs_root *tree_root, return 0; } - blocksize = tree_root->nodesize; + btrfs_setup_root(log_root, fs_info, + BTRFS_TREE_LOG_OBJECTID); - __setup_root(tree_root->nodesize, tree_root->leafsize, - tree_root->sectorsize, tree_root->stripesize, - log_root, fs_info, BTRFS_TREE_LOG_OBJECTID); - - log_root->node = read_tree_block(tree_root, blocknr, - blocksize, + log_root->node = read_tree_block(fs_info, blocknr, btrfs_super_generation(disk_super) + 1); fs_info->log_root_tree = log_root; @@ -695,7 +566,6 @@ struct btrfs_root *btrfs_read_fs_root_no_cache(struct btrfs_fs_info *fs_info, struct btrfs_path *path; struct extent_buffer *l; u64 generation; - u32 blocksize; int ret = 0; root = calloc(1, sizeof(*root)); @@ -711,12 +581,15 @@ struct btrfs_root *btrfs_read_fs_root_no_cache(struct btrfs_fs_info *fs_info, goto insert; } - __setup_root(tree_root->nodesize, tree_root->leafsize, - tree_root->sectorsize, tree_root->stripesize, - root, fs_info, location->objectid); + btrfs_setup_root(root, fs_info, + location->objectid); path = btrfs_alloc_path(); - BUG_ON(!path); + if (!path) { + free(root); + return ERR_PTR(-ENOMEM); + } + ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0); if (ret != 0) { if (ret > 0) @@ -736,9 +609,8 @@ out: return ERR_PTR(ret); } generation = btrfs_root_generation(&root->root_item); - blocksize = root->nodesize; - root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item), - blocksize, generation); + root->node = read_tree_block(fs_info, + btrfs_root_bytenr(&root->root_item), generation); if (!extent_buffer_uptodate(root->node)) { free(root); return ERR_PTR(-EIO); @@ -791,7 +663,8 @@ struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info, if (location->objectid == BTRFS_CSUM_TREE_OBJECTID) return fs_info->csum_root; if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID) - return fs_info->quota_root; + return fs_info->quota_enabled ? fs_info->quota_root : + ERR_PTR(-ENOENT); BUG_ON(location->objectid == BTRFS_TREE_RELOC_OBJECTID || location->offset != (u64)-1); @@ -813,12 +686,14 @@ struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info, void btrfs_free_fs_info(struct btrfs_fs_info *fs_info) { + if (fs_info->quota_root) + free(fs_info->quota_root); + free(fs_info->tree_root); free(fs_info->extent_root); free(fs_info->chunk_root); free(fs_info->dev_root); free(fs_info->csum_root); - free(fs_info->quota_root); free(fs_info->free_space_root); free(fs_info->super_copy); free(fs_info->log_root_tree); @@ -877,7 +752,8 @@ free_all: return NULL; } -int btrfs_check_fs_compatibility(struct btrfs_super_block *sb, int writable) +int btrfs_check_fs_compatibility(struct btrfs_super_block *sb, + unsigned int flags) { u64 features; @@ -896,13 +772,22 @@ int btrfs_check_fs_compatibility(struct btrfs_super_block *sb, int writable) btrfs_set_super_incompat_flags(sb, features); } - features = btrfs_super_compat_ro_flags(sb) & - ~BTRFS_FEATURE_COMPAT_RO_SUPP; - if (writable && features) { - printk("couldn't open RDWR because of unsupported " - "option features (%Lx).\n", - (unsigned long long)features); - return -ENOTSUP; + features = btrfs_super_compat_ro_flags(sb); + if (flags & OPEN_CTREE_WRITES) { + if (flags & OPEN_CTREE_INVALIDATE_FST) { + /* Clear the FREE_SPACE_TREE_VALID bit on disk... */ + features &= ~BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID; + btrfs_set_super_compat_ro_flags(sb, features); + /* ... and ignore the free space tree bit. */ + features &= ~BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE; + } + if (features & ~BTRFS_FEATURE_COMPAT_RO_SUPP) { + printk("couldn't open RDWR because of unsupported " + "option features (%Lx).\n", + (unsigned long long)features); + return -ENOTSUP; + } + } return 0; } @@ -927,13 +812,11 @@ static int find_best_backup_root(struct btrfs_super_block *super) } static int setup_root_or_create_block(struct btrfs_fs_info *fs_info, - enum btrfs_open_ctree_flags flags, + unsigned flags, struct btrfs_root *info_root, u64 objectid, char *str) { - struct btrfs_super_block *sb = fs_info->super_copy; struct btrfs_root *root = fs_info->tree_root; - u32 nodesize = btrfs_super_nodesize(sb); int ret; ret = find_and_setup_root(root, fs_info, objectid, info_root); @@ -946,38 +829,26 @@ static int setup_root_or_create_block(struct btrfs_fs_info *fs_info, * million of places that assume a root has a valid ->node */ info_root->node = - btrfs_find_create_tree_block(fs_info, 0, nodesize); + btrfs_find_create_tree_block(fs_info, 0); if (!info_root->node) return -ENOMEM; - clear_extent_buffer_uptodate(NULL, info_root->node); + clear_extent_buffer_uptodate(info_root->node); } return 0; } int btrfs_setup_all_roots(struct btrfs_fs_info *fs_info, u64 root_tree_bytenr, - enum btrfs_open_ctree_flags flags) + unsigned flags) { struct btrfs_super_block *sb = fs_info->super_copy; struct btrfs_root *root; struct btrfs_key key; - u32 sectorsize; - u32 nodesize; - u32 leafsize; - u32 stripesize; u64 generation; - u32 blocksize; int ret; - nodesize = btrfs_super_nodesize(sb); - leafsize = btrfs_super_leafsize(sb); - sectorsize = btrfs_super_sectorsize(sb); - stripesize = btrfs_super_stripesize(sb); - root = fs_info->tree_root; - __setup_root(nodesize, leafsize, sectorsize, stripesize, - root, fs_info, BTRFS_ROOT_TREE_OBJECTID); - blocksize = root->nodesize; + btrfs_setup_root(root, fs_info, BTRFS_ROOT_TREE_OBJECTID); generation = btrfs_super_generation(sb); if (!root_tree_bytenr && !(flags & OPEN_CTREE_BACKUP_ROOT)) { @@ -994,8 +865,7 @@ int btrfs_setup_all_roots(struct btrfs_fs_info *fs_info, u64 root_tree_bytenr, generation = btrfs_backup_tree_root_gen(backup); } - root->node = read_tree_block(root, root_tree_bytenr, blocksize, - generation); + root->node = read_tree_block(fs_info, root_tree_bytenr, generation); if (!extent_buffer_uptodate(root->node)) { fprintf(stderr, "Couldn't read tree root\n"); return -EIO; @@ -1023,10 +893,14 @@ int btrfs_setup_all_roots(struct btrfs_fs_info *fs_info, u64 root_tree_bytenr, ret = find_and_setup_root(root, fs_info, BTRFS_QUOTA_TREE_OBJECTID, fs_info->quota_root); - if (ret == 0) + if (ret) { + free(fs_info->quota_root); + fs_info->quota_root = NULL; + } else { fs_info->quota_enabled = 1; + } - if (btrfs_fs_compat_ro(fs_info, BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE)) { + if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) { ret = find_and_setup_root(root, fs_info, BTRFS_FREE_SPACE_TREE_OBJECTID, fs_info->free_space_root); if (ret) { @@ -1046,8 +920,16 @@ int btrfs_setup_all_roots(struct btrfs_fs_info *fs_info, u64 root_tree_bytenr, fs_info->generation = generation; fs_info->last_trans_committed = generation; if (extent_buffer_uptodate(fs_info->extent_root->node) && - !(flags & OPEN_CTREE_NO_BLOCK_GROUPS)) - btrfs_read_block_groups(fs_info->tree_root); + !(flags & OPEN_CTREE_NO_BLOCK_GROUPS)) { + ret = btrfs_read_block_groups(fs_info->tree_root); + /* + * If we don't find any blockgroups (ENOENT) we're either + * restoring or creating the filesystem, where it's expected, + * anything else is error + */ + if (ret != -ENOENT) + return -EIO; + } key.objectid = BTRFS_FS_TREE_OBJECTID; key.type = BTRFS_ROOT_ITEM_KEY; @@ -1109,7 +991,7 @@ void btrfs_cleanup_all_caches(struct btrfs_fs_info *fs_info) int btrfs_scan_fs_devices(int fd, const char *path, struct btrfs_fs_devices **fs_devices, - u64 sb_bytenr, int super_recover, + u64 sb_bytenr, unsigned sbflags, int skip_devices) { u64 total_devs; @@ -1126,19 +1008,21 @@ int btrfs_scan_fs_devices(int fd, const char *path, dev_size = seek_ret; lseek(fd, 0, SEEK_SET); if (sb_bytenr > dev_size) { - fprintf(stderr, "Superblock bytenr is larger than device size\n"); + error("superblock bytenr %llu is larger than device size %llu", + (unsigned long long)sb_bytenr, + (unsigned long long)dev_size); return -EINVAL; } ret = btrfs_scan_one_device(fd, path, fs_devices, - &total_devs, sb_bytenr, super_recover); + &total_devs, sb_bytenr, sbflags); if (ret) { fprintf(stderr, "No valid Btrfs found on %s\n", path); return ret; } if (!skip_devices && total_devs != 1) { - ret = btrfs_scan_lblkid(); + ret = btrfs_scan_devices(); if (ret) return ret; } @@ -1149,33 +1033,22 @@ int btrfs_setup_chunk_tree_and_device_map(struct btrfs_fs_info *fs_info, u64 chunk_root_bytenr) { struct btrfs_super_block *sb = fs_info->super_copy; - u32 sectorsize; - u32 nodesize; - u32 leafsize; - u32 blocksize; - u32 stripesize; u64 generation; int ret; - nodesize = btrfs_super_nodesize(sb); - leafsize = btrfs_super_leafsize(sb); - sectorsize = btrfs_super_sectorsize(sb); - stripesize = btrfs_super_stripesize(sb); + btrfs_setup_root(fs_info->chunk_root, fs_info, + BTRFS_CHUNK_TREE_OBJECTID); - __setup_root(nodesize, leafsize, sectorsize, stripesize, - fs_info->chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID); - - ret = btrfs_read_sys_array(fs_info->chunk_root); + ret = btrfs_read_sys_array(fs_info); if (ret) return ret; - blocksize = fs_info->chunk_root->nodesize; generation = btrfs_super_chunk_root_generation(sb); if (chunk_root_bytenr && !IS_ALIGNED(chunk_root_bytenr, - btrfs_super_sectorsize(sb))) { + fs_info->sectorsize)) { warning("chunk_root_bytenr %llu is unaligned to %u, ignore it", - chunk_root_bytenr, btrfs_super_sectorsize(sb)); + chunk_root_bytenr, fs_info->sectorsize); chunk_root_bytenr = 0; } @@ -1184,9 +1057,9 @@ int btrfs_setup_chunk_tree_and_device_map(struct btrfs_fs_info *fs_info, else generation = 0; - fs_info->chunk_root->node = read_tree_block(fs_info->chunk_root, + fs_info->chunk_root->node = read_tree_block(fs_info, chunk_root_bytenr, - blocksize, generation); + generation); if (!extent_buffer_uptodate(fs_info->chunk_root->node)) { if (fs_info->ignore_chunk_tree_error) { warning("cannot read chunk root, continue anyway"); @@ -1199,7 +1072,7 @@ int btrfs_setup_chunk_tree_and_device_map(struct btrfs_fs_info *fs_info, } if (!(btrfs_super_flags(sb) & BTRFS_SUPER_FLAG_METADUMP)) { - ret = btrfs_read_chunk_tree(fs_info->chunk_root); + ret = btrfs_read_chunk_tree(fs_info); if (ret) { fprintf(stderr, "Couldn't read chunk tree\n"); return ret; @@ -1212,7 +1085,7 @@ static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path, u64 sb_bytenr, u64 root_tree_bytenr, u64 chunk_root_bytenr, - enum btrfs_open_ctree_flags flags) + unsigned flags) { struct btrfs_fs_info *fs_info; struct btrfs_super_block *disk_super; @@ -1220,6 +1093,7 @@ static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path, struct extent_buffer *eb; int ret; int oflags; + unsigned sbflags = SBREAD_DEFAULT; if (sb_bytenr == 0) sb_bytenr = BTRFS_SUPER_INFO_OFFSET; @@ -1242,9 +1116,18 @@ static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path, if (flags & OPEN_CTREE_IGNORE_CHUNK_TREE_ERROR) fs_info->ignore_chunk_tree_error = 1; - ret = btrfs_scan_fs_devices(fp, path, &fs_devices, sb_bytenr, - (flags & OPEN_CTREE_RECOVER_SUPER), - (flags & OPEN_CTREE_NO_DEVICES)); + if ((flags & OPEN_CTREE_RECOVER_SUPER) + && (flags & OPEN_CTREE_FS_PARTIAL)) { + fprintf(stderr, + "cannot open a partially created filesystem for recovery"); + goto out; + } + + if (flags & OPEN_CTREE_FS_PARTIAL) + sbflags = SBREAD_PARTIAL; + + ret = btrfs_scan_fs_devices(fp, path, &fs_devices, sb_bytenr, sbflags, + (flags & OPEN_CTREE_NO_DEVICES)); if (ret) goto out; @@ -1263,10 +1146,11 @@ static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path, disk_super = fs_info->super_copy; if (flags & OPEN_CTREE_RECOVER_SUPER) - ret = btrfs_read_dev_super(fs_devices->latest_bdev, - disk_super, sb_bytenr, 1); + ret = btrfs_read_dev_super(fs_devices->latest_bdev, disk_super, + sb_bytenr, SBREAD_RECOVER); else - ret = btrfs_read_dev_super(fp, disk_super, sb_bytenr, 0); + ret = btrfs_read_dev_super(fp, disk_super, sb_bytenr, + sbflags); if (ret) { printk("No valid btrfs found\n"); goto out_devices; @@ -1279,9 +1163,11 @@ static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path, } memcpy(fs_info->fsid, &disk_super->fsid, BTRFS_FSID_SIZE); + fs_info->sectorsize = btrfs_super_sectorsize(disk_super); + fs_info->nodesize = btrfs_super_nodesize(disk_super); + fs_info->stripesize = btrfs_super_stripesize(disk_super); - ret = btrfs_check_fs_compatibility(fs_info->super_copy, - flags & OPEN_CTREE_WRITES); + ret = btrfs_check_fs_compatibility(fs_info->super_copy, flags); if (ret) goto out_devices; @@ -1318,17 +1204,17 @@ out: struct btrfs_fs_info *open_ctree_fs_info(const char *filename, u64 sb_bytenr, u64 root_tree_bytenr, u64 chunk_root_bytenr, - enum btrfs_open_ctree_flags flags) + unsigned flags) { int fp; int ret; struct btrfs_fs_info *info; - int oflags = O_CREAT | O_RDWR; + int oflags = O_RDWR; struct stat st; ret = stat(filename, &st); if (ret < 0) { - error("cannot stat '%s': %s", filename, strerror(errno)); + error("cannot stat '%s': %m", filename); return NULL; } if (!(((st.st_mode & S_IFMT) == S_IFREG) || ((st.st_mode & S_IFMT) == S_IFBLK))) { @@ -1339,9 +1225,9 @@ struct btrfs_fs_info *open_ctree_fs_info(const char *filename, if (!(flags & OPEN_CTREE_WRITES)) oflags = O_RDONLY; - fp = open(filename, oflags, 0600); + fp = open(filename, oflags); if (fp < 0) { - error("cannot open '%s': %s", filename, strerror(errno)); + error("cannot open '%s': %m", filename); return NULL; } info = __open_ctree_fd(fp, filename, sb_bytenr, root_tree_bytenr, @@ -1351,7 +1237,7 @@ struct btrfs_fs_info *open_ctree_fs_info(const char *filename, } struct btrfs_root *open_ctree(const char *filename, u64 sb_bytenr, - enum btrfs_open_ctree_flags flags) + unsigned flags) { struct btrfs_fs_info *info; @@ -1366,12 +1252,16 @@ struct btrfs_root *open_ctree(const char *filename, u64 sb_bytenr, } struct btrfs_root *open_ctree_fd(int fp, const char *path, u64 sb_bytenr, - enum btrfs_open_ctree_flags flags) + unsigned flags) { struct btrfs_fs_info *info; /* This flags may not return fs_info with any valid root */ - BUG_ON(flags & OPEN_CTREE_IGNORE_CHUNK_TREE_ERROR); + if (flags & OPEN_CTREE_IGNORE_CHUNK_TREE_ERROR) { + error("invalid open_ctree flags: 0x%llx", + (unsigned long long)flags); + return NULL; + } info = __open_ctree_fd(fp, path, sb_bytenr, 0, 0, flags); if (!info) return NULL; @@ -1387,84 +1277,84 @@ struct btrfs_root *open_ctree_fd(int fp, const char *path, u64 sb_bytenr, * - number of devices - something sane * - sys array size - maximum */ -static int check_super(struct btrfs_super_block *sb) +static int check_super(struct btrfs_super_block *sb, unsigned sbflags) { - char result[BTRFS_CSUM_SIZE]; + u8 result[BTRFS_CSUM_SIZE]; u32 crc; u16 csum_type; int csum_size; if (btrfs_super_magic(sb) != BTRFS_MAGIC) { - fprintf(stderr, "ERROR: superblock magic doesn't match\n"); - return -EIO; + if (btrfs_super_magic(sb) == BTRFS_MAGIC_PARTIAL) { + if (!(sbflags & SBREAD_PARTIAL)) { + error("superblock magic doesn't match"); + return -EIO; + } + } } csum_type = btrfs_super_csum_type(sb); if (csum_type >= ARRAY_SIZE(btrfs_csum_sizes)) { - fprintf(stderr, "ERROR: unsupported checksum algorithm %u\n", - csum_type); + error("unsupported checksum algorithm %u", csum_type); return -EIO; } csum_size = btrfs_csum_sizes[csum_type]; crc = ~(u32)0; - crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc, + crc = btrfs_csum_data((char *)sb + BTRFS_CSUM_SIZE, crc, BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE); btrfs_csum_final(crc, result); if (memcmp(result, sb->csum, csum_size)) { - fprintf(stderr, "ERROR: superblock checksum mismatch\n"); + error("superblock checksum mismatch"); return -EIO; } if (btrfs_super_root_level(sb) >= BTRFS_MAX_LEVEL) { - fprintf(stderr, "ERROR: tree_root level too big: %d >= %d\n", + error("tree_root level too big: %d >= %d", btrfs_super_root_level(sb), BTRFS_MAX_LEVEL); goto error_out; } if (btrfs_super_chunk_root_level(sb) >= BTRFS_MAX_LEVEL) { - fprintf(stderr, "ERROR: chunk_root level too big: %d >= %d\n", + error("chunk_root level too big: %d >= %d", btrfs_super_chunk_root_level(sb), BTRFS_MAX_LEVEL); goto error_out; } if (btrfs_super_log_root_level(sb) >= BTRFS_MAX_LEVEL) { - fprintf(stderr, "ERROR: log_root level too big: %d >= %d\n", + error("log_root level too big: %d >= %d", btrfs_super_log_root_level(sb), BTRFS_MAX_LEVEL); goto error_out; } if (!IS_ALIGNED(btrfs_super_root(sb), 4096)) { - fprintf(stderr, "ERROR: tree_root block unaligned: %llu\n", - btrfs_super_root(sb)); + error("tree_root block unaligned: %llu", btrfs_super_root(sb)); goto error_out; } if (!IS_ALIGNED(btrfs_super_chunk_root(sb), 4096)) { - fprintf(stderr, "ERROR: chunk_root block unaligned: %llu\n", + error("chunk_root block unaligned: %llu", btrfs_super_chunk_root(sb)); goto error_out; } if (!IS_ALIGNED(btrfs_super_log_root(sb), 4096)) { - fprintf(stderr, "ERROR: log_root block unaligned: %llu\n", + error("log_root block unaligned: %llu", btrfs_super_log_root(sb)); goto error_out; } if (btrfs_super_nodesize(sb) < 4096) { - fprintf(stderr, "ERROR: nodesize too small: %u < 4096\n", + error("nodesize too small: %u < 4096", btrfs_super_nodesize(sb)); goto error_out; } if (!IS_ALIGNED(btrfs_super_nodesize(sb), 4096)) { - fprintf(stderr, "ERROR: nodesize unaligned: %u\n", - btrfs_super_nodesize(sb)); + error("nodesize unaligned: %u", btrfs_super_nodesize(sb)); goto error_out; } if (btrfs_super_sectorsize(sb) < 4096) { - fprintf(stderr, "ERROR: sectorsize too small: %u < 4096\n", + error("sectorsize too small: %u < 4096", btrfs_super_sectorsize(sb)); goto error_out; } if (!IS_ALIGNED(btrfs_super_sectorsize(sb), 4096)) { - fprintf(stderr, "ERROR: sectorsize unaligned: %u\n", - btrfs_super_sectorsize(sb)); + error("sectorsize unaligned: %u", btrfs_super_sectorsize(sb)); goto error_out; } if (btrfs_super_total_bytes(sb) == 0) { @@ -1475,7 +1365,8 @@ static int check_super(struct btrfs_super_block *sb) error("invalid bytes_used %llu", btrfs_super_bytes_used(sb)); goto error_out; } - if (btrfs_super_stripesize(sb) != 4096) { + if ((btrfs_super_stripesize(sb) != 4096) + && (btrfs_super_stripesize(sb) != btrfs_super_sectorsize(sb))) { error("invalid stripesize %u", btrfs_super_stripesize(sb)); goto error_out; } @@ -1486,8 +1377,7 @@ static int check_super(struct btrfs_super_block *sb) uuid_unparse(sb->fsid, fsid); uuid_unparse(sb->dev_item.fsid, dev_fsid); - printk(KERN_ERR - "ERROR: dev_item UUID does not match fsid: %s != %s\n", + error("dev_item UUID does not match fsid: %s != %s", dev_fsid, fsid); goto error_out; } @@ -1496,12 +1386,12 @@ static int check_super(struct btrfs_super_block *sb) * Hint to catch really bogus numbers, bitflips or so */ if (btrfs_super_num_devices(sb) > (1UL << 31)) { - fprintf(stderr, "WARNING: suspicious number of devices: %llu\n", + warning("suspicious number of devices: %llu", btrfs_super_num_devices(sb)); } if (btrfs_super_num_devices(sb) == 0) { - fprintf(stderr, "ERROR: number of devices is 0\n"); + error("number of devices is 0"); goto error_out; } @@ -1510,17 +1400,17 @@ static int check_super(struct btrfs_super_block *sb) * and one chunk */ if (btrfs_super_sys_array_size(sb) > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) { - fprintf(stderr, "BTRFS: system chunk array too big %u > %u\n", - btrfs_super_sys_array_size(sb), - BTRFS_SYSTEM_CHUNK_ARRAY_SIZE); + error("system chunk array too big %u > %u", + btrfs_super_sys_array_size(sb), + BTRFS_SYSTEM_CHUNK_ARRAY_SIZE); goto error_out; } if (btrfs_super_sys_array_size(sb) < sizeof(struct btrfs_disk_key) + sizeof(struct btrfs_chunk)) { - fprintf(stderr, "BTRFS: system chunk array too small %u < %lu\n", - btrfs_super_sys_array_size(sb), - sizeof(struct btrfs_disk_key) + - sizeof(struct btrfs_chunk)); + error("system chunk array too small %u < %zu", + btrfs_super_sys_array_size(sb), + sizeof(struct btrfs_disk_key) + + sizeof(struct btrfs_chunk)); goto error_out; } @@ -1531,8 +1421,25 @@ error_out: return -EIO; } +/* + * btrfs_read_dev_super - read a valid superblock from a block device + * @fd: file descriptor of the device + * @sb: buffer where the superblock is going to be read in + * @sb_bytenr: offset of the particular superblock copy we want + * @sbflags: flags controlling how the superblock is read + * + * This function is used by various btrfs comands to obtain a valid superblock. + * + * It's mode of operation is controlled by the @sb_bytenr and @sbdflags + * parameters. If SBREAD_RECOVER flag is set and @sb_bytenr is + * BTRFS_SUPER_INFO_OFFSET then the function reads all 3 superblock copies and + * returns the newest one. If SBREAD_RECOVER is not set then only a single + * copy is read, which one is decided by @sb_bytenr. If @sb_bytenr != + * BTRFS_SUPER_INFO_OFFSET then the @sbflags is effectively ignored and only a + * single copy is read. + */ int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr, - int super_recover) + unsigned sbflags) { u8 fsid[BTRFS_FSID_SIZE]; int fsid_is_initialized = 0; @@ -1540,20 +1447,26 @@ int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr, struct btrfs_super_block *buf = (struct btrfs_super_block *)tmp; int i; int ret; - int max_super = super_recover ? BTRFS_SUPER_MIRROR_MAX : 1; + int max_super = sbflags & SBREAD_RECOVER ? BTRFS_SUPER_MIRROR_MAX : 1; u64 transid = 0; u64 bytenr; if (sb_bytenr != BTRFS_SUPER_INFO_OFFSET) { ret = pread64(fd, buf, BTRFS_SUPER_INFO_SIZE, sb_bytenr); + /* real error */ + if (ret < 0) + return -errno; + + /* Not large enough sb, return -ENOENT instead of normal -EIO */ if (ret < BTRFS_SUPER_INFO_SIZE) - return -1; + return -ENOENT; if (btrfs_super_bytenr(buf) != sb_bytenr) - return -1; + return -EIO; - if (check_super(buf)) - return -1; + ret = check_super(buf, sbflags); + if (ret < 0) + return ret; memcpy(sb, buf, BTRFS_SUPER_INFO_SIZE); return 0; } @@ -1576,7 +1489,7 @@ int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr, /* if magic is NULL, the device was removed */ if (btrfs_super_magic(buf) == 0 && i == 0) break; - if (check_super(buf)) + if (check_super(buf, sbflags)) continue; if (!fsid_is_initialized) { @@ -1600,7 +1513,7 @@ int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr, return transid > 0 ? 0 : -1; } -static int write_dev_supers(struct btrfs_root *root, +static int write_dev_supers(struct btrfs_fs_info *fs_info, struct btrfs_super_block *sb, struct btrfs_device *device) { @@ -1608,20 +1521,20 @@ static int write_dev_supers(struct btrfs_root *root, u32 crc; int i, ret; - if (root->fs_info->super_bytenr != BTRFS_SUPER_INFO_OFFSET) { - btrfs_set_super_bytenr(sb, root->fs_info->super_bytenr); + if (fs_info->super_bytenr != BTRFS_SUPER_INFO_OFFSET) { + btrfs_set_super_bytenr(sb, fs_info->super_bytenr); crc = ~(u32)0; - crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc, + crc = btrfs_csum_data((char *)sb + BTRFS_CSUM_SIZE, crc, BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE); - btrfs_csum_final(crc, (char *)&sb->csum[0]); + btrfs_csum_final(crc, &sb->csum[0]); /* * super_copy is BTRFS_SUPER_INFO_SIZE bytes and is * zero filled, we can use it directly */ - ret = pwrite64(device->fd, root->fs_info->super_copy, + ret = pwrite64(device->fd, fs_info->super_copy, BTRFS_SUPER_INFO_SIZE, - root->fs_info->super_bytenr); + fs_info->super_bytenr); if (ret != BTRFS_SUPER_INFO_SIZE) goto write_err; return 0; @@ -1635,15 +1548,15 @@ static int write_dev_supers(struct btrfs_root *root, btrfs_set_super_bytenr(sb, bytenr); crc = ~(u32)0; - crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc, + crc = btrfs_csum_data((char *)sb + BTRFS_CSUM_SIZE, crc, BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE); - btrfs_csum_final(crc, (char *)&sb->csum[0]); + btrfs_csum_final(crc, &sb->csum[0]); /* * super_copy is BTRFS_SUPER_INFO_SIZE bytes and is * zero filled, we can use it directly */ - ret = pwrite64(device->fd, root->fs_info->super_copy, + ret = pwrite64(device->fd, fs_info->super_copy, BTRFS_SUPER_INFO_SIZE, bytenr); if (ret != BTRFS_SUPER_INFO_SIZE) goto write_err; @@ -1655,25 +1568,22 @@ write_err: if (ret > 0) fprintf(stderr, "WARNING: failed to write all sb data\n"); else - fprintf(stderr, "WARNING: failed to write sb: %s\n", - strerror(errno)); + fprintf(stderr, "WARNING: failed to write sb: %m\n"); return ret; } -int write_all_supers(struct btrfs_root *root) +int write_all_supers(struct btrfs_fs_info *fs_info) { - struct list_head *cur; - struct list_head *head = &root->fs_info->fs_devices->devices; + struct list_head *head = &fs_info->fs_devices->devices; struct btrfs_device *dev; struct btrfs_super_block *sb; struct btrfs_dev_item *dev_item; int ret; u64 flags; - sb = root->fs_info->super_copy; + sb = fs_info->super_copy; dev_item = &sb->dev_item; - list_for_each(cur, head) { - dev = list_entry(cur, struct btrfs_device, dev_list); + list_for_each_entry(dev, head, dev_list) { if (!dev->writeable) continue; @@ -1691,36 +1601,36 @@ int write_all_supers(struct btrfs_root *root) flags = btrfs_super_flags(sb); btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN); - ret = write_dev_supers(root, sb, dev); + ret = write_dev_supers(fs_info, sb, dev); BUG_ON(ret); } return 0; } int write_ctree_super(struct btrfs_trans_handle *trans, - struct btrfs_root *root) + struct btrfs_fs_info *fs_info) { int ret; - struct btrfs_root *tree_root = root->fs_info->tree_root; - struct btrfs_root *chunk_root = root->fs_info->chunk_root; + struct btrfs_root *tree_root = fs_info->tree_root; + struct btrfs_root *chunk_root = fs_info->chunk_root; - if (root->fs_info->readonly) + if (fs_info->readonly) return 0; - btrfs_set_super_generation(root->fs_info->super_copy, + btrfs_set_super_generation(fs_info->super_copy, trans->transid); - btrfs_set_super_root(root->fs_info->super_copy, + btrfs_set_super_root(fs_info->super_copy, tree_root->node->start); - btrfs_set_super_root_level(root->fs_info->super_copy, + btrfs_set_super_root_level(fs_info->super_copy, btrfs_header_level(tree_root->node)); - btrfs_set_super_chunk_root(root->fs_info->super_copy, + btrfs_set_super_chunk_root(fs_info->super_copy, chunk_root->node->start); - btrfs_set_super_chunk_root_level(root->fs_info->super_copy, + btrfs_set_super_chunk_root_level(fs_info->super_copy, btrfs_header_level(chunk_root->node)); - btrfs_set_super_chunk_root_generation(root->fs_info->super_copy, + btrfs_set_super_chunk_root_generation(fs_info->super_copy, btrfs_header_generation(chunk_root->node)); - ret = write_all_supers(root); + ret = write_all_supers(fs_info); if (ret) fprintf(stderr, "failed to write new super block err %d\n", ret); return ret; @@ -1729,6 +1639,7 @@ int write_ctree_super(struct btrfs_trans_handle *trans, int close_ctree_fs_info(struct btrfs_fs_info *fs_info) { int ret; + int err = 0; struct btrfs_trans_handle *trans; struct btrfs_root *root = fs_info->tree_root; @@ -1736,24 +1647,42 @@ int close_ctree_fs_info(struct btrfs_fs_info *fs_info) fs_info->generation) { BUG_ON(!root); trans = btrfs_start_transaction(root, 1); + if (IS_ERR(trans)) { + err = PTR_ERR(trans); + goto skip_commit; + } btrfs_commit_transaction(trans, root); trans = btrfs_start_transaction(root, 1); + BUG_ON(IS_ERR(trans)); ret = commit_tree_roots(trans, fs_info); BUG_ON(ret); ret = __commit_transaction(trans, root); BUG_ON(ret); - write_ctree_super(trans, root); - btrfs_free_transaction(root, trans); + write_ctree_super(trans, fs_info); + kfree(trans); } + + if (fs_info->finalize_on_close) { + btrfs_set_super_magic(fs_info->super_copy, BTRFS_MAGIC); + root->fs_info->finalize_on_close = 0; + ret = write_all_supers(fs_info); + if (ret) + fprintf(stderr, + "failed to write new super block err %d\n", ret); + } + +skip_commit: btrfs_free_block_groups(fs_info); free_fs_roots_tree(&fs_info->fs_root_tree); btrfs_release_all_roots(fs_info); - btrfs_close_devices(fs_info->fs_devices); + ret = btrfs_close_devices(fs_info->fs_devices); btrfs_cleanup_all_caches(fs_info); btrfs_free_fs_info(fs_info); - return 0; + if (!err) + err = ret; + return err; } int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, @@ -1762,12 +1691,6 @@ int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, return clear_extent_buffer_dirty(eb); } -int wait_on_tree_block_writeback(struct btrfs_root *root, - struct extent_buffer *eb) -{ - return 0; -} - void btrfs_mark_buffer_dirty(struct extent_buffer *eb) { set_extent_buffer_dirty(eb);