X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=disk-io.c;h=6aa6d98a880ecd6af501441c8f623a5e4db434be;hb=c1c987503412a8e98e40da2548c6b78888535641;hp=77eb0a6806d29c57a9064daef8e864950fdb0718;hpb=c27db1238a0be644fea7d36773a53dd6957c94ba;p=platform%2Fupstream%2Fbtrfs-progs.git diff --git a/disk-io.c b/disk-io.c index 77eb0a6..6aa6d98 100644 --- a/disk-io.c +++ b/disk-io.c @@ -118,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; @@ -207,7 +207,7 @@ void readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize, bytenr, &length, &multi, 0, NULL)) { device = multi->stripes[0].dev; device->total_ios++; - blocksize = min(blocksize, (u32)(64 * 1024)); + blocksize = min(blocksize, (u32)SZ_64K); readahead(device->fd, multi->stripes[0].physical, blocksize); } @@ -241,7 +241,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; } @@ -313,11 +313,30 @@ struct extent_buffer* read_tree_block_fs_info( int ret; struct extent_buffer *eb; u64 best_transid = 0; + u32 sectorsize = btrfs_super_sectorsize(fs_info->super_copy); + u32 nodesize = btrfs_super_nodesize(fs_info->super_copy); int mirror_num = 0; int good_mirror = 0; int num_copies; int ignore = 0; + /* + * 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); + } + if (blocksize < nodesize || !IS_ALIGNED(blocksize, nodesize)) { + error("tree block size %u is not aligned to nodesize %u", + blocksize, nodesize); + return ERR_PTR(-EIO); + } + eb = btrfs_find_create_tree_block(fs_info, bytenr, blocksize); if (!eb) return ERR_PTR(-ENOMEM); @@ -407,9 +426,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_root *root, struct extent_buffer *eb) { int ret; int dev_nr; @@ -456,10 +473,10 @@ int write_tree_block(struct btrfs_trans_handle *trans, btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN); csum_tree_block(root, eb, 0); - return write_and_map_eb(trans, root, eb); + return write_and_map_eb(root, eb); } -int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize, +void btrfs_setup_root(u32 nodesize, u32 leafsize, u32 sectorsize, u32 stripesize, struct btrfs_root *root, struct btrfs_fs_info *fs_info, u64 objectid) { @@ -475,7 +492,6 @@ int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize, 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); @@ -483,7 +499,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, @@ -600,7 +615,7 @@ commit_tree: write_ctree_super(trans, root); btrfs_finish_extent_commit(trans, fs_info->extent_root, &fs_info->pinned_extents); - btrfs_free_transaction(root, trans); + kfree(trans); free_extent_buffer(root->commit_root); root->commit_root = NULL; fs_info->running_transaction = NULL; @@ -616,7 +631,7 @@ static int find_and_setup_root(struct btrfs_root *tree_root, u32 blocksize; u64 generation; - __setup_root(tree_root->nodesize, tree_root->leafsize, + btrfs_setup_root(tree_root->nodesize, tree_root->leafsize, tree_root->sectorsize, tree_root->stripesize, root, fs_info, objectid); ret = btrfs_find_last_root(tree_root, objectid, @@ -652,7 +667,7 @@ static int find_and_setup_log_root(struct btrfs_root *tree_root, blocksize = tree_root->nodesize; - __setup_root(tree_root->nodesize, tree_root->leafsize, + btrfs_setup_root(tree_root->nodesize, tree_root->leafsize, tree_root->sectorsize, tree_root->stripesize, log_root, fs_info, BTRFS_TREE_LOG_OBJECTID); @@ -716,12 +731,16 @@ 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, + btrfs_setup_root(tree_root->nodesize, tree_root->leafsize, tree_root->sectorsize, tree_root->stripesize, 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) @@ -796,7 +815,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); @@ -818,12 +838,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); @@ -882,7 +904,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; @@ -901,13 +924,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; } @@ -932,7 +964,7 @@ 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) { @@ -954,14 +986,14 @@ static int setup_root_or_create_block(struct btrfs_fs_info *fs_info, btrfs_find_create_tree_block(fs_info, 0, nodesize); 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; @@ -980,7 +1012,7 @@ int btrfs_setup_all_roots(struct btrfs_fs_info *fs_info, u64 root_tree_bytenr, stripesize = btrfs_super_stripesize(sb); root = fs_info->tree_root; - __setup_root(nodesize, leafsize, sectorsize, stripesize, + btrfs_setup_root(nodesize, leafsize, sectorsize, stripesize, root, fs_info, BTRFS_ROOT_TREE_OBJECTID); blocksize = root->nodesize; generation = btrfs_super_generation(sb); @@ -1028,10 +1060,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) { @@ -1114,7 +1150,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; @@ -1131,19 +1167,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; } @@ -1167,7 +1205,7 @@ int btrfs_setup_chunk_tree_and_device_map(struct btrfs_fs_info *fs_info, sectorsize = btrfs_super_sectorsize(sb); stripesize = btrfs_super_stripesize(sb); - __setup_root(nodesize, leafsize, sectorsize, stripesize, + btrfs_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); @@ -1217,7 +1255,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; @@ -1225,6 +1263,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; @@ -1247,9 +1286,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; @@ -1268,10 +1316,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; @@ -1285,8 +1334,7 @@ static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path, memcpy(fs_info->fsid, &disk_super->fsid, BTRFS_FSID_SIZE); - 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; @@ -1323,7 +1371,7 @@ 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; @@ -1356,7 +1404,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; @@ -1371,12 +1419,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; @@ -1392,27 +1444,31 @@ 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) { - error("superblock magic doesn't match"); - 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)) { - 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); @@ -1476,7 +1532,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; } @@ -1517,7 +1574,7 @@ static int check_super(struct btrfs_super_block *sb) } if (btrfs_super_sys_array_size(sb) < sizeof(struct btrfs_disk_key) + sizeof(struct btrfs_chunk)) { - error("system chunk array too small %u < %lu", + error("system chunk array too small %u < %zu", btrfs_super_sys_array_size(sb), sizeof(struct btrfs_disk_key) + sizeof(struct btrfs_chunk)); @@ -1532,7 +1589,7 @@ error_out: } 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 +1597,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 +1639,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) { @@ -1611,9 +1674,9 @@ static int write_dev_supers(struct btrfs_root *root, if (root->fs_info->super_bytenr != BTRFS_SUPER_INFO_OFFSET) { btrfs_set_super_bytenr(sb, root->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 @@ -1635,9 +1698,9 @@ 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 @@ -1743,17 +1806,26 @@ int close_ctree_fs_info(struct btrfs_fs_info *fs_info) ret = __commit_transaction(trans, root); BUG_ON(ret); write_ctree_super(trans, root); - btrfs_free_transaction(root, trans); + 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(root); + if (ret) + fprintf(stderr, + "failed to write new super block err %d\n", ret); } 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; + return ret; } int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, @@ -1762,12 +1834,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);