aboutsummaryrefslogtreecommitdiffstats
path: root/fs/btrfs
diff options
context:
space:
mode:
authorYan Zheng <zheng.yan@oracle.com>2008-11-17 21:11:30 -0500
committerChris Mason <chris.mason@oracle.com>2008-11-17 21:11:30 -0500
commit2b82032c34ec40515d3c45c36cd1961f37977de8 (patch)
treefbdfe7b13dd51983dfca4aeb75983b37ee186ff9 /fs/btrfs
parentc146afad2c7fea6a366d4945c1bab9b03880f526 (diff)
Btrfs: Seed device support
Seed device is a special btrfs with SEEDING super flag set and can only be mounted in read-only mode. Seed devices allow people to create new btrfs on top of it. The new FS contains the same contents as the seed device, but it can be mounted in read-write mode. This patch does the following: 1) split code in btrfs_alloc_chunk into two parts. The first part does makes the newly allocated chunk usable, but does not do any operation that modifies the chunk tree. The second part does the the chunk tree modifications. This division is for the bootstrap step of adding storage to the seed device. 2) Update device management code to handle seed device. The basic idea is: For an FS grown from seed devices, its seed devices are put into a list. Seed devices are opened on demand at mounting time. If any seed device is missing or has been changed, btrfs kernel module will refuse to mount the FS. 3) make btrfs_find_block_group not return NULL when all block groups are read-only. Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
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-14 21:17:45 -0500