aboutsummaryrefslogtreecommitdiffstats
path: root/fs/btrfs
diff options
context:
space:
mode:
Diffstat (limited to 'fs/btrfs')
-rw-r--r--fs/btrfs/ctree.c8
-rw-r--r--fs/btrfs/ctree.h18
-rw-r--r--fs/btrfs/disk-io.c56
-rw-r--r--fs/btrfs/extent-tree.c31
-rw-r--r--fs/btrfs/ioctl.c2
-rw-r--r--fs/btrfs/super.c9
-rw-r--r--fs/btrfs/volumes.c1103
-rw-r--r--fs/btrfs/volumes.h20
8 files changed, 932 insertions, 315 deletions
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 8bb452456d90..dd1c03aea2df 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -185,6 +185,10 @@ int btrfs_copy_root(struct btrfs_trans_handle *trans,
185 btrfs_set_header_owner(cow, new_root_objectid); 185 btrfs_set_header_owner(cow, new_root_objectid);
186 btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN); 186 btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN);
187 187
188 write_extent_buffer(cow, root->fs_info->fsid,
189 (unsigned long)btrfs_header_fsid(cow),
190 BTRFS_FSID_SIZE);
191
188 WARN_ON(btrfs_header_generation(buf) > trans->transid); 192 WARN_ON(btrfs_header_generation(buf) > trans->transid);
189 ret = btrfs_inc_ref(trans, new_root, buf, cow, NULL); 193 ret = btrfs_inc_ref(trans, new_root, buf, cow, NULL);
190 kfree(new_root); 194 kfree(new_root);
@@ -274,6 +278,10 @@ int noinline __btrfs_cow_block(struct btrfs_trans_handle *trans,
274 btrfs_set_header_owner(cow, root->root_key.objectid); 278 btrfs_set_header_owner(cow, root->root_key.objectid);
275 btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN); 279 btrfs_clear_header_flag(cow, BTRFS_HEADER_FLAG_WRITTEN);
276 280
281 write_extent_buffer(cow, root->fs_info->fsid,
282 (unsigned long)btrfs_header_fsid(cow),
283 BTRFS_FSID_SIZE);
284
277 WARN_ON(btrfs_header_generation(buf) > trans->transid); 285 WARN_ON(btrfs_header_generation(buf) > trans->transid);
278 if (btrfs_header_generation(buf) != trans->transid) { 286 if (btrfs_header_generation(buf) != trans->transid) {
279 u32 nr_extents; 287 u32 nr_extents;
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index c4c6c127323b..5ff74282a620 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -177,6 +177,9 @@ struct btrfs_dev_item {
177 /* type and info about this device */ 177 /* type and info about this device */
178 __le64 type; 178 __le64 type;
179 179
180 /* expected generation for this device */
181 __le64 generation;
182
180 /* grouping information for allocation decisions */ 183 /* grouping information for allocation decisions */
181 __le32 dev_group; 184 __le32 dev_group;
182 185
@@ -188,6 +191,9 @@ struct btrfs_dev_item {
188 191
189 /* btrfs generated uuid for this device */ 192 /* btrfs generated uuid for this device */
190 u8 uuid[BTRFS_UUID_SIZE]; 193 u8 uuid[BTRFS_UUID_SIZE];
194
195 /* uuid of FS who owns this device */
196 u8 fsid[BTRFS_UUID_SIZE];
191} __attribute__ ((__packed__)); 197} __attribute__ ((__packed__));
192 198
193struct btrfs_stripe { 199struct btrfs_stripe {
@@ -263,6 +269,7 @@ struct btrfs_header {
263 sizeof(struct btrfs_item) - \ 269 sizeof(struct btrfs_item) - \
264 sizeof(struct btrfs_file_extent_item)) 270 sizeof(struct btrfs_file_extent_item))
265 271
272#define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32)
266 273
267/* 274/*
268 * this is a very generous portion of the super block, giving us 275 * this is a very generous portion of the super block, giving us
@@ -278,7 +285,7 @@ struct btrfs_header {
278struct btrfs_super_block { 285struct btrfs_super_block {
279 u8 csum[BTRFS_CSUM_SIZE]; 286 u8 csum[BTRFS_CSUM_SIZE];
280 /* the first 4 fields must match struct btrfs_header */ 287 /* the first 4 fields must match struct btrfs_header */
281 u8 fsid[16]; /* FS specific uuid */ 288 u8 fsid[BTRFS_FSID_SIZE]; /* FS specific uuid */
282 __le64 bytenr; /* this block number */ 289 __le64 bytenr; /* this block number */
283 __le64 flags; 290 __le64 flags;
284 291
@@ -941,6 +948,7 @@ BTRFS_SETGET_FUNCS(device_id, struct btrfs_dev_item, devid, 64);
941BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32); 948BTRFS_SETGET_FUNCS(device_group, struct btrfs_dev_item, dev_group, 32);
942BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8); 949BTRFS_SETGET_FUNCS(device_seek_speed, struct btrfs_dev_item, seek_speed, 8);
943BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8); 950BTRFS_SETGET_FUNCS(device_bandwidth, struct btrfs_dev_item, bandwidth, 8);
951BTRFS_SETGET_FUNCS(device_generation, struct btrfs_dev_item, generation, 64);
944 952
945BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64); 953BTRFS_SETGET_STACK_FUNCS(stack_device_type, struct btrfs_dev_item, type, 64);
946BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item, 954BTRFS_SETGET_STACK_FUNCS(stack_device_total_bytes, struct btrfs_dev_item,
@@ -960,12 +968,19 @@ BTRFS_SETGET_STACK_FUNCS(stack_device_seek_speed, struct btrfs_dev_item,
960 seek_speed, 8); 968 seek_speed, 8);
961BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item, 969BTRFS_SETGET_STACK_FUNCS(stack_device_bandwidth, struct btrfs_dev_item,
962 bandwidth, 8); 970 bandwidth, 8);
971BTRFS_SETGET_STACK_FUNCS(stack_device_generation, struct btrfs_dev_item,
972 generation, 64);
963 973
964static inline char *btrfs_device_uuid(struct btrfs_dev_item *d) 974static inline char *btrfs_device_uuid(struct btrfs_dev_item *d)
965{ 975{
966 return (char *)d + offsetof(struct btrfs_dev_item, uuid); 976 return (char *)d + offsetof(struct btrfs_dev_item, uuid);
967} 977}
968 978
979static inline char *btrfs_device_fsid(struct btrfs_dev_item *d)
980{
981 return (char *)d + offsetof(struct btrfs_dev_item, fsid);
982}
983
969BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64); 984BTRFS_SETGET_FUNCS(chunk_length, struct btrfs_chunk, length, 64);
970BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64); 985BTRFS_SETGET_FUNCS(chunk_owner, struct btrfs_chunk, owner, 64);
971BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64); 986BTRFS_SETGET_FUNCS(chunk_stripe_len, struct btrfs_chunk, stripe_len, 64);
@@ -1661,6 +1676,7 @@ int btrfs_reloc_tree_cache_ref(struct btrfs_trans_handle *trans,
1661 struct extent_buffer *buf, u64 orig_start); 1676 struct extent_buffer *buf, u64 orig_start);
1662int btrfs_add_dead_reloc_root(struct btrfs_root *root); 1677int btrfs_add_dead_reloc_root(struct btrfs_root *root);
1663int btrfs_cleanup_reloc_trees(struct btrfs_root *root); 1678int btrfs_cleanup_reloc_trees(struct btrfs_root *root);
1679u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags);
1664/* ctree.c */ 1680/* ctree.c */
1665int btrfs_previous_item(struct btrfs_root *root, 1681int btrfs_previous_item(struct btrfs_root *root,
1666 struct btrfs_path *path, u64 min_objectid, 1682 struct btrfs_path *path, u64 min_objectid,
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index c599f0ee997a..82833e5d84b6 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -345,6 +345,25 @@ out:
345 return 0; 345 return 0;
346} 346}
347 347
348static int check_tree_block_fsid(struct btrfs_root *root,
349 struct extent_buffer *eb)
350{
351 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
352 u8 fsid[BTRFS_UUID_SIZE];
353 int ret = 1;
354
355 read_extent_buffer(eb, fsid, (unsigned long)btrfs_header_fsid(eb),
356 BTRFS_FSID_SIZE);
357 while (fs_devices) {
358 if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
359 ret = 0;
360 break;
361 }
362 fs_devices = fs_devices->seed;
363 }
364 return ret;
365}
366
348int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end, 367int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
349 struct extent_state *state) 368 struct extent_state *state)
350{ 369{
@@ -382,9 +401,7 @@ int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
382 ret = -EIO; 401 ret = -EIO;
383 goto err; 402 goto err;
384 } 403 }
385 if (memcmp_extent_buffer(eb, root->fs_info->fsid, 404 if (check_tree_block_fsid(root, eb)) {
386 (unsigned long)btrfs_header_fsid(eb),
387 BTRFS_FSID_SIZE)) {
388 printk("bad fsid on block %Lu\n", eb->start); 405 printk("bad fsid on block %Lu\n", eb->start);
389 ret = -EIO; 406 ret = -EIO;
390 goto err; 407 goto err;
@@ -1558,9 +1575,11 @@ struct btrfs_root *open_ctree(struct super_block *sb,
1558 if (!btrfs_super_root(disk_super)) 1575 if (!btrfs_super_root(disk_super))
1559 goto fail_sb_buffer; 1576 goto fail_sb_buffer;
1560 1577
1561 err = btrfs_parse_options(tree_root, options); 1578 ret = btrfs_parse_options(tree_root, options);
1562 if (err) 1579 if (ret) {
1580 err = ret;
1563 goto fail_sb_buffer; 1581 goto fail_sb_buffer;
1582 }
1564 1583
1565 /* 1584 /*
1566 * we need to start all the end_io workers up front because the 1585 * we need to start all the end_io workers up front because the
@@ -1610,18 +1629,6 @@ struct btrfs_root *open_ctree(struct super_block *sb,
1610 btrfs_start_workers(&fs_info->endio_write_workers, 1629 btrfs_start_workers(&fs_info->endio_write_workers,
1611 fs_info->thread_pool_size); 1630 fs_info->thread_pool_size);
1612 1631
1613 err = -EINVAL;
1614 if (btrfs_super_num_devices(disk_super) > fs_devices->open_devices) {
1615 printk("Btrfs: wanted %llu devices, but found %llu\n",
1616 (unsigned long long)btrfs_super_num_devices(disk_super),
1617 (unsigned long long)fs_devices->open_devices);
1618 if (btrfs_test_opt(tree_root, DEGRADED))
1619 printk("continuing in degraded mode\n");
1620 else {
1621 goto fail_sb_buffer;
1622 }
1623 }
1624
1625 fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super); 1632 fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
1626 fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages, 1633 fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
1627 4 * 1024 * 1024 / PAGE_CACHE_SIZE); 1634 4 * 1024 * 1024 / PAGE_CACHE_SIZE);
@@ -1672,7 +1679,10 @@ struct btrfs_root *open_ctree(struct super_block *sb,
1672 mutex_lock(&fs_info->chunk_mutex); 1679 mutex_lock(&fs_info->chunk_mutex);
1673 ret = btrfs_read_chunk_tree(chunk_root); 1680 ret = btrfs_read_chunk_tree(chunk_root);
1674 mutex_unlock(&fs_info->chunk_mutex); 1681 mutex_unlock(&fs_info->chunk_mutex);
1675 BUG_ON(ret); 1682 if (ret) {
1683 printk("btrfs: failed to read chunk tree on %s\n", sb->s_id);
1684 goto fail_chunk_root;
1685 }
1676 1686
1677 btrfs_close_extra_devices(fs_devices); 1687 btrfs_close_extra_devices(fs_devices);
1678 1688
@@ -1684,7 +1694,7 @@ struct btrfs_root *open_ctree(struct super_block *sb,
1684 btrfs_super_root(disk_super), 1694 btrfs_super_root(disk_super),
1685 blocksize, generation); 1695 blocksize, generation);
1686 if (!tree_root->node) 1696 if (!tree_root->node)
1687 goto fail_sb_buffer; 1697 goto fail_chunk_root;
1688 1698
1689 1699
1690 ret = find_and_setup_root(tree_root, fs_info, 1700 ret = find_and_setup_root(tree_root, fs_info,
@@ -1753,6 +1763,8 @@ fail_extent_root:
1753 free_extent_buffer(extent_root->node); 1763 free_extent_buffer(extent_root->node);
1754fail_tree_root: 1764fail_tree_root:
1755 free_extent_buffer(tree_root->node); 1765 free_extent_buffer(tree_root->node);
1766fail_chunk_root:
1767 free_extent_buffer(chunk_root->node);
1756fail_sys_array: 1768fail_sys_array:
1757fail_sb_buffer: 1769fail_sb_buffer:
1758 btrfs_stop_workers(&fs_info->fixup_workers); 1770 btrfs_stop_workers(&fs_info->fixup_workers);
@@ -1823,9 +1835,10 @@ int write_all_supers(struct btrfs_root *root)
1823 total_errors++; 1835 total_errors++;
1824 continue; 1836 continue;
1825 } 1837 }
1826 if (!dev->in_fs_metadata) 1838 if (!dev->in_fs_metadata || !dev->writeable)
1827 continue; 1839 continue;
1828 1840
1841 btrfs_set_stack_device_generation(dev_item, 0);
1829 btrfs_set_stack_device_type(dev_item, dev->type); 1842 btrfs_set_stack_device_type(dev_item, dev->type);
1830 btrfs_set_stack_device_id(dev_item, dev->devid); 1843 btrfs_set_stack_device_id(dev_item, dev->devid);
1831 btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes); 1844 btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
@@ -1834,6 +1847,7 @@ int write_all_supers(struct btrfs_root *root)
1834 btrfs_set_stack_device_io_width(dev_item, dev->io_width); 1847 btrfs_set_stack_device_io_width(dev_item, dev->io_width);
1835 btrfs_set_stack_device_sector_size(dev_item, dev->sector_size); 1848 btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
1836 memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE); 1849 memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
1850 memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
1837 flags = btrfs_super_flags(sb); 1851 flags = btrfs_super_flags(sb);
1838 btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN); 1852 btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
1839 1853
@@ -1881,7 +1895,7 @@ int write_all_supers(struct btrfs_root *root)
1881 dev = list_entry(cur, struct btrfs_device, dev_list); 1895 dev = list_entry(cur, struct btrfs_device, dev_list);
1882 if (!dev->bdev) 1896 if (!dev->bdev)
1883 continue; 1897 continue;
1884 if (!dev->in_fs_metadata) 1898 if (!dev->in_fs_metadata || !dev->writeable)
1885 continue; 1899 continue;
1886 1900
1887 BUG_ON(!dev->pending_io); 1901 BUG_ON(!dev->pending_io);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index af2de30dbeac..197422c1dc4b 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -355,7 +355,7 @@ __btrfs_find_block_group(struct btrfs_root *root,
355 if (search_start) { 355 if (search_start) {
356 struct btrfs_block_group_cache *shint; 356 struct btrfs_block_group_cache *shint;
357 shint = btrfs_lookup_first_block_group(info, search_start); 357 shint = btrfs_lookup_first_block_group(info, search_start);
358 if (shint && block_group_bits(shint, data) && !shint->ro) { 358 if (shint && block_group_bits(shint, data)) {
359 spin_lock(&shint->lock); 359 spin_lock(&shint->lock);
360 used = btrfs_block_group_used(&shint->item); 360 used = btrfs_block_group_used(&shint->item);
361 if (used + shint->pinned + shint->reserved < 361 if (used + shint->pinned + shint->reserved <
@@ -366,7 +366,7 @@ __btrfs_find_block_group(struct btrfs_root *root,
366 spin_unlock(&shint->lock); 366 spin_unlock(&shint->lock);
367 } 367 }
368 } 368 }
369 if (hint && !hint->ro && block_group_bits(hint, data)) { 369 if (hint && block_group_bits(hint, data)) {
370 spin_lock(&hint->lock); 370 spin_lock(&hint->lock);
371 used = btrfs_block_group_used(&hint->item); 371 used = btrfs_block_group_used(&hint->item);
372 if (used + hint->pinned + hint->reserved < 372 if (used + hint->pinned + hint->reserved <
@@ -392,7 +392,7 @@ again:
392 last = cache->key.objectid + cache->key.offset; 392 last = cache->key.objectid + cache->key.offset;
393 used = btrfs_block_group_used(&cache->item); 393 used = btrfs_block_group_used(&cache->item);
394 394
395 if (!cache->ro && block_group_bits(cache, data)) { 395 if (block_group_bits(cache, data)) {
396 free_check = div_factor(cache->key.offset, factor); 396 free_check = div_factor(cache->key.offset, factor);
397 if (used + cache->pinned + cache->reserved < 397 if (used + cache->pinned + cache->reserved <
398 free_check) { 398 free_check) {
@@ -1843,9 +1843,9 @@ static void set_block_group_readonly(struct btrfs_block_group_cache *cache)
1843 spin_unlock(&cache->space_info->lock); 1843 spin_unlock(&cache->space_info->lock);
1844} 1844}
1845 1845
1846static u64 reduce_alloc_profile(struct btrfs_root *root, u64 flags) 1846u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags)
1847{ 1847{
1848 u64 num_devices = root->fs_info->fs_devices->num_devices; 1848 u64 num_devices = root->fs_info->fs_devices->rw_devices;
1849 1849
1850 if (num_devices == 1) 1850 if (num_devices == 1)
1851 flags &= ~(BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID0); 1851 flags &= ~(BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID0);
@@ -1877,13 +1877,11 @@ static int do_chunk_alloc(struct btrfs_trans_handle *trans,
1877{ 1877{
1878 struct btrfs_space_info *space_info; 1878 struct btrfs_space_info *space_info;
1879 u64 thresh; 1879 u64 thresh;
1880 u64 start;
1881 u64 num_bytes;
1882 int ret = 0; 1880 int ret = 0;
1883 1881
1884 mutex_lock(&extent_root->fs_info->chunk_mutex); 1882 mutex_lock(&extent_root->fs_info->chunk_mutex);
1885 1883
1886 flags = reduce_alloc_profile(extent_root, flags); 1884 flags = btrfs_reduce_alloc_profile(extent_root, flags);
1887 1885
1888 space_info = __find_space_info(extent_root->fs_info, flags); 1886 space_info = __find_space_info(extent_root->fs_info, flags);
1889 if (!space_info) { 1887 if (!space_info) {
@@ -1913,16 +1911,11 @@ static int do_chunk_alloc(struct btrfs_trans_handle *trans,
1913 } 1911 }
1914 spin_unlock(&space_info->lock); 1912 spin_unlock(&space_info->lock);
1915 1913
1916 ret = btrfs_alloc_chunk(trans, extent_root, &start, &num_bytes, flags); 1914 ret = btrfs_alloc_chunk(trans, extent_root, flags);
1917 if (ret) { 1915 if (ret) {
1918printk("space info full %Lu\n", flags); 1916printk("space info full %Lu\n", flags);
1919 space_info->full = 1; 1917 space_info->full = 1;
1920 goto out;
1921 } 1918 }
1922
1923 ret = btrfs_make_block_group(trans, extent_root, 0, flags,
1924 BTRFS_FIRST_CHUNK_TREE_OBJECTID, start, num_bytes);
1925 BUG_ON(ret);
1926out: 1919out:
1927 mutex_unlock(&extent_root->fs_info->chunk_mutex); 1920 mutex_unlock(&extent_root->fs_info->chunk_mutex);
1928 return ret; 1921 return ret;
@@ -3040,7 +3033,7 @@ static int __btrfs_reserve_extent(struct btrfs_trans_handle *trans,
3040 data = BTRFS_BLOCK_GROUP_METADATA | alloc_profile; 3033 data = BTRFS_BLOCK_GROUP_METADATA | alloc_profile;
3041 } 3034 }
3042again: 3035again:
3043 data = reduce_alloc_profile(root, data); 3036 data = btrfs_reduce_alloc_profile(root, data);
3044 /* 3037 /*
3045 * the only place that sets empty_size is btrfs_realloc_node, which 3038 * the only place that sets empty_size is btrfs_realloc_node, which
3046 * is not called recursively on allocations 3039 * is not called recursively on allocations
@@ -5136,7 +5129,8 @@ static int noinline relocate_one_path(struct btrfs_trans_handle *trans,
5136 else 5129 else
5137 btrfs_node_key_to_cpu(eb, &keys[level], 0); 5130 btrfs_node_key_to_cpu(eb, &keys[level], 0);
5138 } 5131 }
5139 if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) { 5132 if (nodes[0] &&
5133 ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
5140 eb = path->nodes[0]; 5134 eb = path->nodes[0];
5141 ret = replace_extents_in_leaf(trans, reloc_root, eb, 5135 ret = replace_extents_in_leaf(trans, reloc_root, eb,
5142 group, reloc_inode); 5136 group, reloc_inode);
@@ -5377,7 +5371,7 @@ static u64 update_block_group_flags(struct btrfs_root *root, u64 flags)
5377 u64 stripped = BTRFS_BLOCK_GROUP_RAID0 | 5371 u64 stripped = BTRFS_BLOCK_GROUP_RAID0 |
5378 BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10; 5372 BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10;
5379 5373
5380 num_devices = root->fs_info->fs_devices->num_devices; 5374 num_devices = root->fs_info->fs_devices->rw_devices;
5381 if (num_devices == 1) { 5375 if (num_devices == 1) {
5382 stripped |= BTRFS_BLOCK_GROUP_DUP; 5376 stripped |= BTRFS_BLOCK_GROUP_DUP;
5383 stripped = flags & ~stripped; 5377 stripped = flags & ~stripped;
@@ -5801,6 +5795,8 @@ int btrfs_read_block_groups(struct btrfs_root *root)
5801 BUG_ON(ret); 5795 BUG_ON(ret);
5802 5796
5803 set_avail_alloc_bits(root->fs_info, cache->flags); 5797 set_avail_alloc_bits(root->fs_info, cache->flags);
5798 if (btrfs_chunk_readonly(root, cache->key.objectid))
5799 set_block_group_readonly(cache);
5804 } 5800 }
5805 ret = 0; 5801 ret = 0;
5806error: 5802error:
@@ -5889,6 +5885,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
5889 block_group->space_info->total_bytes -= block_group->key.offset; 5885 block_group->space_info->total_bytes -= block_group->key.offset;
5890 block_group->space_info->bytes_readonly -= block_group->key.offset; 5886 block_group->space_info->bytes_readonly -= block_group->key.offset;
5891 spin_unlock(&block_group->space_info->lock); 5887 spin_unlock(&block_group->space_info->lock);
5888 block_group->space_info->full = 0;
5892 5889
5893 /* 5890 /*
5894 memset(shrink_block_group, 0, sizeof(*shrink_block_group)); 5891 memset(shrink_block_group, 0, sizeof(*shrink_block_group));
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 52863cebd594..f43df72b0e17 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -405,7 +405,7 @@ static int btrfs_ioctl_resize(struct btrfs_root *root, void __user *arg)
405 devid = simple_strtoull(devstr, &end, 10); 405 devid = simple_strtoull(devstr, &end, 10);
406 printk(KERN_INFO "resizing devid %llu\n", devid); 406 printk(KERN_INFO "resizing devid %llu\n", devid);
407 } 407 }
408 device = btrfs_find_device(root, devid, NULL); 408 device = btrfs_find_device(root, devid, NULL, NULL);
409 if (!device) { 409 if (!device) {
410 printk(KERN_INFO "resizer unable to find device %llu\n", devid); 410 printk(KERN_INFO "resizer unable to find device %llu\n", devid);
411 ret = -EINVAL; 411 ret = -EINVAL;
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 04a3bf816509..92393cc60d08 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -431,6 +431,11 @@ static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
431 if (error) 431 if (error)
432 goto error_free_subvol_name; 432 goto error_free_subvol_name;
433 433
434 if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
435 error = -EACCES;
436 goto error_close_devices;
437 }
438
434 bdev = fs_devices->latest_bdev; 439 bdev = fs_devices->latest_bdev;
435 s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices); 440 s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
436 if (IS_ERR(s)) 441 if (IS_ERR(s))
@@ -444,6 +449,7 @@ static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
444 goto error_close_devices; 449 goto error_close_devices;
445 } 450 }
446 451
452 btrfs_close_devices(fs_devices);
447 } else { 453 } else {
448 char b[BDEVNAME_SIZE]; 454 char b[BDEVNAME_SIZE];
449 455
@@ -512,6 +518,9 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
512 ret = btrfs_commit_super(root); 518 ret = btrfs_commit_super(root);
513 WARN_ON(ret); 519 WARN_ON(ret);
514 } else { 520 } else {
521 if (root->fs_info->fs_devices->rw_devices == 0)
522 return -EACCES;
523
515 if (btrfs_super_log_root(&root->fs_info->super_copy) != 0) 524 if (btrfs_super_log_root(&root->fs_info->super_copy) != 0)
516 return -EINVAL; 525 return -EINVAL;
517 526
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 80a27284dbf1..d6f1996de629 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -40,6 +40,12 @@ struct map_lookup {
40 struct btrfs_bio_stripe stripes[]; 40 struct btrfs_bio_stripe stripes[];
41}; 41};
42 42
43static int init_first_rw_device(struct btrfs_trans_handle *trans,
44 struct btrfs_root *root,
45 struct btrfs_device *device);
46static int btrfs_relocate_sys_chunks(struct btrfs_root *root);
47
48
43#define map_lookup_size(n) (sizeof(struct map_lookup) + \ 49#define map_lookup_size(n) (sizeof(struct map_lookup) + \
44 (sizeof(struct btrfs_bio_stripe) * (n))) 50 (sizeof(struct btrfs_bio_stripe) * (n)))
45 51
@@ -69,25 +75,31 @@ static void unlock_chunks(struct btrfs_root *root)
69int btrfs_cleanup_fs_uuids(void) 75int btrfs_cleanup_fs_uuids(void)
70{ 76{
71 struct btrfs_fs_devices *fs_devices; 77 struct btrfs_fs_devices *fs_devices;
72 struct list_head *uuid_cur;
73 struct list_head *devices_cur;
74 struct btrfs_device *dev; 78 struct btrfs_device *dev;
75 79
76 list_for_each(uuid_cur, &fs_uuids) { 80 while (!list_empty(&fs_uuids)) {
77 fs_devices = list_entry(uuid_cur, struct btrfs_fs_devices, 81 fs_devices = list_entry(fs_uuids.next,
78 list); 82 struct btrfs_fs_devices, list);
83 list_del(&fs_devices->list);
79 while(!list_empty(&fs_devices->devices)) { 84 while(!list_empty(&fs_devices->devices)) {
80 devices_cur = fs_devices->devices.next; 85 dev = list_entry(fs_devices->devices.next,
81 dev = list_entry(devices_cur, struct btrfs_device, 86 struct btrfs_device, dev_list);
82 dev_list);
83 if (dev->bdev) { 87 if (dev->bdev) {
84 close_bdev_excl(dev->bdev); 88 close_bdev_excl(dev->bdev);
85 fs_devices->open_devices--; 89 fs_devices->open_devices--;
86 } 90 }
91 fs_devices->num_devices--;
92 if (dev->writeable)
93 fs_devices->rw_devices--;
87 list_del(&dev->dev_list); 94 list_del(&dev->dev_list);
95 list_del(&dev->dev_alloc_list);
88 kfree(dev->name); 96 kfree(dev->name);
89 kfree(dev); 97 kfree(dev);
90 } 98 }
99 WARN_ON(fs_devices->num_devices);
100 WARN_ON(fs_devices->open_devices);
101 WARN_ON(fs_devices->rw_devices);
102 kfree(fs_devices);
91 } 103 }
92 return 0; 104 return 0;
93} 105}
@@ -257,6 +269,9 @@ static noinline int device_list_add(const char *path,
257 disk_super->dev_item.uuid); 269 disk_super->dev_item.uuid);
258 } 270 }
259 if (!device) { 271 if (!device) {
272 if (fs_devices->opened)
273 return -EBUSY;
274
260 device = kzalloc(sizeof(*device), GFP_NOFS); 275 device = kzalloc(sizeof(*device), GFP_NOFS);
261 if (!device) { 276 if (!device) {
262 /* we can safely leave the fs_devices entry around */ 277 /* we can safely leave the fs_devices entry around */
@@ -273,8 +288,9 @@ static noinline int device_list_add(const char *path,
273 kfree(device); 288 kfree(device);
274 return -ENOMEM; 289 return -ENOMEM;
275 } 290 }
291 INIT_LIST_HEAD(&device->dev_alloc_list);
276 list_add(&device->dev_list, &fs_devices->devices); 292 list_add(&device->dev_list, &fs_devices->devices);
277 list_add(&device->dev_alloc_list, &fs_devices->alloc_list); 293 device->fs_devices = fs_devices;
278 fs_devices->num_devices++; 294 fs_devices->num_devices++;
279 } 295 }
280 296
@@ -288,58 +304,94 @@ static noinline int device_list_add(const char *path,
288 304
289int btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices) 305int btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices)
290{ 306{
291 struct list_head *head = &fs_devices->devices; 307 struct list_head *tmp;
292 struct list_head *cur; 308 struct list_head *cur;
293 struct btrfs_device *device; 309 struct btrfs_device *device;
310 int seed_devices = 0;
294 311
295 mutex_lock(&uuid_mutex); 312 mutex_lock(&uuid_mutex);
296again: 313again:
297 list_for_each(cur, head) { 314 list_for_each_safe(cur, tmp, &fs_devices->devices) {
298 device = list_entry(cur, struct btrfs_device, dev_list); 315 device = list_entry(cur, struct btrfs_device, dev_list);
299 if (!device->in_fs_metadata) { 316 if (device->in_fs_metadata)
300 struct block_device *bdev; 317 continue;
301 list_del(&device->dev_list); 318
302 list_del(&device->dev_alloc_list); 319 if (device->bdev) {
320 close_bdev_excl(device->bdev);
321 device->bdev = NULL;
322 fs_devices->open_devices--;
323 }
324 if (device->writeable) {
325 list_del_init(&device->dev_alloc_list);
326 device->writeable = 0;
327 fs_devices->rw_devices--;
328 }
329 if (!seed_devices) {
330 list_del_init(&device->dev_list);
303 fs_devices->num_devices--; 331 fs_devices->num_devices--;
304 if (device->bdev) {
305 bdev = device->bdev;
306 fs_devices->open_devices--;
307 mutex_unlock(&uuid_mutex);
308 close_bdev_excl(bdev);
309 mutex_lock(&uuid_mutex);
310 }
311 kfree(device->name); 332 kfree(device->name);
312 kfree(device); 333 kfree(device);
313 goto again;
314 } 334 }
315 } 335 }
336
337 if (fs_devices->seed) {
338 fs_devices = fs_devices->seed;
339 seed_devices = 1;
340 goto again;
341 }
342
316 mutex_unlock(&uuid_mutex); 343 mutex_unlock(&uuid_mutex);
317 return 0; 344 return 0;
318} 345}
319 346
320int btrfs_close_devices(struct btrfs_fs_devices *fs_devices) 347static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
321{ 348{
322 struct list_head *head = &fs_devices->devices; 349 struct btrfs_fs_devices *seed_devices;
323 struct list_head *cur; 350 struct list_head *cur;
324 struct btrfs_device *device; 351 struct btrfs_device *device;
352again:
353 if (--fs_devices->opened > 0)
354 return 0;
325 355
326 mutex_lock(&uuid_mutex); 356 list_for_each(cur, &fs_devices->devices) {
327 list_for_each(cur, head) {
328 device = list_entry(cur, struct btrfs_device, dev_list); 357 device = list_entry(cur, struct btrfs_device, dev_list);
329 if (device->bdev) { 358 if (device->bdev) {
330 close_bdev_excl(device->bdev); 359 close_bdev_excl(device->bdev);
331 fs_devices->open_devices--; 360 fs_devices->open_devices--;
332 } 361 }
362 if (device->writeable) {
363 list_del_init(&device->dev_alloc_list);
364 fs_devices->rw_devices--;
365 }
366
333 device->bdev = NULL; 367 device->bdev = NULL;
368 device->writeable = 0;
334 device->in_fs_metadata = 0; 369 device->in_fs_metadata = 0;
335 } 370 }
336 fs_devices->mounted = 0; 371 fs_devices->opened = 0;
337 mutex_unlock(&uuid_mutex); 372 fs_devices->seeding = 0;
373 fs_devices->sprouted = 0;
374
375 seed_devices = fs_devices->seed;
376 fs_devices->seed = NULL;
377 if (seed_devices) {
378 fs_devices = seed_devices;
379 goto again;
380 }
338 return 0; 381 return 0;
339} 382}
340 383
341int btrfs_open_devices(struct btrfs_fs_devices *fs_devices, 384int btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
342 int flags, void *holder) 385{
386 int ret;
387
388 mutex_lock(&uuid_mutex);
389 ret = __btrfs_close_devices(fs_devices);
390 mutex_unlock(&uuid_mutex);
391 return ret;
392}
393
394int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices, void *holder)
343{ 395{
344 struct block_device *bdev; 396 struct block_device *bdev;
345 struct list_head *head = &fs_devices->devices; 397 struct list_head *head = &fs_devices->devices;
@@ -350,24 +402,18 @@ int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
350 struct btrfs_super_block *disk_super; 402 struct btrfs_super_block *disk_super;
351 u64 latest_devid = 0; 403 u64 latest_devid = 0;
352 u64 latest_transid = 0; 404 u64 latest_transid = 0;
353 u64 transid;
354 u64 devid; 405 u64 devid;
406 int seeding = 1;
355 int ret = 0; 407 int ret = 0;
356 408
357 mutex_lock(&uuid_mutex);
358 if (fs_devices->mounted)
359 goto out;
360
361 list_for_each(cur, head) { 409 list_for_each(cur, head) {
362 device = list_entry(cur, struct btrfs_device, dev_list); 410 device = list_entry(cur, struct btrfs_device, dev_list);
363 if (device->bdev) 411 if (device->bdev)
364 continue; 412 continue;
365
366 if (!device->name) 413 if (!device->name)
367 continue; 414 continue;
368 415
369 bdev = open_bdev_excl(device->name, flags, holder); 416 bdev = open_bdev_excl(device->name, MS_RDONLY, holder);
370
371 if (IS_ERR(bdev)) { 417 if (IS_ERR(bdev)) {
372 printk("open %s failed\n", device->name); 418 printk("open %s failed\n", device->name);
373 goto error; 419 goto error;
@@ -387,16 +433,32 @@ int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
387 if (devid != device->devid) 433 if (devid != device->devid)
388 goto error_brelse; 434 goto error_brelse;
389 435
390 transid = btrfs_super_generation(disk_super); 436 if (memcmp(device->uuid, disk_super->dev_item.uuid,
391 if (!latest_transid || transid > latest_transid) { 437 BTRFS_UUID_SIZE))
438 goto error_brelse;
439
440 device->generation = btrfs_super_generation(disk_super);
441 if (!latest_transid || device->generation > latest_transid) {
392 latest_devid = devid; 442 latest_devid = devid;
393 latest_transid = transid; 443 latest_transid = device->generation;
394 latest_bdev = bdev; 444 latest_bdev = bdev;
395 } 445 }
396 446
447 if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_SEEDING) {
448 device->writeable = 0;
449 } else {
450 device->writeable = !bdev_read_only(bdev);
451 seeding = 0;
452 }
453
397 device->bdev = bdev; 454 device->bdev = bdev;
398 device->in_fs_metadata = 0; 455 device->in_fs_metadata = 0;
399 fs_devices->open_devices++; 456 fs_devices->open_devices++;
457 if (device->writeable) {
458 fs_devices->rw_devices++;
459 list_add(&device->dev_alloc_list,
460 &fs_devices->alloc_list);
461 }
400 continue; 462 continue;
401 463
402error_brelse: 464error_brelse:
@@ -410,11 +472,32 @@ error:
410 ret = -EIO; 472 ret = -EIO;
411 goto out; 473 goto out;
412 } 474 }
413 fs_devices->mounted = 1; 475 fs_devices->seeding = seeding;
476 fs_devices->opened = 1;
414 fs_devices->latest_bdev = latest_bdev; 477 fs_devices->latest_bdev = latest_bdev;
415 fs_devices->latest_devid = latest_devid; 478 fs_devices->latest_devid = latest_devid;
416 fs_devices->latest_trans = latest_transid; 479 fs_devices->latest_trans = latest_transid;
480 fs_devices->total_rw_bytes = 0;
417out: 481out:
482 return ret;
483}
484
485int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
486 int flags, void *holder)
487{
488 int ret;
489
490 mutex_lock(&uuid_mutex);
491 if (fs_devices->opened) {
492 if (fs_devices->sprouted) {
493 ret = -EBUSY;
494 } else {
495 fs_devices->opened++;
496 ret = 0;
497 }
498 } else {
499 ret = __btrfs_open_devices(fs_devices, holder);
500 }
418 mutex_unlock(&uuid_mutex); 501 mutex_unlock(&uuid_mutex);
419 return ret; 502 return ret;
420} 503}
@@ -481,12 +564,12 @@ error:
481 */ 564 */
482static noinline int find_free_dev_extent(struct btrfs_trans_handle *trans, 565static noinline int find_free_dev_extent(struct btrfs_trans_handle *trans,
483 struct btrfs_device *device, 566 struct btrfs_device *device,
484 struct btrfs_path *path,
485 u64 num_bytes, u64 *start) 567 u64 num_bytes, u64 *start)
486{ 568{
487 struct btrfs_key key; 569 struct btrfs_key key;
488 struct btrfs_root *root = device->dev_root; 570 struct btrfs_root *root = device->dev_root;
489 struct btrfs_dev_extent *dev_extent = NULL; 571 struct btrfs_dev_extent *dev_extent = NULL;
572 struct btrfs_path *path;
490 u64 hole_size = 0; 573 u64 hole_size = 0;
491 u64 last_byte = 0; 574 u64 last_byte = 0;
492 u64 search_start = 0; 575 u64 search_start = 0;
@@ -496,8 +579,11 @@ static noinline int find_free_dev_extent(struct btrfs_trans_handle *trans,
496 int start_found; 579 int start_found;
497 struct extent_buffer *l; 580 struct extent_buffer *l;
498 581
499 start_found = 0; 582 path = btrfs_alloc_path();
583 if (!path)
584 return -ENOMEM;
500 path->reada = 2; 585 path->reada = 2;
586 start_found = 0;
501 587
502 /* FIXME use last free of some kind */ 588 /* FIXME use last free of some kind */
503 589
@@ -581,7 +667,6 @@ check_pending:
581 /* we have to make sure we didn't find an extent that has already 667 /* we have to make sure we didn't find an extent that has already
582 * been allocated by the map tree or the original allocation 668 * been allocated by the map tree or the original allocation
583 */ 669 */
584 btrfs_release_path(root, path);
585 BUG_ON(*start < search_start); 670 BUG_ON(*start < search_start);
586 671
587 if (*start + num_bytes > search_end) { 672 if (*start + num_bytes > search_end) {
@@ -589,10 +674,10 @@ check_pending:
589 goto error; 674 goto error;
590 } 675 }
591 /* check for pending inserts here */ 676 /* check for pending inserts here */
592 return 0; 677 ret = 0;
593 678
594error: 679error:
595 btrfs_release_path(root, path); 680 btrfs_free_path(path);
596 return ret; 681 return ret;
597} 682}
598 683
@@ -644,11 +729,10 @@ int btrfs_free_dev_extent(struct btrfs_trans_handle *trans,
644 return ret; 729 return ret;
645} 730}
646 731
647int noinline btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans, 732int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
648 struct btrfs_device *device, 733 struct btrfs_device *device,
649 u64 chunk_tree, u64 chunk_objectid, 734 u64 chunk_tree, u64 chunk_objectid,
650 u64 chunk_offset, 735 u64 chunk_offset, u64 start, u64 num_bytes)
651 u64 num_bytes, u64 *start)
652{ 736{
653 int ret; 737 int ret;
654 struct btrfs_path *path; 738 struct btrfs_path *path;
@@ -662,13 +746,8 @@ int noinline btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
662 if (!path) 746 if (!path)
663 return -ENOMEM; 747 return -ENOMEM;
664 748
665 ret = find_free_dev_extent(trans, device, path, num_bytes, start);
666 if (ret) {
667 goto err;
668 }
669
670 key.objectid = device->devid; 749 key.objectid = device->devid;
671 key.offset = *start; 750 key.offset = start;
672 key.type = BTRFS_DEV_EXTENT_KEY; 751 key.type = BTRFS_DEV_EXTENT_KEY;
673 ret = btrfs_insert_empty_item(trans, root, path, &key, 752 ret = btrfs_insert_empty_item(trans, root, path, &key,
674 sizeof(*extent)); 753 sizeof(*extent));
@@ -687,7 +766,6 @@ int noinline btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
687 766
688 btrfs_set_dev_extent_length(leaf, extent, num_bytes); 767 btrfs_set_dev_extent_length(leaf, extent, num_bytes);
689 btrfs_mark_buffer_dirty(leaf); 768 btrfs_mark_buffer_dirty(leaf);
690err:
691 btrfs_free_path(path); 769 btrfs_free_path(path);
692 return ret; 770 return ret;
693} 771}
@@ -735,12 +813,18 @@ error:
735 return ret; 813 return ret;
736} 814}
737 815
738static noinline int find_next_devid(struct btrfs_root *root, 816static noinline int find_next_devid(struct btrfs_root *root, u64 *objectid)
739 struct btrfs_path *path, u64 *objectid)
740{ 817{
741 int ret; 818 int ret;
742 struct btrfs_key key; 819 struct btrfs_key key;
743 struct btrfs_key found_key; 820 struct btrfs_key found_key;
821 struct btrfs_path *path;
822
823 root = root->fs_info->chunk_root;
824
825 path = btrfs_alloc_path();
826 if (!path)
827 return -ENOMEM;
744 828
745 key.objectid = BTRFS_DEV_ITEMS_OBJECTID; 829 key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
746 key.type = BTRFS_DEV_ITEM_KEY; 830 key.type = BTRFS_DEV_ITEM_KEY;
@@ -763,7 +847,7 @@ static noinline int find_next_devid(struct btrfs_root *root,
763 } 847 }
764 ret = 0; 848 ret = 0;
765error: 849error:
766 btrfs_release_path(root, path); 850 btrfs_free_path(path);
767 return ret; 851 return ret;
768} 852}
769 853
@@ -781,7 +865,6 @@ int btrfs_add_device(struct btrfs_trans_handle *trans,
781 struct extent_buffer *leaf; 865 struct extent_buffer *leaf;
782 struct btrfs_key key; 866 struct btrfs_key key;
783 unsigned long ptr; 867 unsigned long ptr;
784 u64 free_devid = 0;
785 868
786 root = root->fs_info->chunk_root; 869 root = root->fs_info->chunk_root;
787 870
@@ -789,13 +872,9 @@ int btrfs_add_device(struct btrfs_trans_handle *trans,
789 if (!path) 872 if (!path)
790 return -ENOMEM; 873 return -ENOMEM;
791 874
792 ret = find_next_devid(root, path, &free_devid);
793 if (ret)
794 goto out;
795
796 key.objectid = BTRFS_DEV_ITEMS_OBJECTID; 875 key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
797 key.type = BTRFS_DEV_ITEM_KEY; 876 key.type = BTRFS_DEV_ITEM_KEY;
798 key.offset = free_devid; 877 key.offset = device->devid;
799 878
800 ret = btrfs_insert_empty_item(trans, root, path, &key, 879 ret = btrfs_insert_empty_item(trans, root, path, &key,
801 sizeof(*dev_item)); 880 sizeof(*dev_item));
@@ -805,8 +884,8 @@ int btrfs_add_device(struct btrfs_trans_handle *trans,
805 leaf = path->nodes[0]; 884 leaf = path->nodes[0];
806 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); 885 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);
807 886
808 device->devid = free_devid;
809 btrfs_set_device_id(leaf, dev_item, device->devid); 887 btrfs_set_device_id(leaf, dev_item, device->devid);
888 btrfs_set_device_generation(leaf, dev_item, 0);
810 btrfs_set_device_type(leaf, dev_item, device->type); 889 btrfs_set_device_type(leaf, dev_item, device->type);
811 btrfs_set_device_io_align(leaf, dev_item, device->io_align); 890 btrfs_set_device_io_align(leaf, dev_item, device->io_align);
812 btrfs_set_device_io_width(leaf, dev_item, device->io_width); 891 btrfs_set_device_io_width(leaf, dev_item, device->io_width);
@@ -819,9 +898,11 @@ int btrfs_add_device(struct btrfs_trans_handle *trans,
819 898
820 ptr = (unsigned long)btrfs_device_uuid(dev_item); 899 ptr = (unsigned long)btrfs_device_uuid(dev_item);
821 write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); 900 write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
901 ptr = (unsigned long)btrfs_device_fsid(dev_item);
902 write_extent_buffer(leaf, root->fs_info->fsid, ptr, BTRFS_UUID_SIZE);
822 btrfs_mark_buffer_dirty(leaf); 903 btrfs_mark_buffer_dirty(leaf);
823 ret = 0;
824 904
905 ret = 0;
825out: 906out:
826 btrfs_free_path(path); 907 btrfs_free_path(path);
827 return ret; 908 return ret;
@@ -832,11 +913,7 @@ static int btrfs_rm_dev_item(struct btrfs_root *root,
832{ 913{
833 int ret; 914 int ret;
834 struct btrfs_path *path; 915 struct btrfs_path *path;
835 struct block_device *bdev = device->bdev;
836 struct btrfs_device *next_dev;
837 struct btrfs_key key; 916 struct btrfs_key key;
838 u64 total_bytes;
839 struct btrfs_fs_devices *fs_devices;
840 struct btrfs_trans_handle *trans; 917 struct btrfs_trans_handle *trans;
841 918
842 root = root->fs_info->chunk_root; 919 root = root->fs_info->chunk_root;
@@ -863,25 +940,6 @@ static int btrfs_rm_dev_item(struct btrfs_root *root,
863 ret = btrfs_del_item(trans, root, path); 940 ret = btrfs_del_item(trans, root, path);
864 if (ret) 941 if (ret)
865 goto out; 942 goto out;
866
867 /*
868 * at this point, the device is zero sized. We want to
869 * remove it from the devices list and zero out the old super
870 */
871 list_del_init(&device->dev_list);
872 list_del_init(&device->dev_alloc_list);
873 fs_devices = root->fs_info->fs_devices;
874
875 next_dev = list_entry(fs_devices->devices.next, struct btrfs_device,
876 dev_list);
877 if (bdev == root->fs_info->sb->s_bdev)
878 root->fs_info->sb->s_bdev = next_dev->bdev;
879 if (bdev == fs_devices->latest_bdev)
880 fs_devices->latest_bdev = next_dev->bdev;
881
882 total_bytes = btrfs_super_num_devices(&root->fs_info->super_copy);
883 btrfs_set_super_num_devices(&root->fs_info->super_copy,
884 total_bytes - 1);
885out: 943out:
886 btrfs_free_path(path); 944 btrfs_free_path(path);
887 unlock_chunks(root); 945 unlock_chunks(root);
@@ -892,11 +950,14 @@ out:
892int btrfs_rm_device(struct btrfs_root *root, char *device_path) 950int btrfs_rm_device(struct btrfs_root *root, char *device_path)
893{ 951{
894 struct btrfs_device *device; 952 struct btrfs_device *device;
953 struct btrfs_device *next_device;
895 struct block_device *bdev; 954 struct block_device *bdev;
896 struct buffer_head *bh = NULL; 955 struct buffer_head *bh = NULL;
897 struct btrfs_super_block *disk_super; 956 struct btrfs_super_block *disk_super;
898 u64 all_avail; 957 u64 all_avail;
899 u64 devid; 958 u64 devid;
959 u64 num_devices;
960 u8 *dev_uuid;
900 int ret = 0; 961 int ret = 0;
901 962
902 mutex_lock(&uuid_mutex); 963 mutex_lock(&uuid_mutex);
@@ -907,14 +968,14 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
907 root->fs_info->avail_metadata_alloc_bits; 968 root->fs_info->avail_metadata_alloc_bits;
908 969
909 if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) && 970 if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) &&
910 btrfs_super_num_devices(&root->fs_info->super_copy) <= 4) { 971 root->fs_info->fs_devices->rw_devices <= 4) {
911 printk("btrfs: unable to go below four devices on raid10\n"); 972 printk("btrfs: unable to go below four devices on raid10\n");
912 ret = -EINVAL; 973 ret = -EINVAL;
913 goto out; 974 goto out;
914 } 975 }
915 976
916 if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) && 977 if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) &&
917 btrfs_super_num_devices(&root->fs_info->super_copy) <= 2) { 978 root->fs_info->fs_devices->rw_devices <= 2) {
918 printk("btrfs: unable to go below two devices on raid1\n"); 979 printk("btrfs: unable to go below two devices on raid1\n");
919 ret = -EINVAL; 980 ret = -EINVAL;
920 goto out; 981 goto out;
@@ -941,15 +1002,15 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
941 printk("btrfs: no missing devices found to remove\n"); 1002 printk("btrfs: no missing devices found to remove\n");
942 goto out; 1003 goto out;
943 } 1004 }
944
945 } else { 1005 } else {
946 bdev = open_bdev_excl(device_path, 0, 1006 bdev = open_bdev_excl(device_path, MS_RDONLY,
947 root->fs_info->bdev_holder); 1007 root->fs_info->bdev_holder);
948 if (IS_ERR(bdev)) { 1008 if (IS_ERR(bdev)) {
949 ret = PTR_ERR(bdev); 1009 ret = PTR_ERR(bdev);
950 goto out; 1010 goto out;
951 } 1011 }
952 1012
1013 set_blocksize(bdev, 4096);
953 bh = __bread(bdev, BTRFS_SUPER_INFO_OFFSET / 4096, 4096); 1014 bh = __bread(bdev, BTRFS_SUPER_INFO_OFFSET / 4096, 4096);
954 if (!bh) { 1015 if (!bh) {
955 ret = -EIO; 1016 ret = -EIO;
@@ -957,45 +1018,97 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
957 } 1018 }
958 disk_super = (struct btrfs_super_block *)bh->b_data; 1019 disk_super = (struct btrfs_super_block *)bh->b_data;
959 if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC, 1020 if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
960 sizeof(disk_super->magic))) { 1021 sizeof(disk_super->magic))) {
961 ret = -ENOENT;
962 goto error_brelse;
963 }
964 if (memcmp(disk_super->fsid, root->fs_info->fsid,
965 BTRFS_FSID_SIZE)) {
966 ret = -ENOENT; 1022 ret = -ENOENT;
967 goto error_brelse; 1023 goto error_brelse;
968 } 1024 }
969 devid = le64_to_cpu(disk_super->dev_item.devid); 1025 devid = le64_to_cpu(disk_super->dev_item.devid);
970 device = btrfs_find_device(root, devid, NULL); 1026 dev_uuid = disk_super->dev_item.uuid;
1027 device = btrfs_find_device(root, devid, dev_uuid,
1028 disk_super->fsid);
971 if (!device) { 1029 if (!device) {
972 ret = -ENOENT; 1030 ret = -ENOENT;
973 goto error_brelse; 1031 goto error_brelse;
974 } 1032 }
1033 }
975 1034
1035 if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) {
1036 printk("btrfs: unable to remove the only writeable device\n");
1037 ret = -EINVAL;
1038 goto error_brelse;
1039 }
1040
1041 if (device->writeable) {
1042 list_del_init(&device->dev_alloc_list);
1043 root->fs_info->fs_devices->rw_devices--;
976 } 1044 }
977 root->fs_info->fs_devices->num_devices--;
978 root->fs_info->fs_devices->open_devices--;
979 1045
980 ret = btrfs_shrink_device(device, 0); 1046 ret = btrfs_shrink_device(device, 0);
981 if (ret) 1047 if (ret)
982 goto error_brelse; 1048 goto error_brelse;
983 1049
984
985 ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device); 1050 ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device);
986 if (ret) 1051 if (ret)
987 goto error_brelse; 1052 goto error_brelse;
988 1053
989 if (bh) { 1054 device->in_fs_metadata = 0;
1055 if (device->fs_devices == root->fs_info->fs_devices) {
1056 list_del_init(&device->dev_list);
1057 root->fs_info->fs_devices->num_devices--;
1058 if (device->bdev)
1059 device->fs_devices->open_devices--;
1060 }
1061
1062 next_device = list_entry(root->fs_info->fs_devices->devices.next,
1063 struct btrfs_device, dev_list);
1064 if (device->bdev == root->fs_info->sb->s_bdev)
1065 root->fs_info->sb->s_bdev = next_device->bdev;
1066 if (device->bdev == root->fs_info->fs_devices->latest_bdev)
1067 root->fs_info->fs_devices->latest_bdev = next_device->bdev;
1068
1069 num_devices = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
1070 btrfs_set_super_num_devices(&root->fs_info->super_copy, num_devices);
1071
1072 if (device->fs_devices != root->fs_info->fs_devices) {
1073 BUG_ON(device->writeable);
1074 brelse(bh);
1075 if (bdev)
1076 close_bdev_excl(bdev);
1077
1078 if (device->bdev) {
1079 close_bdev_excl(device->bdev);
1080 device->bdev = NULL;
1081 device->fs_devices->open_devices--;
1082 }
1083 if (device->fs_devices->open_devices == 0) {
1084 struct btrfs_fs_devices *fs_devices;
1085 fs_devices = root->fs_info->fs_devices;
1086 while (fs_devices) {
1087 if (fs_devices->seed == device->fs_devices)
1088 break;
1089 fs_devices = fs_devices->seed;
1090 }
1091 fs_devices->seed = device->fs_devices->seed;
1092 device->fs_devices->seed = NULL;
1093 __btrfs_close_devices(device->fs_devices);
1094 }
1095 ret = 0;
1096 goto out;
1097 }
1098
1099 /*
1100 * at this point, the device is zero sized. We want to
1101 * remove it from the devices list and zero out the old super
1102 */
1103 if (device->writeable) {
990 /* make sure this device isn't detected as part of 1104 /* make sure this device isn't detected as part of
991 * the FS anymore 1105 * the FS anymore
992 */ 1106 */
993 memset(&disk_super->magic, 0, sizeof(disk_super->magic)); 1107 memset(&disk_super->magic, 0, sizeof(disk_super->magic));
994 set_buffer_dirty(bh); 1108 set_buffer_dirty(bh);
995 sync_dirty_buffer(bh); 1109 sync_dirty_buffer(bh);
996
997 brelse(bh);
998 } 1110 }
1111 brelse(bh);
999 1112
1000 if (device->bdev) { 1113 if (device->bdev) {
1001 /* one close for the device struct or super_block */ 1114 /* one close for the device struct or super_block */
@@ -1021,6 +1134,129 @@ out:
1021 return ret; 1134 return ret;
1022} 1135}
1023 1136
1137/*
1138 * does all the dirty work required for changing file system's UUID.
1139 */
1140static int btrfs_prepare_sprout(struct btrfs_trans_handle *trans,
1141 struct btrfs_root *root)
1142{
1143 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
1144 struct btrfs_fs_devices *old_devices;
1145 struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
1146 struct btrfs_device *device;
1147 u64 super_flags;
1148
1149 BUG_ON(!mutex_is_locked(&uuid_mutex));
1150 if (!fs_devices->seeding || fs_devices->opened != 1)
1151 return -EINVAL;
1152
1153 old_devices = kzalloc(sizeof(*fs_devices), GFP_NOFS);
1154 if (!old_devices)
1155 return -ENOMEM;
1156
1157 memcpy(old_devices, fs_devices, sizeof(*old_devices));
1158 old_devices->opened = 1;
1159 old_devices->sprouted = 1;
1160 INIT_LIST_HEAD(&old_devices->devices);
1161 INIT_LIST_HEAD(&old_devices->alloc_list);
1162 list_splice_init(&fs_devices->devices, &old_devices->devices);
1163 list_splice_init(&fs_devices->alloc_list, &old_devices->alloc_list);
1164 list_for_each_entry(device, &old_devices->devices, dev_list) {
1165 device->fs_devices = old_devices;
1166 }
1167 list_add(&old_devices->list, &fs_uuids);
1168
1169 fs_devices->seeding = 0;
1170 fs_devices->num_devices = 0;
1171 fs_devices->open_devices = 0;
1172 fs_devices->seed = old_devices;
1173
1174 generate_random_uuid(fs_devices->fsid);
1175 memcpy(root->fs_info->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
1176 memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
1177 super_flags = btrfs_super_flags(disk_super) &
1178 ~BTRFS_SUPER_FLAG_SEEDING;
1179 btrfs_set_super_flags(disk_super, super_flags);
1180
1181 return 0;
1182}
1183
1184/*
1185 * strore the expected generation for seed devices in device items.
1186 */
1187static int btrfs_finish_sprout(struct btrfs_trans_handle *trans,
1188 struct btrfs_root *root)
1189{
1190 struct btrfs_path *path;
1191 struct extent_buffer *leaf;
1192 struct btrfs_dev_item *dev_item;
1193 struct btrfs_device *device;
1194 struct btrfs_key key;
1195 u8 fs_uuid[BTRFS_UUID_SIZE];
1196 u8 dev_uuid[BTRFS_UUID_SIZE];
1197 u64 devid;
1198 int ret;
1199
1200 path = btrfs_alloc_path();
1201 if (!path)
1202 return -ENOMEM;
1203
1204 root = root->fs_info->chunk_root;
1205 key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1206 key.offset = 0;
1207 key.type = BTRFS_DEV_ITEM_KEY;
1208
1209 while (1) {
1210 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
1211 if (ret < 0)
1212 goto error;
1213
1214 leaf = path->nodes[0];
1215next_slot:
1216 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
1217 ret = btrfs_next_leaf(root, path);
1218 if (ret > 0)
1219 break;
1220 if (ret < 0)
1221 goto error;
1222 leaf = path->nodes[0];
1223 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1224 btrfs_release_path(root, path);
1225 continue;
1226 }
1227
1228 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1229 if (key.objectid != BTRFS_DEV_ITEMS_OBJECTID ||
1230 key.type != BTRFS_DEV_ITEM_KEY)
1231 break;
1232
1233 dev_item = btrfs_item_ptr(leaf, path->slots[0],
1234 struct btrfs_dev_item);
1235 devid = btrfs_device_id(leaf, dev_item);
1236 read_extent_buffer(leaf, dev_uuid,
1237 (unsigned long)btrfs_device_uuid(dev_item),
1238 BTRFS_UUID_SIZE);
1239 read_extent_buffer(leaf, fs_uuid,
1240 (unsigned long)btrfs_device_fsid(dev_item),
1241 BTRFS_UUID_SIZE);
1242 device = btrfs_find_device(root, devid, dev_uuid, fs_uuid);
1243 BUG_ON(!device);
1244
1245 if (device->fs_devices->seeding) {
1246 btrfs_set_device_generation(leaf, dev_item,
1247 device->generation);
1248 btrfs_mark_buffer_dirty(leaf);
1249 }
1250
1251 path->slots[0]++;
1252 goto next_slot;
1253 }
1254 ret = 0;
1255error:
1256 btrfs_free_path(path);
1257 return ret;
1258}
1259
1024int btrfs_init_new_device(struct btrfs_root *root, char *device_path) 1260int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
1025{ 1261{
1026 struct btrfs_trans_handle *trans; 1262 struct btrfs_trans_handle *trans;
@@ -1028,26 +1264,34 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
1028 struct block_device *bdev; 1264 struct block_device *bdev;
1029 struct list_head *cur; 1265 struct list_head *cur;
1030 struct list_head *devices; 1266 struct list_head *devices;
1267 struct super_block *sb = root->fs_info->sb;
1031 u64 total_bytes; 1268 u64 total_bytes;
1269 int seeding_dev = 0;
1032 int ret = 0; 1270 int ret = 0;
1033 1271
1272 if ((sb->s_flags & MS_RDONLY) && !root->fs_info->fs_devices->seeding)
1273 return -EINVAL;
1034 1274
1035 bdev = open_bdev_excl(device_path, 0, root->fs_info->bdev_holder); 1275 bdev = open_bdev_excl(device_path, 0, root->fs_info->bdev_holder);
1036 if (!bdev) { 1276 if (!bdev) {
1037 return -EIO; 1277 return -EIO;
1038 } 1278 }
1039 1279
1280 if (root->fs_info->fs_devices->seeding) {
1281 seeding_dev = 1;
1282 down_write(&sb->s_umount);
1283 mutex_lock(&uuid_mutex);
1284 }
1285
1040 filemap_write_and_wait(bdev->bd_inode->i_mapping); 1286 filemap_write_and_wait(bdev->bd_inode->i_mapping);
1041 mutex_lock(&root->fs_info->volume_mutex); 1287 mutex_lock(&root->fs_info->volume_mutex);
1042 1288
1043 trans = btrfs_start_transaction(root, 1);
1044 lock_chunks(root);
1045 devices = &root->fs_info->fs_devices->devices; 1289 devices = &root->fs_info->fs_devices->devices;
1046 list_for_each(cur, devices) { 1290 list_for_each(cur, devices) {
1047 device = list_entry(cur, struct btrfs_device, dev_list); 1291 device = list_entry(cur, struct btrfs_device, dev_list);
1048 if (device->bdev == bdev) { 1292 if (device->bdev == bdev) {
1049 ret = -EEXIST; 1293 ret = -EEXIST;
1050 goto out; 1294 goto error;
1051 } 1295 }
1052 } 1296 }
1053 1297
@@ -1055,18 +1299,31 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
1055 if (!device) { 1299 if (!device) {
1056 /* we can safely leave the fs_devices entry around */ 1300 /* we can safely leave the fs_devices entry around */
1057 ret = -ENOMEM; 1301 ret = -ENOMEM;
1058 goto out_close_bdev; 1302 goto error;
1059 } 1303 }
1060 1304
1061 device->barriers = 1;
1062 device->work.func = pending_bios_fn;
1063 generate_random_uuid(device->uuid);
1064 spin_lock_init(&device->io_lock);
1065 device->name = kstrdup(device_path, GFP_NOFS); 1305 device->name = kstrdup(device_path, GFP_NOFS);
1066 if (!device->name) { 1306 if (!device->name) {
1067 kfree(device); 1307 kfree(device);
1068 goto out_close_bdev; 1308 ret = -ENOMEM;
1309 goto error;
1069 } 1310 }
1311
1312 ret = find_next_devid(root, &device->devid);
1313 if (ret) {
1314 kfree(device);
1315 goto error;
1316 }
1317
1318 trans = btrfs_start_transaction(root, 1);
1319 lock_chunks(root);
1320
1321 device->barriers = 1;
1322 device->writeable = 1;
1323 device->work.func = pending_bios_fn;
1324 generate_random_uuid(device->uuid);
1325 spin_lock_init(&device->io_lock);
1326 device->generation = trans->transid;
1070 device->io_width = root->sectorsize; 1327 device->io_width = root->sectorsize;
1071 device->io_align = root->sectorsize; 1328 device->io_align = root->sectorsize;
1072 device->sector_size = root->sectorsize; 1329 device->sector_size = root->sectorsize;
@@ -1074,12 +1331,22 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
1074 device->dev_root = root->fs_info->dev_root; 1331 device->dev_root = root->fs_info->dev_root;
1075 device->bdev = bdev; 1332 device->bdev = bdev;
1076 device->in_fs_metadata = 1; 1333 device->in_fs_metadata = 1;
1334 set_blocksize(device->bdev, 4096);
1077 1335
1078 ret = btrfs_add_device(trans, root, device); 1336 if (seeding_dev) {
1079 if (ret) 1337 sb->s_flags &= ~MS_RDONLY;
1080 goto out_close_bdev; 1338 ret = btrfs_prepare_sprout(trans, root);
1339 BUG_ON(ret);
1340 }
1081 1341
1082 set_blocksize(device->bdev, 4096); 1342 device->fs_devices = root->fs_info->fs_devices;
1343 list_add(&device->dev_list, &root->fs_info->fs_devices->devices);
1344 list_add(&device->dev_alloc_list,
1345 &root->fs_info->fs_devices->alloc_list);
1346 root->fs_info->fs_devices->num_devices++;
1347 root->fs_info->fs_devices->open_devices++;
1348 root->fs_info->fs_devices->rw_devices++;
1349 root->fs_info->fs_devices->total_rw_bytes += device->total_bytes;
1083 1350
1084 total_bytes = btrfs_super_total_bytes(&root->fs_info->super_copy); 1351 total_bytes = btrfs_super_total_bytes(&root->fs_info->super_copy);
1085 btrfs_set_super_total_bytes(&root->fs_info->super_copy, 1352 btrfs_set_super_total_bytes(&root->fs_info->super_copy,
@@ -1089,20 +1356,34 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
1089 btrfs_set_super_num_devices(&root->fs_info->super_copy, 1356 btrfs_set_super_num_devices(&root->fs_info->super_copy,
1090 total_bytes + 1); 1357 total_bytes + 1);
1091 1358
1092 list_add(&device->dev_list, &root->fs_info->fs_devices->devices); 1359 if (seeding_dev) {
1093 list_add(&device->dev_alloc_list, 1360 ret = init_first_rw_device(trans, root, device);
1094 &root->fs_info->fs_devices->alloc_list); 1361 BUG_ON(ret);
1095 root->fs_info->fs_devices->num_devices++; 1362 ret = btrfs_finish_sprout(trans, root);
1096 root->fs_info->fs_devices->open_devices++; 1363 BUG_ON(ret);
1097out: 1364 } else {
1365 ret = btrfs_add_device(trans, root, device);
1366 }
1367
1098 unlock_chunks(root); 1368 unlock_chunks(root);
1099 btrfs_end_transaction(trans, root); 1369 btrfs_commit_transaction(trans, root);
1100 mutex_unlock(&root->fs_info->volume_mutex);
1101 1370
1102 return ret; 1371 if (seeding_dev) {
1372 mutex_unlock(&uuid_mutex);
1373 up_write(&sb->s_umount);
1103 1374
1104out_close_bdev: 1375 ret = btrfs_relocate_sys_chunks(root);
1376 BUG_ON(ret);
1377 }
1378out:
1379 mutex_unlock(&root->fs_info->volume_mutex);
1380 return ret;
1381error:
1105 close_bdev_excl(bdev); 1382 close_bdev_excl(bdev);
1383 if (seeding_dev) {
1384 mutex_unlock(&uuid_mutex);
1385 up_write(&sb->s_umount);
1386 }
1106 goto out; 1387 goto out;
1107} 1388}
1108 1389
@@ -1160,7 +1441,15 @@ static int __btrfs_grow_device(struct btrfs_trans_handle *trans,
1160 u64 old_total = btrfs_super_total_bytes(super_copy); 1441 u64 old_total = btrfs_super_total_bytes(super_copy);
1161 u64 diff = new_size - device->total_bytes; 1442 u64 diff = new_size - device->total_bytes;
1162 1443
1444 if (!device->writeable)
1445 return -EACCES;
1446 if (new_size <= device->total_bytes)
1447 return -EINVAL;
1448
1163 btrfs_set_super_total_bytes(super_copy, old_total + diff); 1449 btrfs_set_super_total_bytes(super_copy, old_total + diff);
1450 device->fs_devices->total_rw_bytes += diff;
1451
1452 device->total_bytes = new_size;
1164 return btrfs_update_device(trans, device); 1453 return btrfs_update_device(trans, device);
1165} 1454}
1166 1455
@@ -1248,7 +1537,6 @@ int btrfs_del_sys_chunk(struct btrfs_root *root, u64 chunk_objectid, u64
1248 return ret; 1537 return ret;
1249} 1538}
1250 1539
1251
1252int btrfs_relocate_chunk(struct btrfs_root *root, 1540int btrfs_relocate_chunk(struct btrfs_root *root,
1253 u64 chunk_tree, u64 chunk_objectid, 1541 u64 chunk_tree, u64 chunk_objectid,
1254 u64 chunk_offset) 1542 u64 chunk_offset)
@@ -1328,6 +1616,64 @@ int btrfs_relocate_chunk(struct btrfs_root *root,
1328 return 0; 1616 return 0;
1329} 1617}
1330 1618
1619static int btrfs_relocate_sys_chunks(struct btrfs_root *root)
1620{
1621 struct btrfs_root *chunk_root = root->fs_info->chunk_root;
1622 struct btrfs_path *path;
1623 struct extent_buffer *leaf;
1624 struct btrfs_chunk *chunk;
1625 struct btrfs_key key;
1626 struct btrfs_key found_key;
1627 u64 chunk_tree = chunk_root->root_key.objectid;
1628 u64 chunk_type;
1629 int ret;
1630
1631 path = btrfs_alloc_path();
1632 if (!path)
1633 return -ENOMEM;
1634
1635 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
1636 key.offset = (u64)-1;
1637 key.type = BTRFS_CHUNK_ITEM_KEY;
1638
1639 while (1) {
1640 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
1641 if (ret < 0)
1642 goto error;
1643 BUG_ON(ret == 0);
1644
1645 ret = btrfs_previous_item(chunk_root, path, key.objectid,
1646 key.type);
1647 if (ret < 0)
1648 goto error;
1649 if (ret > 0)
1650 break;
1651
1652 leaf = path->nodes[0];
1653 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1654
1655 chunk = btrfs_item_ptr(leaf, path->slots[0],
1656 struct btrfs_chunk);
1657 chunk_type = btrfs_chunk_type(leaf, chunk);
1658 btrfs_release_path(chunk_root, path);
1659
1660 if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) {
1661 ret = btrfs_relocate_chunk(chunk_root, chunk_tree,
1662 found_key.objectid,
1663 found_key.offset);
1664 BUG_ON(ret);
1665 }
1666
1667 if (found_key.offset == 0)
1668 break;
1669 key.offset = found_key.offset - 1;
1670 }
1671 ret = 0;
1672error:
1673 btrfs_free_path(path);
1674 return ret;
1675}
1676
1331static u64 div_factor(u64 num, int factor) 1677static u64 div_factor(u64 num, int factor)
1332{ 1678{
1333 if (factor == 10) 1679 if (factor == 10)
@@ -1337,7 +1683,6 @@ static u64 div_factor(u64 num, int factor)
1337 return num; 1683 return num;
1338} 1684}
1339 1685
1340
1341int btrfs_balance(struct btrfs_root *dev_root) 1686int btrfs_balance(struct btrfs_root *dev_root)
1342{ 1687{
1343 int ret; 1688 int ret;
@@ -1353,6 +1698,8 @@ int btrfs_balance(struct btrfs_root *dev_root)
1353 struct btrfs_trans_handle *trans; 1698 struct btrfs_trans_handle *trans;
1354 struct btrfs_key found_key; 1699 struct btrfs_key found_key;
1355 1700
1701 if (dev_root->fs_info->sb->s_flags & MS_RDONLY)
1702 return -EROFS;
1356 1703
1357 mutex_lock(&dev_root->fs_info->volume_mutex); 1704 mutex_lock(&dev_root->fs_info->volume_mutex);
1358 dev_root = dev_root->fs_info->dev_root; 1705 dev_root = dev_root->fs_info->dev_root;
@@ -1363,7 +1710,8 @@ int btrfs_balance(struct btrfs_root *dev_root)
1363 old_size = device->total_bytes; 1710 old_size = device->total_bytes;
1364 size_to_free = div_factor(old_size, 1); 1711 size_to_free = div_factor(old_size, 1);
1365 size_to_free = min(size_to_free, (u64)1 * 1024 * 1024); 1712 size_to_free = min(size_to_free, (u64)1 * 1024 * 1024);
1366 if (device->total_bytes - device->bytes_used > size_to_free) 1713 if (!device->writeable ||
1714 device->total_bytes - device->bytes_used > size_to_free)
1367 continue; 1715 continue;
1368 1716
1369 ret = btrfs_shrink_device(device, old_size - size_to_free); 1717 ret = btrfs_shrink_device(device, old_size - size_to_free);
@@ -1453,6 +1801,8 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
1453 u64 old_total = btrfs_super_total_bytes(super_copy); 1801 u64 old_total = btrfs_super_total_bytes(super_copy);
1454 u64 diff = device->total_bytes - new_size; 1802 u64 diff = device->total_bytes - new_size;
1455 1803
1804 if (new_size >= device->total_bytes)
1805 return -EINVAL;
1456 1806
1457 path = btrfs_alloc_path(); 1807 path = btrfs_alloc_path();
1458 if (!path) 1808 if (!path)
@@ -1469,6 +1819,8 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
1469 lock_chunks(root); 1819 lock_chunks(root);
1470 1820
1471 device->total_bytes = new_size; 1821 device->total_bytes = new_size;
1822 if (device->writeable)
1823 device->fs_devices->total_rw_bytes -= diff;
1472 ret = btrfs_update_device(trans, device); 1824 ret = btrfs_update_device(trans, device);
1473 if (ret) { 1825 if (ret) {
1474 unlock_chunks(root); 1826 unlock_chunks(root);
@@ -1561,32 +1913,27 @@ static u64 noinline chunk_bytes_by_type(u64 type, u64 calc_size,
1561 return calc_size * num_stripes; 1913 return calc_size * num_stripes;
1562} 1914}
1563 1915
1564 1916static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
1565int btrfs_alloc_chunk(struct btrfs_trans_handle *trans, 1917 struct btrfs_root *extent_root,
1566 struct btrfs_root *extent_root, u64 *start, 1918 struct map_lookup **map_ret,
1567 u64 *num_bytes, u64 type) 1919 u64 *num_bytes, u64 *stripe_size,
1920 u64 start, u64 type)
1568{ 1921{
1569 u64 dev_offset;
1570 struct btrfs_fs_info *info = extent_root->fs_info; 1922 struct btrfs_fs_info *info = extent_root->fs_info;
1571 struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
1572 struct btrfs_path *path;
1573 struct btrfs_stripe *stripes;
1574 struct btrfs_device *device = NULL; 1923 struct btrfs_device *device = NULL;
1575 struct btrfs_chunk *chunk; 1924 struct btrfs_fs_devices *fs_devices = info->fs_devices;
1576 struct list_head private_devs;
1577 struct list_head *dev_list;
1578 struct list_head *cur; 1925 struct list_head *cur;
1926 struct map_lookup *map = NULL;
1579 struct extent_map_tree *em_tree; 1927 struct extent_map_tree *em_tree;
1580 struct map_lookup *map;
1581 struct extent_map *em; 1928 struct extent_map *em;
1929 struct list_head private_devs;
1582 int min_stripe_size = 1 * 1024 * 1024; 1930 int min_stripe_size = 1 * 1024 * 1024;
1583 u64 physical;
1584 u64 calc_size = 1024 * 1024 * 1024; 1931 u64 calc_size = 1024 * 1024 * 1024;
1585 u64 max_chunk_size = calc_size; 1932 u64 max_chunk_size = calc_size;
1586 u64 min_free; 1933 u64 min_free;
1587 u64 avail; 1934 u64 avail;
1588 u64 max_avail = 0; 1935 u64 max_avail = 0;
1589 u64 percent_max; 1936 u64 dev_offset;
1590 int num_stripes = 1; 1937 int num_stripes = 1;
1591 int min_stripes = 1; 1938 int min_stripes = 1;
1592 int sub_stripes = 0; 1939 int sub_stripes = 0;
@@ -1594,19 +1941,17 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
1594 int ret; 1941 int ret;
1595 int index; 1942 int index;
1596 int stripe_len = 64 * 1024; 1943 int stripe_len = 64 * 1024;
1597 struct btrfs_key key;
1598 1944
1599 if ((type & BTRFS_BLOCK_GROUP_RAID1) && 1945 if ((type & BTRFS_BLOCK_GROUP_RAID1) &&
1600 (type & BTRFS_BLOCK_GROUP_DUP)) { 1946 (type & BTRFS_BLOCK_GROUP_DUP)) {
1601 WARN_ON(1); 1947 WARN_ON(1);
1602 type &= ~BTRFS_BLOCK_GROUP_DUP; 1948 type &= ~BTRFS_BLOCK_GROUP_DUP;
1603 } 1949 }
1604 dev_list = &extent_root->fs_info->fs_devices->alloc_list; 1950 if (list_empty(&fs_devices->alloc_list))
1605 if (list_empty(dev_list))
1606 return -ENOSPC; 1951 return -ENOSPC;
1607 1952
1608 if (type & (BTRFS_BLOCK_GROUP_RAID0)) { 1953 if (type & (BTRFS_BLOCK_GROUP_RAID0)) {
1609 num_stripes = extent_root->fs_info->fs_devices->open_devices; 1954 num_stripes = fs_devices->rw_devices;
1610 min_stripes = 2; 1955 min_stripes = 2;
1611 } 1956 }
1612 if (type & (BTRFS_BLOCK_GROUP_DUP)) { 1957 if (type & (BTRFS_BLOCK_GROUP_DUP)) {
@@ -1614,14 +1959,13 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
1614 min_stripes = 2; 1959 min_stripes = 2;
1615 } 1960 }
1616 if (type & (BTRFS_BLOCK_GROUP_RAID1)) { 1961 if (type & (BTRFS_BLOCK_GROUP_RAID1)) {
1617 num_stripes = min_t(u64, 2, 1962 num_stripes = min_t(u64, 2, fs_devices->rw_devices);
1618 extent_root->fs_info->fs_devices->open_devices);
1619 if (num_stripes < 2) 1963 if (num_stripes < 2)
1620 return -ENOSPC; 1964 return -ENOSPC;
1621 min_stripes = 2; 1965 min_stripes = 2;
1622 } 1966 }
1623 if (type & (BTRFS_BLOCK_GROUP_RAID10)) { 1967 if (type & (BTRFS_BLOCK_GROUP_RAID10)) {
1624 num_stripes = extent_root->fs_info->fs_devices->open_devices; 1968 num_stripes = fs_devices->rw_devices;
1625 if (num_stripes < 4) 1969 if (num_stripes < 4)
1626 return -ENOSPC; 1970 return -ENOSPC;
1627 num_stripes &= ~(u32)1; 1971 num_stripes &= ~(u32)1;
@@ -1641,15 +1985,19 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
1641 min_stripe_size = 1 * 1024 * 1024; 1985 min_stripe_size = 1 * 1024 * 1024;
1642 } 1986 }
1643 1987
1644 path = btrfs_alloc_path(); 1988 /* we don't want a chunk larger than 10% of writeable space */
1645 if (!path) 1989 max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),
1646 return -ENOMEM; 1990 max_chunk_size);
1647
1648 /* we don't want a chunk larger than 10% of the FS */
1649 percent_max = div_factor(btrfs_super_total_bytes(&info->super_copy), 1);
1650 max_chunk_size = min(percent_max, max_chunk_size);
1651 1991
1652again: 1992again:
1993 if (!map || map->num_stripes != num_stripes) {
1994 kfree(map);
1995 map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
1996 if (!map)
1997 return -ENOMEM;
1998 map->num_stripes = num_stripes;
1999 }
2000
1653 if (calc_size * num_stripes > max_chunk_size) { 2001 if (calc_size * num_stripes > max_chunk_size) {
1654 calc_size = max_chunk_size; 2002 calc_size = max_chunk_size;
1655 do_div(calc_size, num_stripes); 2003 do_div(calc_size, num_stripes);
@@ -1662,8 +2010,7 @@ again:
1662 do_div(calc_size, stripe_len); 2010 do_div(calc_size, stripe_len);
1663 calc_size *= stripe_len; 2011 calc_size *= stripe_len;
1664 2012
1665 INIT_LIST_HEAD(&private_devs); 2013 cur = fs_devices->alloc_list.next;
1666 cur = dev_list->next;
1667 index = 0; 2014 index = 0;
1668 2015
1669 if (type & BTRFS_BLOCK_GROUP_DUP) 2016 if (type & BTRFS_BLOCK_GROUP_DUP)
@@ -1679,10 +2026,10 @@ again:
1679 if (!looped) 2026 if (!looped)
1680 min_free += 1024 * 1024; 2027 min_free += 1024 * 1024;
1681 2028
1682 /* build a private list of devices we will allocate from */ 2029 INIT_LIST_HEAD(&private_devs);
1683 while(index < num_stripes) { 2030 while(index < num_stripes) {
1684 device = list_entry(cur, struct btrfs_device, dev_alloc_list); 2031 device = list_entry(cur, struct btrfs_device, dev_alloc_list);
1685 2032 BUG_ON(!device->writeable);
1686 if (device->total_bytes > device->bytes_used) 2033 if (device->total_bytes > device->bytes_used)
1687 avail = device->total_bytes - device->bytes_used; 2034 avail = device->total_bytes - device->bytes_used;
1688 else 2035 else
@@ -1690,24 +2037,28 @@ again:
1690 cur = cur->next; 2037 cur = cur->next;
1691 2038
1692 if (device->in_fs_metadata && avail >= min_free) { 2039 if (device->in_fs_metadata && avail >= min_free) {
1693 u64 ignored_start = 0; 2040 ret = find_free_dev_extent(trans, device,
1694 ret = find_free_dev_extent(trans, device, path, 2041 min_free, &dev_offset);
1695 min_free,
1696 &ignored_start);
1697 if (ret == 0) { 2042 if (ret == 0) {
1698 list_move_tail(&device->dev_alloc_list, 2043 list_move_tail(&device->dev_alloc_list,
1699 &private_devs); 2044 &private_devs);
2045 map->stripes[index].dev = device;
2046 map->stripes[index].physical = dev_offset;
1700 index++; 2047 index++;
1701 if (type & BTRFS_BLOCK_GROUP_DUP) 2048 if (type & BTRFS_BLOCK_GROUP_DUP) {
2049 map->stripes[index].dev = device;
2050 map->stripes[index].physical =
2051 dev_offset + calc_size;
1702 index++; 2052 index++;
2053 }
1703 } 2054 }
1704 } else if (device->in_fs_metadata && avail > max_avail) 2055 } else if (device->in_fs_metadata && avail > max_avail)
1705 max_avail = avail; 2056 max_avail = avail;
1706 if (cur == dev_list) 2057 if (cur == &fs_devices->alloc_list)
1707 break; 2058 break;
1708 } 2059 }
2060 list_splice(&private_devs, &fs_devices->alloc_list);
1709 if (index < num_stripes) { 2061 if (index < num_stripes) {
1710 list_splice(&private_devs, dev_list);
1711 if (index >= min_stripes) { 2062 if (index >= min_stripes) {
1712 num_stripes = index; 2063 num_stripes = index;
1713 if (type & (BTRFS_BLOCK_GROUP_RAID10)) { 2064 if (type & (BTRFS_BLOCK_GROUP_RAID10)) {
@@ -1722,115 +2073,246 @@ again:
1722 calc_size = max_avail; 2073 calc_size = max_avail;
1723 goto again; 2074 goto again;
1724 } 2075 }
1725 btrfs_free_path(path); 2076 kfree(map);
1726 return -ENOSPC; 2077 return -ENOSPC;
1727 } 2078 }
1728 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID; 2079 map->sector_size = extent_root->sectorsize;
1729 key.type = BTRFS_CHUNK_ITEM_KEY; 2080 map->stripe_len = stripe_len;
1730 ret = find_next_chunk(chunk_root, BTRFS_FIRST_CHUNK_TREE_OBJECTID, 2081 map->io_align = stripe_len;
1731 &key.offset); 2082 map->io_width = stripe_len;
1732 if (ret) { 2083 map->type = type;
1733 btrfs_free_path(path); 2084 map->num_stripes = num_stripes;
1734 return ret; 2085 map->sub_stripes = sub_stripes;
1735 }
1736 2086
1737 chunk = kmalloc(btrfs_chunk_item_size(num_stripes), GFP_NOFS); 2087 *map_ret = map;
1738 if (!chunk) { 2088 *stripe_size = calc_size;
1739 btrfs_free_path(path); 2089 *num_bytes = chunk_bytes_by_type(type, calc_size,
1740 return -ENOMEM; 2090 num_stripes, sub_stripes);
1741 }
1742 2091
1743 map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS); 2092 em = alloc_extent_map(GFP_NOFS);
1744 if (!map) { 2093 if (!em) {
1745 kfree(chunk); 2094 kfree(map);
1746 btrfs_free_path(path);
1747 return -ENOMEM; 2095 return -ENOMEM;
1748 } 2096 }
1749 btrfs_free_path(path); 2097 em->bdev = (struct block_device *)map;
1750 path = NULL; 2098 em->start = start;
2099 em->len = *num_bytes;
2100 em->block_start = 0;
2101 em->block_len = em->len;
1751 2102
1752 stripes = &chunk->stripe; 2103 em_tree = &extent_root->fs_info->mapping_tree.map_tree;
1753 *num_bytes = chunk_bytes_by_type(type, calc_size, 2104 spin_lock(&em_tree->lock);
1754 num_stripes, sub_stripes); 2105 ret = add_extent_mapping(em_tree, em);
2106 spin_unlock(&em_tree->lock);
2107 BUG_ON(ret);
2108 free_extent_map(em);
1755 2109
1756 index = 0; 2110 ret = btrfs_make_block_group(trans, extent_root, 0, type,
1757 while(index < num_stripes) { 2111 BTRFS_FIRST_CHUNK_TREE_OBJECTID,
1758 struct btrfs_stripe *stripe; 2112 start, *num_bytes);
1759 BUG_ON(list_empty(&private_devs)); 2113 BUG_ON(ret);
1760 cur = private_devs.next;
1761 device = list_entry(cur, struct btrfs_device, dev_alloc_list);
1762 2114
1763 /* loop over this device again if we're doing a dup group */ 2115 index = 0;
1764 if (!(type & BTRFS_BLOCK_GROUP_DUP) || 2116 while (index < map->num_stripes) {
1765 (index == num_stripes - 1)) 2117 device = map->stripes[index].dev;
1766 list_move_tail(&device->dev_alloc_list, dev_list); 2118 dev_offset = map->stripes[index].physical;
1767 2119
1768 ret = btrfs_alloc_dev_extent(trans, device, 2120 ret = btrfs_alloc_dev_extent(trans, device,
1769 info->chunk_root->root_key.objectid, 2121 info->chunk_root->root_key.objectid,
1770 BTRFS_FIRST_CHUNK_TREE_OBJECTID, key.offset, 2122 BTRFS_FIRST_CHUNK_TREE_OBJECTID,
1771 calc_size, &dev_offset); 2123 start, dev_offset, calc_size);
1772 BUG_ON(ret); 2124 BUG_ON(ret);
1773 device->bytes_used += calc_size; 2125 index++;
2126 }
2127
2128 return 0;
2129}
2130
2131static int __finish_chunk_alloc(struct btrfs_trans_handle *trans,
2132 struct btrfs_root *extent_root,
2133 struct map_lookup *map, u64 chunk_offset,
2134 u64 chunk_size, u64 stripe_size)
2135{
2136 u64 dev_offset;
2137 struct btrfs_key key;
2138 struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
2139 struct btrfs_device *device;
2140 struct btrfs_chunk *chunk;
2141 struct btrfs_stripe *stripe;
2142 size_t item_size = btrfs_chunk_item_size(map->num_stripes);
2143 int index = 0;
2144 int ret;
2145
2146 chunk = kzalloc(item_size, GFP_NOFS);
2147 if (!chunk)
2148 return -ENOMEM;
2149
2150 index = 0;
2151 while (index < map->num_stripes) {
2152 device = map->stripes[index].dev;
2153 device->bytes_used += stripe_size;
1774 ret = btrfs_update_device(trans, device); 2154 ret = btrfs_update_device(trans, device);
1775 BUG_ON(ret); 2155 BUG_ON(ret);
2156 index++;
2157 }
2158
2159 index = 0;
2160 stripe = &chunk->stripe;
2161 while (index < map->num_stripes) {
2162 device = map->stripes[index].dev;
2163 dev_offset = map->stripes[index].physical;
1776 2164
1777 map->stripes[index].dev = device;
1778 map->stripes[index].physical = dev_offset;
1779 stripe = stripes + index;
1780 btrfs_set_stack_stripe_devid(stripe, device->devid); 2165 btrfs_set_stack_stripe_devid(stripe, device->devid);
1781 btrfs_set_stack_stripe_offset(stripe, dev_offset); 2166 btrfs_set_stack_stripe_offset(stripe, dev_offset);
1782 memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE); 2167 memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE);
1783 physical = dev_offset; 2168 stripe++;
1784 index++; 2169 index++;
1785 } 2170 }
1786 BUG_ON(!list_empty(&private_devs));
1787 2171
1788 /* key was set above */ 2172 btrfs_set_stack_chunk_length(chunk, chunk_size);
1789 btrfs_set_stack_chunk_length(chunk, *num_bytes);
1790 btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid); 2173 btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid);
1791 btrfs_set_stack_chunk_stripe_len(chunk, stripe_len); 2174 btrfs_set_stack_chunk_stripe_len(chunk, map->stripe_len);
1792 btrfs_set_stack_chunk_type(chunk, type); 2175 btrfs_set_stack_chunk_type(chunk, map->type);
1793 btrfs_set_stack_chunk_num_stripes(chunk, num_stripes); 2176 btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes);
1794 btrfs_set_stack_chunk_io_align(chunk, stripe_len); 2177 btrfs_set_stack_chunk_io_align(chunk, map->stripe_len);
1795 btrfs_set_stack_chunk_io_width(chunk, stripe_len); 2178 btrfs_set_stack_chunk_io_width(chunk, map->stripe_len);
1796 btrfs_set_stack_chunk_sector_size(chunk, extent_root->sectorsize); 2179 btrfs_set_stack_chunk_sector_size(chunk, extent_root->sectorsize);
1797 btrfs_set_stack_chunk_sub_stripes(chunk, sub_stripes); 2180 btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes);
1798 map->sector_size = extent_root->sectorsize;
1799 map->stripe_len = stripe_len;
1800 map->io_align = stripe_len;
1801 map->io_width = stripe_len;
1802 map->type = type;
1803 map->num_stripes = num_stripes;
1804 map->sub_stripes = sub_stripes;
1805 2181
1806 ret = btrfs_insert_item(trans, chunk_root, &key, chunk, 2182 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
1807 btrfs_chunk_item_size(num_stripes)); 2183 key.type = BTRFS_CHUNK_ITEM_KEY;
1808 BUG_ON(ret); 2184 key.offset = chunk_offset;
1809 *start = key.offset;;
1810 2185
1811 em = alloc_extent_map(GFP_NOFS); 2186 ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size);
1812 if (!em) 2187 BUG_ON(ret);
1813 return -ENOMEM;
1814 em->bdev = (struct block_device *)map;
1815 em->start = key.offset;
1816 em->len = *num_bytes;
1817 em->block_start = 0;
1818 em->block_len = em->len;
1819 2188
1820 if (type & BTRFS_BLOCK_GROUP_SYSTEM) { 2189 if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
1821 ret = btrfs_add_system_chunk(trans, chunk_root, &key, 2190 ret = btrfs_add_system_chunk(trans, chunk_root, &key, chunk,
1822 chunk, btrfs_chunk_item_size(num_stripes)); 2191 item_size);
1823 BUG_ON(ret); 2192 BUG_ON(ret);
1824 } 2193 }
1825 kfree(chunk); 2194 kfree(chunk);
2195 return 0;
2196}
1826 2197
1827 em_tree = &extent_root->fs_info->mapping_tree.map_tree; 2198/*
1828 spin_lock(&em_tree->lock); 2199 * Chunk allocation falls into two parts. The first part does works
1829 ret = add_extent_mapping(em_tree, em); 2200 * that make the new allocated chunk useable, but not do any operation
1830 spin_unlock(&em_tree->lock); 2201 * that modifies the chunk tree. The second part does the works that
2202 * require modifying the chunk tree. This division is important for the
2203 * bootstrap process of adding storage to a seed btrfs.
2204 */
2205int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
2206 struct btrfs_root *extent_root, u64 type)
2207{
2208 u64 chunk_offset;
2209 u64 chunk_size;
2210 u64 stripe_size;
2211 struct map_lookup *map;
2212 struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
2213 int ret;
2214
2215 ret = find_next_chunk(chunk_root, BTRFS_FIRST_CHUNK_TREE_OBJECTID,
2216 &chunk_offset);
2217 if (ret)
2218 return ret;
2219
2220 ret = __btrfs_alloc_chunk(trans, extent_root, &map, &chunk_size,
2221 &stripe_size, chunk_offset, type);
2222 if (ret)
2223 return ret;
2224
2225 ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset,
2226 chunk_size, stripe_size);
1831 BUG_ON(ret); 2227 BUG_ON(ret);
2228 return 0;
2229}
2230
2231static int noinline init_first_rw_device(struct btrfs_trans_handle *trans,
2232 struct btrfs_root *root,
2233 struct btrfs_device *device)
2234{
2235 u64 chunk_offset;
2236 u64 sys_chunk_offset;
2237 u64 chunk_size;
2238 u64 sys_chunk_size;
2239 u64 stripe_size;
2240 u64 sys_stripe_size;
2241 u64 alloc_profile;
2242 struct map_lookup *map;
2243 struct map_lookup *sys_map;
2244 struct btrfs_fs_info *fs_info = root->fs_info;
2245 struct btrfs_root *extent_root = fs_info->extent_root;
2246 int ret;
2247
2248 ret = find_next_chunk(fs_info->chunk_root,
2249 BTRFS_FIRST_CHUNK_TREE_OBJECTID, &chunk_offset);
2250 BUG_ON(ret);
2251
2252 alloc_profile = BTRFS_BLOCK_GROUP_METADATA |
2253 (fs_info->metadata_alloc_profile &
2254 fs_info->avail_metadata_alloc_bits);
2255 alloc_profile = btrfs_reduce_alloc_profile(root, alloc_profile);
2256
2257 ret = __btrfs_alloc_chunk(trans, extent_root, &map, &chunk_size,
2258 &stripe_size, chunk_offset, alloc_profile);
2259 BUG_ON(ret);
2260
2261 sys_chunk_offset = chunk_offset + chunk_size;
2262
2263 alloc_profile = BTRFS_BLOCK_GROUP_SYSTEM |
2264 (fs_info->system_alloc_profile &
2265 fs_info->avail_system_alloc_bits);
2266 alloc_profile = btrfs_reduce_alloc_profile(root, alloc_profile);
2267
2268 ret = __btrfs_alloc_chunk(trans, extent_root, &sys_map,
2269 &sys_chunk_size, &sys_stripe_size,
2270 sys_chunk_offset, alloc_profile);
2271 BUG_ON(ret);
2272
2273 ret = btrfs_add_device(trans, fs_info->chunk_root, device);
2274 BUG_ON(ret);
2275
2276 /*
2277 * Modifying chunk tree needs allocating new blocks from both
2278 * system block group and metadata block group. So we only can
2279 * do operations require modifying the chunk tree after both
2280 * block groups were created.
2281 */
2282 ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset,
2283 chunk_size, stripe_size);
2284 BUG_ON(ret);
2285
2286 ret = __finish_chunk_alloc(trans, extent_root, sys_map,
2287 sys_chunk_offset, sys_chunk_size,
2288 sys_stripe_size);
2289 BUG_ON(ret);
2290 return 0;
2291}
2292
2293int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset)
2294{
2295 struct extent_map *em;
2296 struct map_lookup *map;
2297 struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
2298 int readonly = 0;
2299 int i;
2300
2301 spin_lock(&map_tree->map_tree.lock);
2302 em = lookup_extent_mapping(&map_tree->map_tree, chunk_offset, 1);
2303 spin_unlock(&map_tree->map_tree.lock);
2304 if (!em)
2305 return 1;
2306
2307 map = (struct map_lookup *)em->bdev;
2308 for (i = 0; i < map->num_stripes; i++) {
2309 if (!map->stripes[i].dev->writeable) {
2310 readonly = 1;
2311 break;
2312 }
2313 }
1832 free_extent_map(em); 2314 free_extent_map(em);
1833 return ret; 2315 return readonly;
1834} 2316}
1835 2317
1836void btrfs_mapping_init(struct btrfs_mapping_tree *tree) 2318void btrfs_mapping_init(struct btrfs_mapping_tree *tree)
@@ -2227,6 +2709,7 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
2227 } 2709 }
2228 bio->bi_sector = multi->stripes[dev_nr].physical >> 9; 2710 bio->bi_sector = multi->stripes[dev_nr].physical >> 9;
2229 dev = multi->stripes[dev_nr].dev; 2711 dev = multi->stripes[dev_nr].dev;
2712 BUG_ON(rw == WRITE && !dev->writeable);
2230 if (dev && dev->bdev) { 2713 if (dev && dev->bdev) {
2231 bio->bi_bdev = dev->bdev; 2714 bio->bi_bdev = dev->bdev;
2232 if (async_submit) 2715 if (async_submit)
@@ -2246,11 +2729,23 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
2246} 2729}
2247 2730
2248struct btrfs_device *btrfs_find_device(struct btrfs_root *root, u64 devid, 2731struct btrfs_device *btrfs_find_device(struct btrfs_root *root, u64 devid,
2249 u8 *uuid) 2732 u8 *uuid, u8 *fsid)
2250{ 2733{
2251 struct list_head *head = &root->fs_info->fs_devices->devices; 2734 struct btrfs_device *device;
2252 2735 struct btrfs_fs_devices *cur_devices;
2253 return __find_device(head, devid, uuid); 2736
2737 cur_devices = root->fs_info->fs_devices;
2738 while (cur_devices) {
2739 if (!fsid ||
2740 !memcmp(cur_devices->fsid, fsid, BTRFS_UUID_SIZE)) {
2741 device = __find_device(&cur_devices->devices,
2742 devid, uuid);
2743 if (device)
2744 return device;
2745 }
2746 cur_devices = cur_devices->seed;
2747 }
2748 return NULL;
2254} 2749}
2255 2750
2256static struct btrfs_device *add_missing_dev(struct btrfs_root *root, 2751static struct btrfs_device *add_missing_dev(struct btrfs_root *root,
@@ -2262,8 +2757,6 @@ static struct btrfs_device *add_missing_dev(struct btrfs_root *root,
2262 device = kzalloc(sizeof(*device), GFP_NOFS); 2757 device = kzalloc(sizeof(*device), GFP_NOFS);
2263 list_add(&device->dev_list, 2758 list_add(&device->dev_list,
2264 &fs_devices->devices); 2759 &fs_devices->devices);
2265 list_add(&device->dev_alloc_list,
2266 &fs_devices->alloc_list);
2267 device->barriers = 1; 2760 device->barriers = 1;
2268 device->dev_root = root->fs_info->dev_root; 2761 device->dev_root = root->fs_info->dev_root;
2269 device->devid = devid; 2762 device->devid = devid;
@@ -2274,7 +2767,6 @@ static struct btrfs_device *add_missing_dev(struct btrfs_root *root,
2274 return device; 2767 return device;
2275} 2768}
2276 2769
2277
2278static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key, 2770static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
2279 struct extent_buffer *leaf, 2771 struct extent_buffer *leaf,
2280 struct btrfs_chunk *chunk) 2772 struct btrfs_chunk *chunk)
@@ -2339,8 +2831,8 @@ static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
2339 read_extent_buffer(leaf, uuid, (unsigned long) 2831 read_extent_buffer(leaf, uuid, (unsigned long)
2340 btrfs_stripe_dev_uuid_nr(chunk, i), 2832 btrfs_stripe_dev_uuid_nr(chunk, i),
2341 BTRFS_UUID_SIZE); 2833 BTRFS_UUID_SIZE);
2342 map->stripes[i].dev = btrfs_find_device(root, devid, uuid); 2834 map->stripes[i].dev = btrfs_find_device(root, devid, uuid,
2343 2835 NULL);
2344 if (!map->stripes[i].dev && !btrfs_test_opt(root, DEGRADED)) { 2836 if (!map->stripes[i].dev && !btrfs_test_opt(root, DEGRADED)) {
2345 kfree(map); 2837 kfree(map);
2346 free_extent_map(em); 2838 free_extent_map(em);
@@ -2387,6 +2879,50 @@ static int fill_device_from_item(struct extent_buffer *leaf,
2387 return 0; 2879 return 0;
2388} 2880}
2389 2881
2882static int open_seed_devices(struct btrfs_root *root, u8 *fsid)
2883{
2884 struct btrfs_fs_devices *fs_devices;
2885 int ret;
2886
2887 mutex_lock(&uuid_mutex);
2888
2889 fs_devices = root->fs_info->fs_devices->seed;
2890 while (fs_devices) {
2891 if (!memcmp(fs_devices->fsid, fsid, BTRFS_UUID_SIZE)) {
2892 ret = 0;
2893 goto out;
2894 }
2895 fs_devices = fs_devices->seed;
2896 }
2897
2898 fs_devices = find_fsid(fsid);
2899 if (!fs_devices) {
2900 ret = -ENOENT;
2901 goto out;
2902 }
2903 if (fs_devices->opened) {
2904 ret = -EBUSY;
2905 goto out;
2906 }
2907
2908 ret = __btrfs_open_devices(fs_devices, root->fs_info->bdev_holder);
2909 if (ret)
2910 goto out;
2911
2912 if (!fs_devices->seeding) {
2913 __btrfs_close_devices(fs_devices);
2914 ret = -EINVAL;
2915 goto out;
2916 }
2917
2918 fs_devices->seed = root->fs_info->fs_devices->seed;
2919 root->fs_info->fs_devices->seed = fs_devices;
2920 fs_devices->sprouted = 1;
2921out:
2922 mutex_unlock(&uuid_mutex);
2923 return ret;
2924}
2925
2390static int read_one_dev(struct btrfs_root *root, 2926static int read_one_dev(struct btrfs_root *root,
2391 struct extent_buffer *leaf, 2927 struct extent_buffer *leaf,
2392 struct btrfs_dev_item *dev_item) 2928 struct btrfs_dev_item *dev_item)
@@ -2394,23 +2930,50 @@ static int read_one_dev(struct btrfs_root *root,
2394 struct btrfs_device *device; 2930 struct btrfs_device *device;
2395 u64 devid; 2931 u64 devid;
2396 int ret; 2932 int ret;
2933 int seed_devices = 0;
2934 u8 fs_uuid[BTRFS_UUID_SIZE];
2397 u8 dev_uuid[BTRFS_UUID_SIZE]; 2935 u8 dev_uuid[BTRFS_UUID_SIZE];
2398 2936
2399 devid = btrfs_device_id(leaf, dev_item); 2937 devid = btrfs_device_id(leaf, dev_item);
2400 read_extent_buffer(leaf, dev_uuid, 2938 read_extent_buffer(leaf, dev_uuid,
2401 (unsigned long)btrfs_device_uuid(dev_item), 2939 (unsigned long)btrfs_device_uuid(dev_item),
2402 BTRFS_UUID_SIZE); 2940 BTRFS_UUID_SIZE);
2403 device = btrfs_find_device(root, devid, dev_uuid); 2941 read_extent_buffer(leaf, fs_uuid,
2404 if (!device) { 2942 (unsigned long)btrfs_device_fsid(dev_item),
2405 printk("warning devid %Lu missing\n", devid); 2943 BTRFS_UUID_SIZE);
2406 device = add_missing_dev(root, devid, dev_uuid); 2944
2407 if (!device) 2945 if (memcmp(fs_uuid, root->fs_info->fsid, BTRFS_UUID_SIZE)) {
2408 return -ENOMEM; 2946 ret = open_seed_devices(root, fs_uuid);
2947 if (ret)
2948 return ret;
2949 seed_devices = 1;
2950 }
2951
2952 device = btrfs_find_device(root, devid, dev_uuid, fs_uuid);
2953 if (!device || !device->bdev) {
2954 if (!btrfs_test_opt(root, DEGRADED) || seed_devices)
2955 return -EIO;
2956
2957 if (!device) {
2958 printk("warning devid %Lu missing\n", devid);
2959 device = add_missing_dev(root, devid, dev_uuid);
2960 if (!device)
2961 return -ENOMEM;
2962 }
2963 }
2964
2965 if (device->fs_devices != root->fs_info->fs_devices) {
2966 BUG_ON(device->writeable);
2967 if (device->generation !=
2968 btrfs_device_generation(leaf, dev_item))
2969 return -EINVAL;
2409 } 2970 }
2410 2971
2411 fill_device_from_item(leaf, dev_item, device); 2972 fill_device_from_item(leaf, dev_item, device);
2412 device->dev_root = root->fs_info->dev_root; 2973 device->dev_root = root->fs_info->dev_root;
2413 device->in_fs_metadata = 1; 2974 device->in_fs_metadata = 1;
2975 if (device->writeable)
2976 device->fs_devices->total_rw_bytes += device->total_bytes;
2414 ret = 0; 2977 ret = 0;
2415#if 0 2978#if 0
2416 ret = btrfs_open_device(device); 2979 ret = btrfs_open_device(device);
@@ -2528,12 +3091,15 @@ again:
2528 dev_item = btrfs_item_ptr(leaf, slot, 3091 dev_item = btrfs_item_ptr(leaf, slot,
2529 struct btrfs_dev_item); 3092 struct btrfs_dev_item);
2530 ret = read_one_dev(root, leaf, dev_item); 3093 ret = read_one_dev(root, leaf, dev_item);
2531 BUG_ON(ret); 3094 if (ret)
3095 goto error;
2532 } 3096 }
2533 } else if (found_key.type == BTRFS_CHUNK_ITEM_KEY) { 3097 } else if (found_key.type == BTRFS_CHUNK_ITEM_KEY) {
2534 struct btrfs_chunk *chunk; 3098 struct btrfs_chunk *chunk;
2535 chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk); 3099 chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
2536 ret = read_one_chunk(root, &found_key, leaf, chunk); 3100 ret = read_one_chunk(root, &found_key, leaf, chunk);
3101 if (ret)
3102 goto error;
2537 } 3103 }
2538 path->slots[0]++; 3104 path->slots[0]++;
2539 } 3105 }
@@ -2542,9 +3108,8 @@ again:
2542 btrfs_release_path(root, path); 3108 btrfs_release_path(root, path);
2543 goto again; 3109 goto again;
2544 } 3110 }
2545
2546 btrfs_free_path(path);
2547 ret = 0; 3111 ret = 0;
2548error: 3112error:
3113 btrfs_free_path(path);
2549 return ret; 3114 return ret;
2550} 3115}
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index c50e50580b51..1f6f25a5787f 100644
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -26,6 +26,7 @@ struct buffer_head;
26struct btrfs_device { 26struct btrfs_device {
27 struct list_head dev_list; 27 struct list_head dev_list;
28 struct list_head dev_alloc_list; 28 struct list_head dev_alloc_list;
29 struct btrfs_fs_devices *fs_devices;
29 struct btrfs_root *dev_root; 30 struct btrfs_root *dev_root;
30 struct buffer_head *pending_io; 31 struct buffer_head *pending_io;
31 struct bio *pending_bios; 32 struct bio *pending_bios;
@@ -34,6 +35,7 @@ struct btrfs_device {
34 u64 generation; 35 u64 generation;
35 36
36 int barriers; 37 int barriers;
38 int writeable;
37 int in_fs_metadata; 39 int in_fs_metadata;
38 40
39 spinlock_t io_lock; 41 spinlock_t io_lock;
@@ -77,6 +79,8 @@ struct btrfs_fs_devices {
77 u64 latest_trans; 79 u64 latest_trans;
78 u64 num_devices; 80 u64 num_devices;
79 u64 open_devices; 81 u64 open_devices;
82 u64 rw_devices;
83 u64 total_rw_bytes;
80 struct block_device *latest_bdev; 84 struct block_device *latest_bdev;
81 /* all of the devices in the FS */ 85 /* all of the devices in the FS */
82 struct list_head devices; 86 struct list_head devices;
@@ -84,7 +88,12 @@ struct btrfs_fs_devices {
84 /* devices not currently being allocated */ 88 /* devices not currently being allocated */
85 struct list_head alloc_list; 89 struct list_head alloc_list;
86 struct list_head list; 90 struct list_head list;
87 int mounted; 91
92 struct btrfs_fs_devices *seed;
93 int seeding;
94 int sprouted;
95
96 int opened;
88}; 97};
89 98
90struct btrfs_bio_stripe { 99struct btrfs_bio_stripe {
@@ -109,16 +118,14 @@ struct btrfs_multi_bio {
109int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans, 118int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
110 struct btrfs_device *device, 119 struct btrfs_device *device,
111 u64 chunk_tree, u64 chunk_objectid, 120 u64 chunk_tree, u64 chunk_objectid,
112 u64 chunk_offset, 121 u64 chunk_offset, u64 start, u64 num_bytes);
113 u64 num_bytes, u64 *start);
114int btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw, 122int btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
115 u64 logical, u64 *length, 123 u64 logical, u64 *length,
116 struct btrfs_multi_bio **multi_ret, int mirror_num); 124 struct btrfs_multi_bio **multi_ret, int mirror_num);
117int btrfs_read_sys_array(struct btrfs_root *root); 125int btrfs_read_sys_array(struct btrfs_root *root);
118int btrfs_read_chunk_tree(struct btrfs_root *root); 126int btrfs_read_chunk_tree(struct btrfs_root *root);
119int btrfs_alloc_chunk(struct btrfs_trans_handle *trans, 127int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
120 struct btrfs_root *extent_root, u64 *start, 128 struct btrfs_root *extent_root, u64 type);
121 u64 *num_bytes, u64 type);
122void btrfs_mapping_init(struct btrfs_mapping_tree *tree); 129void btrfs_mapping_init(struct btrfs_mapping_tree *tree);
123void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree); 130void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree);
124int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio, 131int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
@@ -141,10 +148,11 @@ int btrfs_unplug_page(struct btrfs_mapping_tree *map_tree,
141int btrfs_grow_device(struct btrfs_trans_handle *trans, 148int btrfs_grow_device(struct btrfs_trans_handle *trans,
142 struct btrfs_device *device, u64 new_size); 149 struct btrfs_device *device, u64 new_size);
143struct btrfs_device *btrfs_find_device(struct btrfs_root *root, u64 devid, 150struct btrfs_device *btrfs_find_device(struct btrfs_root *root, u64 devid,
144 u8 *uuid); 151 u8 *uuid, u8 *fsid);
145int btrfs_shrink_device(struct btrfs_device *device, u64 new_size); 152int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
146int btrfs_init_new_device(struct btrfs_root *root, char *path); 153int btrfs_init_new_device(struct btrfs_root *root, char *path);
147int btrfs_balance(struct btrfs_root *dev_root); 154int btrfs_balance(struct btrfs_root *dev_root);
148void btrfs_unlock_volumes(void); 155void btrfs_unlock_volumes(void);
149void btrfs_lock_volumes(void); 156void btrfs_lock_volumes(void);
157int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset);
150#endif 158#endif
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-15 08:52:47 -0500