Lines Matching +full:system +full:- +full:ctl
1 // SPDX-License-Identifier: GPL-2.0
18 #include "disk-io.h"
20 #include "print-tree.h"
23 #include "rcu-string.h"
24 #include "dev-replace.h"
26 #include "tree-checker.h"
27 #include "space-info.h"
28 #include "block-group.h"
33 #include "uuid-tree.h"
217 size_bp -= ret; \ in btrfs_describe_block_groups()
224 DESCRIBE_FLAG(BTRFS_BLOCK_GROUP_SYSTEM, "system"); in btrfs_describe_block_groups()
235 size_bp -= ret; in btrfs_describe_block_groups()
239 buf[size_buf - size_bp - 1] = '\0'; /* remove last | */ in btrfs_describe_block_groups()
256 * There are several mutexes that protect manipulation of devices and low-level
260 * ------------------------
261 * protects the fs_uuids list that tracks all per-fs fs_devices, resulting from
265 * the mutex can be very coarse and can cover long-running operations
270 * global::fs_devs - add, remove, updates to the global list
276 * btrfs_device::name - renames (write side), read is RCU
278 * fs_devices::device_list_mutex (per-fs, with RCU)
279 * ------------------------------------------------
282 * simple list traversal with read-only actions can be done with RCU protection
291 * -------------
296 * -----------
303 * -------------
323 * - Balance (*)
324 * - Device add
325 * - Device remove
326 * - Device replace (*)
327 * - Resize
331 * - Running state
332 * - Paused state
333 * - Completed state
338 * - ioctl (only Balance can be Paused through ioctl)
339 * - filesystem remounted as read-only
340 * - filesystem unmounted and mounted as read-only
341 * - system power-cycle and filesystem mounted as read-only
342 * - filesystem or device errors leading to forced read-only
347 * either by ioctl (Balance only) or when remounted as read-write.
360 * alloc_fs_devices - allocate struct btrfs_fs_devices
377 return ERR_PTR(-ENOMEM); in alloc_fs_devices()
379 mutex_init(&fs_devs->device_list_mutex); in alloc_fs_devices()
381 INIT_LIST_HEAD(&fs_devs->devices); in alloc_fs_devices()
382 INIT_LIST_HEAD(&fs_devs->alloc_list); in alloc_fs_devices()
383 INIT_LIST_HEAD(&fs_devs->fs_list); in alloc_fs_devices()
384 INIT_LIST_HEAD(&fs_devs->seed_list); in alloc_fs_devices()
387 memcpy(fs_devs->fsid, fsid, BTRFS_FSID_SIZE); in alloc_fs_devices()
388 memcpy(fs_devs->metadata_uuid, in alloc_fs_devices()
397 WARN_ON(!list_empty(&device->post_commit_list)); in btrfs_free_device()
398 rcu_string_free(device->name); in btrfs_free_device()
399 extent_io_tree_release(&device->alloc_state); in btrfs_free_device()
408 WARN_ON(fs_devices->opened); in free_fs_devices()
409 while (!list_empty(&fs_devices->devices)) { in free_fs_devices()
410 device = list_entry(fs_devices->devices.next, in free_fs_devices()
412 list_del(&device->dev_list); in free_fs_devices()
425 list_del(&fs_devices->fs_list); in btrfs_cleanup_fs_uuids()
433 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) != 0) in match_fsid_fs_devices()
439 if (memcmp(metadata_fsid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE) != 0) in match_fsid_fs_devices()
452 /* Handle non-split brain cases */ in find_fsid()
468 return memcmp(fs_devices->fsid, fs_devices->metadata_uuid, in check_fsid_changed()
470 memcmp(fs_devices->metadata_uuid, fsid, BTRFS_FSID_SIZE) == 0; in check_fsid_changed()
486 if (!fs_devices->fsid_change) in find_fsid_with_metadata_uuid()
489 if (match_fsid_fs_devices(fs_devices, disk_super->metadata_uuid, in find_fsid_with_metadata_uuid()
490 fs_devices->fsid)) in find_fsid_with_metadata_uuid()
501 if (!fs_devices->fsid_change) in find_fsid_with_metadata_uuid()
504 if (check_fsid_changed(fs_devices, disk_super->metadata_uuid)) in find_fsid_with_metadata_uuid()
508 return find_fsid(disk_super->fsid, disk_super->metadata_uuid); in find_fsid_with_metadata_uuid()
558 * -EBUSY if @devt is a mounted device.
559 * -ENOENT if @devt does not match any device in the list.
570 ret = -ENOENT; in btrfs_free_stale_devices()
574 mutex_lock(&fs_devices->device_list_mutex); in btrfs_free_stale_devices()
576 &fs_devices->devices, dev_list) { in btrfs_free_stale_devices()
579 if (devt && devt != device->devt) in btrfs_free_stale_devices()
581 if (fs_devices->opened) { in btrfs_free_stale_devices()
584 ret = -EBUSY; in btrfs_free_stale_devices()
589 fs_devices->num_devices--; in btrfs_free_stale_devices()
590 list_del(&device->dev_list); in btrfs_free_stale_devices()
595 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_free_stale_devices()
597 if (fs_devices->num_devices == 0) { in btrfs_free_stale_devices()
599 list_del(&fs_devices->fs_list); in btrfs_free_stale_devices()
610 * fs_devices->device_list_mutex here.
621 if (device->bdev) in btrfs_open_one_device()
622 return -EINVAL; in btrfs_open_one_device()
623 if (!device->name) in btrfs_open_one_device()
624 return -EINVAL; in btrfs_open_one_device()
626 ret = btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1, in btrfs_open_one_device()
631 devid = btrfs_stack_device_id(&disk_super->dev_item); in btrfs_open_one_device()
632 if (devid != device->devid) in btrfs_open_one_device()
635 if (memcmp(device->uuid, disk_super->dev_item.uuid, BTRFS_UUID_SIZE)) in btrfs_open_one_device()
638 device->generation = btrfs_super_generation(disk_super); in btrfs_open_one_device()
644 "BTRFS: Invalid seeding and uuid-changed device detected\n"); in btrfs_open_one_device()
648 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_open_one_device()
649 fs_devices->seeding = true; in btrfs_open_one_device()
652 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_open_one_device()
654 set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_open_one_device()
658 fs_devices->rotating = true; in btrfs_open_one_device()
661 fs_devices->discardable = true; in btrfs_open_one_device()
663 device->bdev = bdev; in btrfs_open_one_device()
664 clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_open_one_device()
665 device->holder = holder; in btrfs_open_one_device()
667 fs_devices->open_devices++; in btrfs_open_one_device()
668 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_open_one_device()
669 device->devid != BTRFS_DEV_REPLACE_DEVID) { in btrfs_open_one_device()
670 fs_devices->rw_devices++; in btrfs_open_one_device()
671 list_add_tail(&device->dev_alloc_list, &fs_devices->alloc_list); in btrfs_open_one_device()
681 return -EINVAL; in btrfs_open_one_device()
689 return has_metadata_uuid ? sb->metadata_uuid : sb->fsid; in btrfs_sb_fsid_ptr()
700 if (!device->name) in is_same_device()
708 ret = strscpy(old_path, rcu_str_deref(device->name), PATH_MAX); in is_same_device()
740 if (fs_devices->fsid_change) in find_fsid_inprogress()
743 if (check_fsid_changed(fs_devices, disk_super->fsid)) in find_fsid_inprogress()
747 return find_fsid(disk_super->fsid, NULL); in find_fsid_inprogress()
760 * 1 - The fs still continues to have different METADATA/FSID uuids. in find_fsid_changed()
761 * 2 - The fs is switched back to its original FSID (METADATA/FSID in find_fsid_changed()
766 if (check_fsid_changed(fs_devices, disk_super->metadata_uuid) && in find_fsid_changed()
767 memcmp(fs_devices->fsid, disk_super->fsid, in find_fsid_changed()
772 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, in find_fsid_changed()
774 memcmp(fs_devices->fsid, disk_super->metadata_uuid, in find_fsid_changed()
797 if (!fs_devices->fsid_change) in find_fsid_reverted_metadata()
800 if (check_fsid_changed(fs_devices, disk_super->fsid)) in find_fsid_reverted_metadata()
821 u64 devid = btrfs_stack_device_id(&disk_super->dev_item); in device_list_add()
846 fs_devices = find_fsid(disk_super->fsid, NULL); in device_list_add()
851 fs_devices = alloc_fs_devices(disk_super->fsid, in device_list_add()
852 has_metadata_uuid ? disk_super->metadata_uuid : NULL); in device_list_add()
856 fs_devices->fsid_change = fsid_change_in_progress; in device_list_add()
858 mutex_lock(&fs_devices->device_list_mutex); in device_list_add()
859 list_add(&fs_devices->fs_list, &fs_uuids); in device_list_add()
865 .uuid = disk_super->dev_item.uuid, in device_list_add()
868 mutex_lock(&fs_devices->device_list_mutex); in device_list_add()
876 if (fs_devices->fsid_change && in device_list_add()
877 found_transid > fs_devices->latest_generation) { in device_list_add()
878 memcpy(fs_devices->fsid, disk_super->fsid, in device_list_add()
880 memcpy(fs_devices->metadata_uuid, in device_list_add()
882 fs_devices->fsid_change = false; in device_list_add()
889 if (fs_devices->opened) { in device_list_add()
892 path, fs_devices->fsid, current->comm, in device_list_add()
894 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
895 return ERR_PTR(-EBUSY); in device_list_add()
900 disk_super->dev_item.uuid, path); in device_list_add()
903 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
908 device->devt = path_devt; in device_list_add()
910 list_add_rcu(&device->dev_list, &fs_devices->devices); in device_list_add()
911 fs_devices->num_devices++; in device_list_add()
913 device->fs_devices = fs_devices; in device_list_add()
916 if (disk_super->label[0]) in device_list_add()
919 disk_super->label, devid, found_transid, path, in device_list_add()
920 current->comm, task_pid_nr(current)); in device_list_add()
924 disk_super->fsid, devid, found_transid, path, in device_list_add()
925 current->comm, task_pid_nr(current)); in device_list_add()
927 } else if (!device->name || !is_same_device(device, path)) { in device_list_add()
930 * 1. If you are here and if the device->name is NULL that in device_list_add()
932 * 2. If you are here and if the device->name is different in device_list_add()
936 * b. The missing-disk-which-was-replaced, has in device_list_add()
954 if (!fs_devices->opened && found_transid < device->generation) { in device_list_add()
959 * with larger generation number or the last-in if in device_list_add()
962 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
965 path, found_transid, device->generation); in device_list_add()
966 return ERR_PTR(-EEXIST); in device_list_add()
973 * NOTE: the device->fs_info may not be reliable here so pass in device_list_add()
975 * use-after-free when the fs_info and fs_info->sb are already in device_list_add()
978 if (device->bdev) { in device_list_add()
979 if (device->devt != path_devt) { in device_list_add()
980 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
984 current->comm, in device_list_add()
986 return ERR_PTR(-EEXIST); in device_list_add()
991 path, current->comm, in device_list_add()
997 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
998 return ERR_PTR(-ENOMEM); in device_list_add()
1000 rcu_string_free(device->name); in device_list_add()
1001 rcu_assign_pointer(device->name, name); in device_list_add()
1002 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in device_list_add()
1003 fs_devices->missing_devices--; in device_list_add()
1004 clear_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in device_list_add()
1006 device->devt = path_devt; in device_list_add()
1015 if (!fs_devices->opened) { in device_list_add()
1016 device->generation = found_transid; in device_list_add()
1017 fs_devices->latest_generation = max_t(u64, found_transid, in device_list_add()
1018 fs_devices->latest_generation); in device_list_add()
1021 fs_devices->total_devices = btrfs_super_num_devices(disk_super); in device_list_add()
1023 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
1036 fs_devices = alloc_fs_devices(orig->fsid, NULL); in clone_fs_devices()
1040 fs_devices->total_devices = orig->total_devices; in clone_fs_devices()
1042 list_for_each_entry(orig_dev, &orig->devices, dev_list) { in clone_fs_devices()
1049 if (orig_dev->name) in clone_fs_devices()
1050 dev_path = orig_dev->name->str; in clone_fs_devices()
1052 device = btrfs_alloc_device(NULL, &orig_dev->devid, in clone_fs_devices()
1053 orig_dev->uuid, dev_path); in clone_fs_devices()
1059 if (orig_dev->zone_info) { in clone_fs_devices()
1065 ret = -ENOMEM; in clone_fs_devices()
1068 device->zone_info = zone_info; in clone_fs_devices()
1071 list_add(&device->dev_list, &fs_devices->devices); in clone_fs_devices()
1072 device->fs_devices = fs_devices; in clone_fs_devices()
1073 fs_devices->num_devices++; in clone_fs_devices()
1087 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) { in __btrfs_free_extra_devids()
1088 if (test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state)) { in __btrfs_free_extra_devids()
1090 &device->dev_state) && in __btrfs_free_extra_devids()
1092 &device->dev_state) && in __btrfs_free_extra_devids()
1094 device->generation > (*latest_dev)->generation)) { in __btrfs_free_extra_devids()
1104 if (device->devid == BTRFS_DEV_REPLACE_DEVID) in __btrfs_free_extra_devids()
1107 if (device->bdev) { in __btrfs_free_extra_devids()
1108 blkdev_put(device->bdev, device->holder); in __btrfs_free_extra_devids()
1109 device->bdev = NULL; in __btrfs_free_extra_devids()
1110 fs_devices->open_devices--; in __btrfs_free_extra_devids()
1112 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in __btrfs_free_extra_devids()
1113 list_del_init(&device->dev_alloc_list); in __btrfs_free_extra_devids()
1114 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in __btrfs_free_extra_devids()
1115 fs_devices->rw_devices--; in __btrfs_free_extra_devids()
1117 list_del_init(&device->dev_list); in __btrfs_free_extra_devids()
1118 fs_devices->num_devices--; in __btrfs_free_extra_devids()
1125 * After we have read the system tree and know devids belonging to this
1136 list_for_each_entry(seed_dev, &fs_devices->seed_list, seed_list) in btrfs_free_extra_devids()
1139 fs_devices->latest_dev = latest_dev; in btrfs_free_extra_devids()
1146 if (!device->bdev) in btrfs_close_bdev()
1149 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_close_bdev()
1150 sync_blockdev(device->bdev); in btrfs_close_bdev()
1151 invalidate_bdev(device->bdev); in btrfs_close_bdev()
1154 blkdev_put(device->bdev, device->holder); in btrfs_close_bdev()
1159 struct btrfs_fs_devices *fs_devices = device->fs_devices; in btrfs_close_one_device()
1161 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_close_one_device()
1162 device->devid != BTRFS_DEV_REPLACE_DEVID) { in btrfs_close_one_device()
1163 list_del_init(&device->dev_alloc_list); in btrfs_close_one_device()
1164 fs_devices->rw_devices--; in btrfs_close_one_device()
1167 if (device->devid == BTRFS_DEV_REPLACE_DEVID) in btrfs_close_one_device()
1168 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in btrfs_close_one_device()
1170 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in btrfs_close_one_device()
1171 clear_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in btrfs_close_one_device()
1172 fs_devices->missing_devices--; in btrfs_close_one_device()
1176 if (device->bdev) { in btrfs_close_one_device()
1177 fs_devices->open_devices--; in btrfs_close_one_device()
1178 device->bdev = NULL; in btrfs_close_one_device()
1180 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_close_one_device()
1183 device->fs_info = NULL; in btrfs_close_one_device()
1184 atomic_set(&device->dev_stats_ccnt, 0); in btrfs_close_one_device()
1185 extent_io_tree_release(&device->alloc_state); in btrfs_close_one_device()
1193 * (btrfs_check_rw_degradable() should not fail) - if after mounting the in btrfs_close_one_device()
1198 device->last_flush_error = 0; in btrfs_close_one_device()
1201 WARN_ON(test_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state)); in btrfs_close_one_device()
1202 WARN_ON(test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)); in btrfs_close_one_device()
1203 WARN_ON(!list_empty(&device->dev_alloc_list)); in btrfs_close_one_device()
1204 WARN_ON(!list_empty(&device->post_commit_list)); in btrfs_close_one_device()
1213 if (--fs_devices->opened > 0) in close_fs_devices()
1216 list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list) in close_fs_devices()
1219 WARN_ON(fs_devices->open_devices); in close_fs_devices()
1220 WARN_ON(fs_devices->rw_devices); in close_fs_devices()
1221 fs_devices->opened = 0; in close_fs_devices()
1222 fs_devices->seeding = false; in close_fs_devices()
1223 fs_devices->fs_info = NULL; in close_fs_devices()
1233 if (!fs_devices->opened) { in btrfs_close_devices()
1234 list_splice_init(&fs_devices->seed_list, &list); in btrfs_close_devices()
1238 * other device, it can be re-initialized during the next mount in btrfs_close_devices()
1239 * without the needing device-scan step. Therefore, it can be in btrfs_close_devices()
1242 if (fs_devices->num_devices == 1) { in btrfs_close_devices()
1243 list_del(&fs_devices->fs_list); in btrfs_close_devices()
1251 list_del(&fs_devices->seed_list); in btrfs_close_devices()
1265 list_for_each_entry_safe(device, tmp_device, &fs_devices->devices, in open_fs_devices()
1271 (!latest_dev || device->generation > latest_dev->generation)) { in open_fs_devices()
1273 } else if (ret2 == -ENODATA) { in open_fs_devices()
1274 fs_devices->num_devices--; in open_fs_devices()
1275 list_del(&device->dev_list); in open_fs_devices()
1282 if (fs_devices->open_devices == 0) { in open_fs_devices()
1285 return -EINVAL; in open_fs_devices()
1288 fs_devices->opened = 1; in open_fs_devices()
1289 fs_devices->latest_dev = latest_dev; in open_fs_devices()
1290 fs_devices->total_rw_bytes = 0; in open_fs_devices()
1291 fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_REGULAR; in open_fs_devices()
1292 fs_devices->read_policy = BTRFS_READ_POLICY_PID; in open_fs_devices()
1305 if (dev1->devid < dev2->devid) in devid_cmp()
1306 return -1; in devid_cmp()
1307 else if (dev1->devid > dev2->devid) in devid_cmp()
1326 if (fs_devices->opened) { in btrfs_open_devices()
1327 fs_devices->opened++; in btrfs_open_devices()
1330 list_sort(NULL, &fs_devices->devices, devid_cmp); in btrfs_open_devices()
1354 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1358 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1362 if ((bytenr + sizeof(*disk_super) - 1) >> PAGE_SHIFT != index) in btrfs_read_disk_super()
1363 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1366 page = read_cache_page_gfp(bdev->bd_inode->i_mapping, index, GFP_KERNEL); in btrfs_read_disk_super()
1379 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1382 if (disk_super->label[0] && disk_super->label[BTRFS_LABEL_SIZE - 1]) in btrfs_read_disk_super()
1383 disk_super->label[BTRFS_LABEL_SIZE - 1] = 0; in btrfs_read_disk_super()
1423 * Avoid an exclusive open here, as the systemd-udev may initiate the in btrfs_scan_one_device()
1451 btrfs_free_stale_devices(device->devt, device); in btrfs_scan_one_device()
1470 lockdep_assert_held(&device->fs_info->chunk_mutex); in contains_pending_extent()
1472 if (find_first_extent_bit(&device->alloc_state, *start, in contains_pending_extent()
1478 physical_end + 1 - physical_start)) { in contains_pending_extent()
1488 switch (device->fs_devices->chunk_alloc_policy) { in dev_extent_search_start()
1507 u64 zone_size = device->zone_info->zone_size; in dev_extent_hole_check_zoned()
1519 *hole_size = *hole_start + *hole_size - pos; in dev_extent_hole_check_zoned()
1533 if (ret == -ERANGE) { in dev_extent_hole_check_zoned()
1540 *hole_size -= zone_size; in dev_extent_hole_check_zoned()
1571 *hole_size = hole_end - *hole_start; in dev_extent_hole_check()
1577 switch (device->fs_devices->chunk_alloc_policy) { in dev_extent_hole_check()
1632 struct btrfs_fs_info *fs_info = device->fs_info; in find_free_dev_extent()
1633 struct btrfs_root *root = fs_info->dev_root; in find_free_dev_extent()
1642 u64 search_end = device->total_bytes; in find_free_dev_extent()
1650 WARN_ON(device->zone_info && in find_free_dev_extent()
1651 !IS_ALIGNED(num_bytes, device->zone_info->zone_size)); in find_free_dev_extent()
1655 ret = -ENOMEM; in find_free_dev_extent()
1660 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in find_free_dev_extent()
1661 ret = -ENOSPC; in find_free_dev_extent()
1665 path->reada = READA_FORWARD; in find_free_dev_extent()
1666 path->search_commit_root = 1; in find_free_dev_extent()
1667 path->skip_locking = 1; in find_free_dev_extent()
1669 key.objectid = device->devid; in find_free_dev_extent()
1678 l = path->nodes[0]; in find_free_dev_extent()
1679 slot = path->slots[0]; in find_free_dev_extent()
1691 if (key.objectid < device->devid) in find_free_dev_extent()
1694 if (key.objectid > device->devid) in find_free_dev_extent()
1704 hole_size = key.offset - search_start; in find_free_dev_extent()
1734 path->slots[0]++; in find_free_dev_extent()
1744 hole_size = search_end - search_start; in find_free_dev_extent()
1759 ret = -ENOSPC; in find_free_dev_extent()
1776 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_free_dev_extent()
1777 struct btrfs_root *root = fs_info->dev_root; in btrfs_free_dev_extent()
1787 return -ENOMEM; in btrfs_free_dev_extent()
1789 key.objectid = device->devid; in btrfs_free_dev_extent()
1793 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_free_dev_extent()
1799 leaf = path->nodes[0]; in btrfs_free_dev_extent()
1800 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_free_dev_extent()
1801 extent = btrfs_item_ptr(leaf, path->slots[0], in btrfs_free_dev_extent()
1809 leaf = path->nodes[0]; in btrfs_free_dev_extent()
1810 extent = btrfs_item_ptr(leaf, path->slots[0], in btrfs_free_dev_extent()
1820 set_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags); in btrfs_free_dev_extent()
1833 em_tree = &fs_info->mapping_tree; in find_next_chunk()
1834 read_lock(&em_tree->lock); in find_next_chunk()
1835 n = rb_last(&em_tree->map.rb_root); in find_next_chunk()
1838 ret = em->start + em->len; in find_next_chunk()
1840 read_unlock(&em_tree->lock); in find_next_chunk()
1855 return -ENOMEM; in find_next_devid()
1859 key.offset = (u64)-1; in find_next_devid()
1861 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0); in find_next_devid()
1867 btrfs_err(fs_info, "corrupted chunk tree devid -1 matched"); in find_next_devid()
1868 ret = -EUCLEAN; in find_next_devid()
1872 ret = btrfs_previous_item(fs_info->chunk_root, path, in find_next_devid()
1878 btrfs_item_key_to_cpu(path->nodes[0], &found_key, in find_next_devid()
1879 path->slots[0]); in find_next_devid()
1904 return -ENOMEM; in btrfs_add_dev_item()
1908 key.offset = device->devid; in btrfs_add_dev_item()
1911 ret = btrfs_insert_empty_item(trans, trans->fs_info->chunk_root, path, in btrfs_add_dev_item()
1917 leaf = path->nodes[0]; in btrfs_add_dev_item()
1918 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); in btrfs_add_dev_item()
1920 btrfs_set_device_id(leaf, dev_item, device->devid); in btrfs_add_dev_item()
1922 btrfs_set_device_type(leaf, dev_item, device->type); in btrfs_add_dev_item()
1923 btrfs_set_device_io_align(leaf, dev_item, device->io_align); in btrfs_add_dev_item()
1924 btrfs_set_device_io_width(leaf, dev_item, device->io_width); in btrfs_add_dev_item()
1925 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size); in btrfs_add_dev_item()
1936 write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); in btrfs_add_dev_item()
1938 write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid, in btrfs_add_dev_item()
1970 struct btrfs_root *root = device->fs_info->chunk_root; in btrfs_rm_dev_item()
1977 return -ENOMEM; in btrfs_rm_dev_item()
1981 key.offset = device->devid; in btrfs_rm_dev_item()
1984 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_rm_dev_item()
1988 ret = -ENOENT; in btrfs_rm_dev_item()
2011 seq = read_seqbegin(&fs_info->profiles_lock); in btrfs_check_raid_min_devices()
2013 all_avail = fs_info->avail_data_alloc_bits | in btrfs_check_raid_min_devices()
2014 fs_info->avail_system_alloc_bits | in btrfs_check_raid_min_devices()
2015 fs_info->avail_metadata_alloc_bits; in btrfs_check_raid_min_devices()
2016 } while (read_seqretry(&fs_info->profiles_lock, seq)); in btrfs_check_raid_min_devices()
2034 list_for_each_entry(next_device, &fs_devs->devices, dev_list) { in btrfs_find_next_active_device()
2036 !test_bit(BTRFS_DEV_STATE_MISSING, &next_device->dev_state) in btrfs_find_next_active_device()
2037 && next_device->bdev) in btrfs_find_next_active_device()
2053 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_assign_next_active_device()
2056 next_device = btrfs_find_next_active_device(fs_info->fs_devices, in btrfs_assign_next_active_device()
2060 if (fs_info->sb->s_bdev && in btrfs_assign_next_active_device()
2061 (fs_info->sb->s_bdev == device->bdev)) in btrfs_assign_next_active_device()
2062 fs_info->sb->s_bdev = next_device->bdev; in btrfs_assign_next_active_device()
2064 if (fs_info->fs_devices->latest_dev->bdev == device->bdev) in btrfs_assign_next_active_device()
2065 fs_info->fs_devices->latest_dev = next_device; in btrfs_assign_next_active_device()
2074 u64 num_devices = fs_info->fs_devices->num_devices; in btrfs_num_devices()
2076 down_read(&fs_info->dev_replace.rwsem); in btrfs_num_devices()
2077 if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) { in btrfs_num_devices()
2079 num_devices--; in btrfs_num_devices()
2081 up_read(&fs_info->dev_replace.rwsem); in btrfs_num_devices()
2090 const size_t len = sizeof(disk_super->magic); in btrfs_scratch_superblock()
2098 memset(&disk_super->magic, 0, len); in btrfs_scratch_superblock()
2102 ret = sync_blockdev_range(bdev, bytenr, bytenr + len - 1); in btrfs_scratch_superblock()
2138 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_rm_device()
2144 return -EINVAL; in btrfs_rm_device()
2154 ret = btrfs_check_raid_min_devices(fs_info, num_devices - 1); in btrfs_rm_device()
2158 device = btrfs_find_device(fs_info->fs_devices, args); in btrfs_rm_device()
2160 if (args->missing) in btrfs_rm_device()
2163 ret = -ENOENT; in btrfs_rm_device()
2170 btrfs_dev_name(device), device->devid); in btrfs_rm_device()
2171 return -ETXTBSY; in btrfs_rm_device()
2174 if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) in btrfs_rm_device()
2177 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_rm_device()
2178 fs_info->fs_devices->rw_devices == 1) in btrfs_rm_device()
2181 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_rm_device()
2182 mutex_lock(&fs_info->chunk_mutex); in btrfs_rm_device()
2183 list_del_init(&device->dev_alloc_list); in btrfs_rm_device()
2184 device->fs_devices->rw_devices--; in btrfs_rm_device()
2185 mutex_unlock(&fs_info->chunk_mutex); in btrfs_rm_device()
2192 trans = btrfs_start_transaction(fs_info->chunk_root, 0); in btrfs_rm_device()
2203 device->devid, ret); in btrfs_rm_device()
2209 clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_rm_device()
2225 * its own fs_devices listed under the fs_devices->seed_list. in btrfs_rm_device()
2227 cur_devices = device->fs_devices; in btrfs_rm_device()
2228 mutex_lock(&fs_devices->device_list_mutex); in btrfs_rm_device()
2229 list_del_rcu(&device->dev_list); in btrfs_rm_device()
2231 cur_devices->num_devices--; in btrfs_rm_device()
2232 cur_devices->total_devices--; in btrfs_rm_device()
2235 fs_devices->total_devices--; in btrfs_rm_device()
2237 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) in btrfs_rm_device()
2238 cur_devices->missing_devices--; in btrfs_rm_device()
2242 if (device->bdev) { in btrfs_rm_device()
2243 cur_devices->open_devices--; in btrfs_rm_device()
2248 num_devices = btrfs_super_num_devices(fs_info->super_copy) - 1; in btrfs_rm_device()
2249 btrfs_set_super_num_devices(fs_info->super_copy, num_devices); in btrfs_rm_device()
2250 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_rm_device()
2258 * write lock, and blkdev_put() will pull in the ->open_mutex on the in btrfs_rm_device()
2262 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_rm_device()
2263 btrfs_scratch_superblocks(fs_info, device->bdev, in btrfs_rm_device()
2264 device->name->str); in btrfs_rm_device()
2265 if (device->bdev) { in btrfs_rm_device()
2266 sync_blockdev(device->bdev); in btrfs_rm_device()
2267 invalidate_bdev(device->bdev); in btrfs_rm_device()
2271 *bdev = device->bdev; in btrfs_rm_device()
2272 *holder = device->holder; in btrfs_rm_device()
2280 * seed_devices, we can simply decrement cur_devices->opened and then in btrfs_rm_device()
2283 if (cur_devices->num_devices == 0) { in btrfs_rm_device()
2284 list_del_init(&cur_devices->seed_list); in btrfs_rm_device()
2285 ASSERT(cur_devices->opened == 1); in btrfs_rm_device()
2286 cur_devices->opened--; in btrfs_rm_device()
2295 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_rm_device()
2296 mutex_lock(&fs_info->chunk_mutex); in btrfs_rm_device()
2297 list_add(&device->dev_alloc_list, in btrfs_rm_device()
2298 &fs_devices->alloc_list); in btrfs_rm_device()
2299 device->fs_devices->rw_devices++; in btrfs_rm_device()
2300 mutex_unlock(&fs_info->chunk_mutex); in btrfs_rm_device()
2309 lockdep_assert_held(&srcdev->fs_info->fs_devices->device_list_mutex); in btrfs_rm_dev_replace_remove_srcdev()
2312 * in case of fs with no seed, srcdev->fs_devices will point in btrfs_rm_dev_replace_remove_srcdev()
2317 fs_devices = srcdev->fs_devices; in btrfs_rm_dev_replace_remove_srcdev()
2319 list_del_rcu(&srcdev->dev_list); in btrfs_rm_dev_replace_remove_srcdev()
2320 list_del(&srcdev->dev_alloc_list); in btrfs_rm_dev_replace_remove_srcdev()
2321 fs_devices->num_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2322 if (test_bit(BTRFS_DEV_STATE_MISSING, &srcdev->dev_state)) in btrfs_rm_dev_replace_remove_srcdev()
2323 fs_devices->missing_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2325 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &srcdev->dev_state)) in btrfs_rm_dev_replace_remove_srcdev()
2326 fs_devices->rw_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2328 if (srcdev->bdev) in btrfs_rm_dev_replace_remove_srcdev()
2329 fs_devices->open_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2334 struct btrfs_fs_devices *fs_devices = srcdev->fs_devices; in btrfs_rm_dev_replace_free_srcdev()
2343 if (!fs_devices->num_devices) { in btrfs_rm_dev_replace_free_srcdev()
2350 ASSERT(fs_devices->seeding); in btrfs_rm_dev_replace_free_srcdev()
2352 list_del_init(&fs_devices->seed_list); in btrfs_rm_dev_replace_free_srcdev()
2361 struct btrfs_fs_devices *fs_devices = tgtdev->fs_info->fs_devices; in btrfs_destroy_dev_replace_tgtdev()
2363 mutex_lock(&fs_devices->device_list_mutex); in btrfs_destroy_dev_replace_tgtdev()
2367 if (tgtdev->bdev) in btrfs_destroy_dev_replace_tgtdev()
2368 fs_devices->open_devices--; in btrfs_destroy_dev_replace_tgtdev()
2370 fs_devices->num_devices--; in btrfs_destroy_dev_replace_tgtdev()
2374 list_del_rcu(&tgtdev->dev_list); in btrfs_destroy_dev_replace_tgtdev()
2376 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_destroy_dev_replace_tgtdev()
2378 btrfs_scratch_superblocks(tgtdev->fs_info, tgtdev->bdev, in btrfs_destroy_dev_replace_tgtdev()
2379 tgtdev->name->str); in btrfs_destroy_dev_replace_tgtdev()
2402 * Return: 0 for success, -errno for failure
2413 return -EINVAL; in btrfs_get_dev_args_from_path()
2415 args->missing = true; in btrfs_get_dev_args_from_path()
2419 args->uuid = kzalloc(BTRFS_UUID_SIZE, GFP_KERNEL); in btrfs_get_dev_args_from_path()
2420 args->fsid = kzalloc(BTRFS_FSID_SIZE, GFP_KERNEL); in btrfs_get_dev_args_from_path()
2421 if (!args->uuid || !args->fsid) { in btrfs_get_dev_args_from_path()
2423 return -ENOMEM; in btrfs_get_dev_args_from_path()
2433 args->devid = btrfs_stack_device_id(&disk_super->dev_item); in btrfs_get_dev_args_from_path()
2434 memcpy(args->uuid, disk_super->dev_item.uuid, BTRFS_UUID_SIZE); in btrfs_get_dev_args_from_path()
2436 memcpy(args->fsid, disk_super->metadata_uuid, BTRFS_FSID_SIZE); in btrfs_get_dev_args_from_path()
2438 memcpy(args->fsid, disk_super->fsid, BTRFS_FSID_SIZE); in btrfs_get_dev_args_from_path()
2446 * allocate our ->uuid and ->fsid pointers, everybody else uses local variables
2451 kfree(args->uuid); in btrfs_put_dev_args_from_path()
2452 kfree(args->fsid); in btrfs_put_dev_args_from_path()
2453 args->uuid = NULL; in btrfs_put_dev_args_from_path()
2454 args->fsid = NULL; in btrfs_put_dev_args_from_path()
2467 device = btrfs_find_device(fs_info->fs_devices, &args); in btrfs_find_device_by_devspec()
2469 return ERR_PTR(-ENOENT); in btrfs_find_device_by_devspec()
2476 device = btrfs_find_device(fs_info->fs_devices, &args); in btrfs_find_device_by_devspec()
2479 return ERR_PTR(-ENOENT); in btrfs_find_device_by_devspec()
2485 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_init_sprout()
2490 if (!fs_devices->seeding) in btrfs_init_sprout()
2491 return ERR_PTR(-EINVAL); in btrfs_init_sprout()
2495 * fs_info->fs_devices->seed_list in btrfs_init_sprout()
2513 list_add(&old_devices->fs_list, &fs_uuids); in btrfs_init_sprout()
2516 seed_devices->opened = 1; in btrfs_init_sprout()
2517 INIT_LIST_HEAD(&seed_devices->devices); in btrfs_init_sprout()
2518 INIT_LIST_HEAD(&seed_devices->alloc_list); in btrfs_init_sprout()
2519 mutex_init(&seed_devices->device_list_mutex); in btrfs_init_sprout()
2526 * Generate a new fsid for the sprouted read-write filesystem.
2531 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_setup_sprout()
2532 struct btrfs_super_block *disk_super = fs_info->super_copy; in btrfs_setup_sprout()
2545 * - All device ops and balance - as we are in btrfs_exclop_start. in btrfs_setup_sprout()
2546 * - Various dev_list readers - are using RCU. in btrfs_setup_sprout()
2547 * - btrfs_ioctl_fitrim() - is using RCU. in btrfs_setup_sprout()
2549 * For-read threads as below are using device_list_mutex: in btrfs_setup_sprout()
2550 * - Readonly scrub btrfs_scrub_dev() in btrfs_setup_sprout()
2551 * - Readonly scrub btrfs_scrub_progress() in btrfs_setup_sprout()
2552 * - btrfs_get_dev_stats() in btrfs_setup_sprout()
2554 lockdep_assert_held(&fs_devices->device_list_mutex); in btrfs_setup_sprout()
2556 list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices, in btrfs_setup_sprout()
2558 list_for_each_entry(device, &seed_devices->devices, dev_list) in btrfs_setup_sprout()
2559 device->fs_devices = seed_devices; in btrfs_setup_sprout()
2561 fs_devices->seeding = false; in btrfs_setup_sprout()
2562 fs_devices->num_devices = 0; in btrfs_setup_sprout()
2563 fs_devices->open_devices = 0; in btrfs_setup_sprout()
2564 fs_devices->missing_devices = 0; in btrfs_setup_sprout()
2565 fs_devices->rotating = false; in btrfs_setup_sprout()
2566 list_add(&seed_devices->seed_list, &fs_devices->seed_list); in btrfs_setup_sprout()
2568 generate_random_uuid(fs_devices->fsid); in btrfs_setup_sprout()
2569 memcpy(fs_devices->metadata_uuid, fs_devices->fsid, BTRFS_FSID_SIZE); in btrfs_setup_sprout()
2570 memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE); in btrfs_setup_sprout()
2583 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_finish_sprout()
2584 struct btrfs_root *root = fs_info->chunk_root; in btrfs_finish_sprout()
2596 return -ENOMEM; in btrfs_finish_sprout()
2609 leaf = path->nodes[0]; in btrfs_finish_sprout()
2611 if (path->slots[0] >= btrfs_header_nritems(leaf)) { in btrfs_finish_sprout()
2617 leaf = path->nodes[0]; in btrfs_finish_sprout()
2618 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_finish_sprout()
2623 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_finish_sprout()
2628 dev_item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_finish_sprout()
2637 device = btrfs_find_device(fs_info->fs_devices, &args); in btrfs_finish_sprout()
2640 if (device->fs_devices->seeding) { in btrfs_finish_sprout()
2642 device->generation); in btrfs_finish_sprout()
2646 path->slots[0]++; in btrfs_finish_sprout()
2657 struct btrfs_root *root = fs_info->dev_root; in btrfs_init_new_device()
2661 struct super_block *sb = fs_info->sb; in btrfs_init_new_device()
2662 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_init_new_device()
2670 if (sb_rdonly(sb) && !fs_devices->seeding) in btrfs_init_new_device()
2671 return -EROFS; in btrfs_init_new_device()
2674 fs_info->bdev_holder, NULL); in btrfs_init_new_device()
2679 ret = -EINVAL; in btrfs_init_new_device()
2683 if (fs_devices->seeding) { in btrfs_init_new_device()
2685 down_write(&sb->s_umount); in btrfs_init_new_device()
2693 list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) { in btrfs_init_new_device()
2694 if (device->bdev == bdev) { in btrfs_init_new_device()
2695 ret = -EEXIST; in btrfs_init_new_device()
2709 device->fs_info = fs_info; in btrfs_init_new_device()
2710 device->bdev = bdev; in btrfs_init_new_device()
2711 ret = lookup_bdev(device_path, &device->devt); in btrfs_init_new_device()
2725 set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_init_new_device()
2726 device->generation = trans->transid; in btrfs_init_new_device()
2727 device->io_width = fs_info->sectorsize; in btrfs_init_new_device()
2728 device->io_align = fs_info->sectorsize; in btrfs_init_new_device()
2729 device->sector_size = fs_info->sectorsize; in btrfs_init_new_device()
2730 device->total_bytes = in btrfs_init_new_device()
2731 round_down(bdev_nr_bytes(bdev), fs_info->sectorsize); in btrfs_init_new_device()
2732 device->disk_total_bytes = device->total_bytes; in btrfs_init_new_device()
2733 device->commit_total_bytes = device->total_bytes; in btrfs_init_new_device()
2734 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_init_new_device()
2735 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in btrfs_init_new_device()
2736 device->holder = fs_info->bdev_holder; in btrfs_init_new_device()
2737 device->dev_stats_valid = 1; in btrfs_init_new_device()
2738 set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE); in btrfs_init_new_device()
2750 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_new_device()
2753 btrfs_assign_next_active_device(fs_info->fs_devices->latest_dev, in btrfs_init_new_device()
2757 device->fs_devices = fs_devices; in btrfs_init_new_device()
2759 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2760 list_add_rcu(&device->dev_list, &fs_devices->devices); in btrfs_init_new_device()
2761 list_add(&device->dev_alloc_list, &fs_devices->alloc_list); in btrfs_init_new_device()
2762 fs_devices->num_devices++; in btrfs_init_new_device()
2763 fs_devices->open_devices++; in btrfs_init_new_device()
2764 fs_devices->rw_devices++; in btrfs_init_new_device()
2765 fs_devices->total_devices++; in btrfs_init_new_device()
2766 fs_devices->total_rw_bytes += device->total_bytes; in btrfs_init_new_device()
2768 atomic64_add(device->total_bytes, &fs_info->free_chunk_space); in btrfs_init_new_device()
2771 fs_devices->rotating = true; in btrfs_init_new_device()
2773 orig_super_total_bytes = btrfs_super_total_bytes(fs_info->super_copy); in btrfs_init_new_device()
2774 btrfs_set_super_total_bytes(fs_info->super_copy, in btrfs_init_new_device()
2775 round_down(orig_super_total_bytes + device->total_bytes, in btrfs_init_new_device()
2776 fs_info->sectorsize)); in btrfs_init_new_device()
2778 orig_super_num_devices = btrfs_super_num_devices(fs_info->super_copy); in btrfs_init_new_device()
2779 btrfs_set_super_num_devices(fs_info->super_copy, in btrfs_init_new_device()
2788 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2793 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_new_device()
2796 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2798 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2829 up_write(&sb->s_umount); in btrfs_init_new_device()
2841 if (PTR_ERR(trans) == -ENOENT) in btrfs_init_new_device()
2854 * We can ignore the return value as it typically returns -EINVAL and in btrfs_init_new_device()
2857 btrfs_forget_devices(device->devt); in btrfs_init_new_device()
2866 mutex_lock(&fs_info->fs_devices->device_list_mutex); in btrfs_init_new_device()
2867 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2868 list_del_rcu(&device->dev_list); in btrfs_init_new_device()
2869 list_del(&device->dev_alloc_list); in btrfs_init_new_device()
2870 fs_info->fs_devices->num_devices--; in btrfs_init_new_device()
2871 fs_info->fs_devices->open_devices--; in btrfs_init_new_device()
2872 fs_info->fs_devices->rw_devices--; in btrfs_init_new_device()
2873 fs_info->fs_devices->total_devices--; in btrfs_init_new_device()
2874 fs_info->fs_devices->total_rw_bytes -= device->total_bytes; in btrfs_init_new_device()
2875 atomic64_sub(device->total_bytes, &fs_info->free_chunk_space); in btrfs_init_new_device()
2876 btrfs_set_super_total_bytes(fs_info->super_copy, in btrfs_init_new_device()
2878 btrfs_set_super_num_devices(fs_info->super_copy, in btrfs_init_new_device()
2880 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2881 mutex_unlock(&fs_info->fs_devices->device_list_mutex); in btrfs_init_new_device()
2890 blkdev_put(bdev, fs_info->bdev_holder); in btrfs_init_new_device()
2893 up_write(&sb->s_umount); in btrfs_init_new_device()
2903 struct btrfs_root *root = device->fs_info->chunk_root; in btrfs_update_device()
2910 return -ENOMEM; in btrfs_update_device()
2914 key.offset = device->devid; in btrfs_update_device()
2921 ret = -ENOENT; in btrfs_update_device()
2925 leaf = path->nodes[0]; in btrfs_update_device()
2926 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); in btrfs_update_device()
2928 btrfs_set_device_id(leaf, dev_item, device->devid); in btrfs_update_device()
2929 btrfs_set_device_type(leaf, dev_item, device->type); in btrfs_update_device()
2930 btrfs_set_device_io_align(leaf, dev_item, device->io_align); in btrfs_update_device()
2931 btrfs_set_device_io_width(leaf, dev_item, device->io_width); in btrfs_update_device()
2932 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size); in btrfs_update_device()
2947 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_grow_device()
2948 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_grow_device()
2953 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) in btrfs_grow_device()
2954 return -EACCES; in btrfs_grow_device()
2956 new_size = round_down(new_size, fs_info->sectorsize); in btrfs_grow_device()
2958 mutex_lock(&fs_info->chunk_mutex); in btrfs_grow_device()
2960 diff = round_down(new_size - device->total_bytes, fs_info->sectorsize); in btrfs_grow_device()
2962 if (new_size <= device->total_bytes || in btrfs_grow_device()
2963 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in btrfs_grow_device()
2964 mutex_unlock(&fs_info->chunk_mutex); in btrfs_grow_device()
2965 return -EINVAL; in btrfs_grow_device()
2969 round_down(old_total + diff, fs_info->sectorsize)); in btrfs_grow_device()
2970 device->fs_devices->total_rw_bytes += diff; in btrfs_grow_device()
2974 btrfs_clear_space_info_full(device->fs_info); in btrfs_grow_device()
2975 if (list_empty(&device->post_commit_list)) in btrfs_grow_device()
2976 list_add_tail(&device->post_commit_list, in btrfs_grow_device()
2977 &trans->transaction->dev_update_list); in btrfs_grow_device()
2978 mutex_unlock(&fs_info->chunk_mutex); in btrfs_grow_device()
2989 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_free_chunk()
2990 struct btrfs_root *root = fs_info->chunk_root; in btrfs_free_chunk()
2997 return -ENOMEM; in btrfs_free_chunk()
3003 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_free_chunk()
3007 btrfs_handle_fs_error(fs_info, -ENOENT, in btrfs_free_chunk()
3009 ret = -ENOENT; in btrfs_free_chunk()
3024 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_del_sys_chunk()
3035 lockdep_assert_held(&fs_info->chunk_mutex); in btrfs_del_sys_chunk()
3038 ptr = super_copy->sys_chunk_array; in btrfs_del_sys_chunk()
3052 ret = -EIO; in btrfs_del_sys_chunk()
3057 memmove(ptr, ptr + len, array_size - (cur + len)); in btrfs_del_sys_chunk()
3058 array_size -= len; in btrfs_del_sys_chunk()
3069 * btrfs_get_chunk_map() - Find the mapping containing the given logical extent.
3081 em_tree = &fs_info->mapping_tree; in btrfs_get_chunk_map()
3082 read_lock(&em_tree->lock); in btrfs_get_chunk_map()
3084 read_unlock(&em_tree->lock); in btrfs_get_chunk_map()
3090 return ERR_PTR(-EINVAL); in btrfs_get_chunk_map()
3093 if (em->start > logical || em->start + em->len <= logical) { in btrfs_get_chunk_map()
3095 "found a bad chunk map, wanted %llu-%llu, found %llu-%llu", in btrfs_get_chunk_map()
3096 logical, logical + length, em->start, em->start + em->len); in btrfs_get_chunk_map()
3098 return ERR_PTR(-EINVAL); in btrfs_get_chunk_map()
3115 lockdep_assert_held(&trans->fs_info->chunk_mutex); in remove_chunk_item()
3117 for (i = 0; i < map->num_stripes; i++) { in remove_chunk_item()
3120 ret = btrfs_update_device(trans, map->stripes[i].dev); in remove_chunk_item()
3130 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_remove_chunk()
3135 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_remove_chunk()
3147 map = em->map_lookup; in btrfs_remove_chunk()
3153 * fs_info->chunk_mutex. Note that here we do not acquire the chunk_mutex in btrfs_remove_chunk()
3155 * items from the devices btree - COWing an extent buffer from the btree in btrfs_remove_chunk()
3157 * lock again fs_info->chunk_mutex. in btrfs_remove_chunk()
3159 mutex_lock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3160 for (i = 0; i < map->num_stripes; i++) { in btrfs_remove_chunk()
3161 struct btrfs_device *device = map->stripes[i].dev; in btrfs_remove_chunk()
3163 map->stripes[i].physical, in btrfs_remove_chunk()
3166 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3171 if (device->bytes_used > 0) { in btrfs_remove_chunk()
3172 mutex_lock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3174 device->bytes_used - dev_extent_len); in btrfs_remove_chunk()
3175 atomic64_add(dev_extent_len, &fs_info->free_chunk_space); in btrfs_remove_chunk()
3177 mutex_unlock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3180 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3183 * We acquire fs_info->chunk_mutex for 2 reasons: in btrfs_remove_chunk()
3186 * reserve system space, do all chunk btree updates and deletions, and in btrfs_remove_chunk()
3187 * update the system chunk array in the superblock while holding this in btrfs_remove_chunk()
3195 * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the in btrfs_remove_chunk()
3203 trans->removing_chunk = true; in btrfs_remove_chunk()
3204 mutex_lock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3206 check_system_chunk(trans, map->type); in btrfs_remove_chunk()
3210 * Normally we should not get -ENOSPC since we reserved space before in btrfs_remove_chunk()
3213 * Despite our system space_info having enough free space, we may not in btrfs_remove_chunk()
3215 * an incompatible profile, which will force us to allocate a new system in btrfs_remove_chunk()
3217 * check_system_space() above, a scrub turned the only system block group in btrfs_remove_chunk()
3221 * So if we get -ENOSPC, allocate a new system chunk and retry once. in btrfs_remove_chunk()
3223 if (ret == -ENOSPC) { in btrfs_remove_chunk()
3250 trace_btrfs_chunk_free(fs_info, map, chunk_offset, em->len); in btrfs_remove_chunk()
3252 if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) { in btrfs_remove_chunk()
3260 mutex_unlock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3261 trans->removing_chunk = false; in btrfs_remove_chunk()
3265 * system space we previously reserved (with check_system_chunk()). in btrfs_remove_chunk()
3276 if (trans->removing_chunk) { in btrfs_remove_chunk()
3277 mutex_unlock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3278 trans->removing_chunk = false; in btrfs_remove_chunk()
3287 struct btrfs_root *root = fs_info->chunk_root; in btrfs_relocate_chunk()
3296 return -EINVAL; in btrfs_relocate_chunk()
3311 lockdep_assert_held(&fs_info->reclaim_bgs_lock); in btrfs_relocate_chunk()
3329 return -ENOENT; in btrfs_relocate_chunk()
3330 btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group); in btrfs_relocate_chunk()
3331 length = block_group->length; in btrfs_relocate_chunk()
3335 * On a zoned file system, discard the whole block group, this will in btrfs_relocate_chunk()
3348 trans = btrfs_start_trans_remove_block_group(root->fs_info, in btrfs_relocate_chunk()
3352 btrfs_handle_fs_error(root->fs_info, ret, NULL); in btrfs_relocate_chunk()
3367 struct btrfs_root *chunk_root = fs_info->chunk_root; in btrfs_relocate_sys_chunks()
3380 return -ENOMEM; in btrfs_relocate_sys_chunks()
3384 key.offset = (u64)-1; in btrfs_relocate_sys_chunks()
3388 mutex_lock(&fs_info->reclaim_bgs_lock); in btrfs_relocate_sys_chunks()
3391 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_relocate_sys_chunks()
3397 * offset -1, which is not possible. On subsequent in btrfs_relocate_sys_chunks()
3402 ret = -EUCLEAN; in btrfs_relocate_sys_chunks()
3403 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_relocate_sys_chunks()
3410 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_relocate_sys_chunks()
3416 leaf = path->nodes[0]; in btrfs_relocate_sys_chunks()
3417 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_relocate_sys_chunks()
3419 chunk = btrfs_item_ptr(leaf, path->slots[0], in btrfs_relocate_sys_chunks()
3426 if (ret == -ENOSPC) in btrfs_relocate_sys_chunks()
3431 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_relocate_sys_chunks()
3435 key.offset = found_key.offset - 1; in btrfs_relocate_sys_chunks()
3443 ret = -ENOSPC; in btrfs_relocate_sys_chunks()
3464 chunk_type = cache->flags; in btrfs_may_alloc_data_chunk()
3470 spin_lock(&fs_info->data_sinfo->lock); in btrfs_may_alloc_data_chunk()
3471 bytes_used = fs_info->data_sinfo->bytes_used; in btrfs_may_alloc_data_chunk()
3472 spin_unlock(&fs_info->data_sinfo->lock); in btrfs_may_alloc_data_chunk()
3478 trans = btrfs_join_transaction(fs_info->tree_root); in btrfs_may_alloc_data_chunk()
3495 struct btrfs_root *root = fs_info->tree_root; in insert_balance_item()
3506 return -ENOMEM; in insert_balance_item()
3523 leaf = path->nodes[0]; in insert_balance_item()
3524 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item); in insert_balance_item()
3528 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->data); in insert_balance_item()
3530 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->meta); in insert_balance_item()
3532 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->sys); in insert_balance_item()
3535 btrfs_set_balance_flags(leaf, item, bctl->flags); in insert_balance_item()
3548 struct btrfs_root *root = fs_info->tree_root; in del_balance_item()
3556 return -ENOMEM; in del_balance_item()
3568 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in del_balance_item()
3572 ret = -ENOENT; in del_balance_item()
3594 if (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3595 bctl->data.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3596 if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3597 bctl->sys.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3598 if (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3599 bctl->meta.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3605 * converted - that will keep us from relocating unconverted in update_balance_args()
3608 if (!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3609 !(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3610 !(bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3611 bctl->data.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3612 bctl->data.usage = 90; in update_balance_args()
3614 if (!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3615 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3616 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3617 bctl->sys.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3618 bctl->sys.usage = 90; in update_balance_args()
3620 if (!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3621 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3622 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3623 bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3624 bctl->meta.usage = 90; in update_balance_args()
3633 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in reset_balance_state()
3636 BUG_ON(!fs_info->balance_ctl); in reset_balance_state()
3638 spin_lock(&fs_info->balance_lock); in reset_balance_state()
3639 fs_info->balance_ctl = NULL; in reset_balance_state()
3640 spin_unlock(&fs_info->balance_lock); in reset_balance_state()
3658 if (bargs->profiles & chunk_type) in chunk_profiles_filter()
3674 chunk_used = cache->used; in chunk_usage_range_filter()
3676 if (bargs->usage_min == 0) in chunk_usage_range_filter()
3679 user_thresh_min = mult_perc(cache->length, bargs->usage_min); in chunk_usage_range_filter()
3681 if (bargs->usage_max == 0) in chunk_usage_range_filter()
3683 else if (bargs->usage_max > 100) in chunk_usage_range_filter()
3684 user_thresh_max = cache->length; in chunk_usage_range_filter()
3686 user_thresh_max = mult_perc(cache->length, bargs->usage_max); in chunk_usage_range_filter()
3703 chunk_used = cache->used; in chunk_usage_filter()
3705 if (bargs->usage_min == 0) in chunk_usage_filter()
3707 else if (bargs->usage > 100) in chunk_usage_filter()
3708 user_thresh = cache->length; in chunk_usage_filter()
3710 user_thresh = mult_perc(cache->length, bargs->usage); in chunk_usage_filter()
3729 if (btrfs_stripe_devid(leaf, stripe) == bargs->devid) in chunk_devid_filter()
3742 return (num_stripes - nparity) / ncopies; in calc_data_stripes()
3758 if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID)) in chunk_drange_filter()
3766 if (btrfs_stripe_devid(leaf, stripe) != bargs->devid) in chunk_drange_filter()
3773 if (stripe_offset < bargs->pend && in chunk_drange_filter()
3774 stripe_offset + stripe_length > bargs->pstart) in chunk_drange_filter()
3787 if (chunk_offset < bargs->vend && in chunk_vrange_filter()
3788 chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart) in chunk_vrange_filter()
3801 if (bargs->stripes_min <= num_stripes in chunk_stripes_range_filter()
3802 && num_stripes <= bargs->stripes_max) in chunk_stripes_range_filter()
3811 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT)) in chunk_soft_convert_filter()
3817 if (bargs->target == chunk_type) in chunk_soft_convert_filter()
3826 struct btrfs_fs_info *fs_info = leaf->fs_info; in should_balance_chunk()
3827 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in should_balance_chunk()
3833 (bctl->flags & BTRFS_BALANCE_TYPE_MASK))) { in should_balance_chunk()
3838 bargs = &bctl->data; in should_balance_chunk()
3840 bargs = &bctl->sys; in should_balance_chunk()
3842 bargs = &bctl->meta; in should_balance_chunk()
3845 if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) && in should_balance_chunk()
3851 if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) && in should_balance_chunk()
3854 } else if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in should_balance_chunk()
3860 if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) && in should_balance_chunk()
3866 if ((bargs->flags & BTRFS_BALANCE_ARGS_DRANGE) && in should_balance_chunk()
3872 if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) && in should_balance_chunk()
3878 if ((bargs->flags & BTRFS_BALANCE_ARGS_STRIPES_RANGE) && in should_balance_chunk()
3884 if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) && in should_balance_chunk()
3892 if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT)) { in should_balance_chunk()
3893 if (bargs->limit == 0) in should_balance_chunk()
3896 bargs->limit--; in should_balance_chunk()
3897 } else if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT_RANGE)) { in should_balance_chunk()
3903 if (bargs->limit_max == 0) in should_balance_chunk()
3906 bargs->limit_max--; in should_balance_chunk()
3914 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in __btrfs_balance()
3915 struct btrfs_root *chunk_root = fs_info->chunk_root; in __btrfs_balance()
3927 u64 limit_data = bctl->data.limit; in __btrfs_balance()
3928 u64 limit_meta = bctl->meta.limit; in __btrfs_balance()
3929 u64 limit_sys = bctl->sys.limit; in __btrfs_balance()
3937 ret = -ENOMEM; in __btrfs_balance()
3942 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3943 memset(&bctl->stat, 0, sizeof(bctl->stat)); in __btrfs_balance()
3944 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3951 bctl->data.limit = limit_data; in __btrfs_balance()
3952 bctl->meta.limit = limit_meta; in __btrfs_balance()
3953 bctl->sys.limit = limit_sys; in __btrfs_balance()
3956 key.offset = (u64)-1; in __btrfs_balance()
3960 if ((!counting && atomic_read(&fs_info->balance_pause_req)) || in __btrfs_balance()
3961 atomic_read(&fs_info->balance_cancel_req)) { in __btrfs_balance()
3962 ret = -ECANCELED; in __btrfs_balance()
3966 mutex_lock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
3969 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
3983 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
3988 leaf = path->nodes[0]; in __btrfs_balance()
3989 slot = path->slots[0]; in __btrfs_balance()
3993 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
4001 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
4002 bctl->stat.considered++; in __btrfs_balance()
4003 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
4010 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
4015 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
4016 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
4017 bctl->stat.expected++; in __btrfs_balance()
4018 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
4035 count_data < bctl->data.limit_min) in __btrfs_balance()
4037 count_meta < bctl->meta.limit_min) in __btrfs_balance()
4039 count_sys < bctl->sys.limit_min)) { in __btrfs_balance()
4040 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
4054 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
4062 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
4063 if (ret == -ENOSPC) { in __btrfs_balance()
4065 } else if (ret == -ETXTBSY) { in __btrfs_balance()
4073 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
4074 bctl->stat.completed++; in __btrfs_balance()
4075 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
4080 key.offset = found_key.offset - 1; in __btrfs_balance()
4094 ret = -ENOSPC; in __btrfs_balance()
4132 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT)) in validate_convert_profile()
4136 if (alloc_profile_is_valid(bargs->target, 1) && in validate_convert_profile()
4137 (bargs->target & ~allowed) == 0) in validate_convert_profile()
4141 type, btrfs_bg_type_to_raid_name(bargs->target)); in validate_convert_profile()
4156 u64 flags = bargs->flags; in describe_balance_args()
4167 size_bp -= ret; \ in describe_balance_args()
4176 size_bp -= ret; \ in describe_balance_args()
4185 size_bp -= ret; \ in describe_balance_args()
4191 btrfs_bg_type_to_raid_name(bargs->target)); in describe_balance_args()
4197 btrfs_describe_block_groups(bargs->profiles, tmp_buf, in describe_balance_args()
4203 CHECK_APPEND_1ARG("usage=%llu,", bargs->usage); in describe_balance_args()
4207 bargs->usage_min, bargs->usage_max); in describe_balance_args()
4210 CHECK_APPEND_1ARG("devid=%llu,", bargs->devid); in describe_balance_args()
4214 bargs->pstart, bargs->pend); in describe_balance_args()
4218 bargs->vstart, bargs->vend); in describe_balance_args()
4221 CHECK_APPEND_1ARG("limit=%llu,", bargs->limit); in describe_balance_args()
4225 bargs->limit_min, bargs->limit_max); in describe_balance_args()
4229 bargs->stripes_min, bargs->stripes_max); in describe_balance_args()
4238 buf[size_buf - size_bp - 1] = '\0'; /* remove last , */ in describe_balance_args()
4251 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in describe_balance_start_or_resume()
4264 size_bp -= ret; \ in describe_balance_start_or_resume()
4268 if (bctl->flags & BTRFS_BALANCE_FORCE) in describe_balance_start_or_resume()
4269 CHECK_APPEND_1ARG("%s", "-f "); in describe_balance_start_or_resume()
4271 if (bctl->flags & BTRFS_BALANCE_DATA) { in describe_balance_start_or_resume()
4272 describe_balance_args(&bctl->data, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4273 CHECK_APPEND_1ARG("-d%s ", tmp_buf); in describe_balance_start_or_resume()
4276 if (bctl->flags & BTRFS_BALANCE_METADATA) { in describe_balance_start_or_resume()
4277 describe_balance_args(&bctl->meta, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4278 CHECK_APPEND_1ARG("-m%s ", tmp_buf); in describe_balance_start_or_resume()
4281 if (bctl->flags & BTRFS_BALANCE_SYSTEM) { in describe_balance_start_or_resume()
4282 describe_balance_args(&bctl->sys, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4283 CHECK_APPEND_1ARG("-s%s ", tmp_buf); in describe_balance_start_or_resume()
4291 buf[size_buf - size_bp - 1] = '\0'; /* remove last " " */ in describe_balance_start_or_resume()
4293 (bctl->flags & BTRFS_BALANCE_RESUME) ? in describe_balance_start_or_resume()
4317 atomic_read(&fs_info->balance_pause_req) || in btrfs_balance()
4319 ret = -EINVAL; in btrfs_balance()
4323 allowed = btrfs_super_incompat_flags(fs_info->super_copy); in btrfs_balance()
4332 if (mixed && (bctl->flags & allowed)) { in btrfs_balance()
4333 if (!(bctl->flags & BTRFS_BALANCE_DATA) || in btrfs_balance()
4334 !(bctl->flags & BTRFS_BALANCE_METADATA) || in btrfs_balance()
4335 memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) { in btrfs_balance()
4338 ret = -EINVAL; in btrfs_balance()
4347 num_devices = fs_info->fs_devices->rw_devices; in btrfs_balance()
4350 * SINGLE profile on-disk has no profile bit, but in-memory we have a in btrfs_balance()
4359 if (!validate_convert_profile(fs_info, &bctl->data, allowed, "data") || in btrfs_balance()
4360 !validate_convert_profile(fs_info, &bctl->meta, allowed, "metadata") || in btrfs_balance()
4361 !validate_convert_profile(fs_info, &bctl->sys, allowed, "system")) { in btrfs_balance()
4362 ret = -EINVAL; in btrfs_balance()
4367 * Allow to reduce metadata or system integrity only if force set for in btrfs_balance()
4377 seq = read_seqbegin(&fs_info->profiles_lock); in btrfs_balance()
4379 if (((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) && in btrfs_balance()
4380 (fs_info->avail_system_alloc_bits & allowed) && in btrfs_balance()
4381 !(bctl->sys.target & allowed)) || in btrfs_balance()
4382 ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) && in btrfs_balance()
4383 (fs_info->avail_metadata_alloc_bits & allowed) && in btrfs_balance()
4384 !(bctl->meta.target & allowed))) in btrfs_balance()
4390 meta_target = (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) ? in btrfs_balance()
4391 bctl->meta.target : fs_info->avail_metadata_alloc_bits; in btrfs_balance()
4392 data_target = (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) ? in btrfs_balance()
4393 bctl->data.target : fs_info->avail_data_alloc_bits; in btrfs_balance()
4394 } while (read_seqretry(&fs_info->profiles_lock, seq)); in btrfs_balance()
4397 if (bctl->flags & BTRFS_BALANCE_FORCE) { in btrfs_balance()
4402 "balance: reduces metadata redundancy, use --force if you want this"); in btrfs_balance()
4403 ret = -EINVAL; in btrfs_balance()
4417 if (ret && ret != -EEXIST) in btrfs_balance()
4420 if (!(bctl->flags & BTRFS_BALANCE_RESUME)) { in btrfs_balance()
4421 BUG_ON(ret == -EEXIST); in btrfs_balance()
4422 BUG_ON(fs_info->balance_ctl); in btrfs_balance()
4423 spin_lock(&fs_info->balance_lock); in btrfs_balance()
4424 fs_info->balance_ctl = bctl; in btrfs_balance()
4425 spin_unlock(&fs_info->balance_lock); in btrfs_balance()
4427 BUG_ON(ret != -EEXIST); in btrfs_balance()
4428 spin_lock(&fs_info->balance_lock); in btrfs_balance()
4430 spin_unlock(&fs_info->balance_lock); in btrfs_balance()
4433 ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_balance()
4434 set_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags); in btrfs_balance()
4436 mutex_unlock(&fs_info->balance_mutex); in btrfs_balance()
4440 mutex_lock(&fs_info->balance_mutex); in btrfs_balance()
4441 if (ret == -ECANCELED && atomic_read(&fs_info->balance_pause_req)) { in btrfs_balance()
4449 * - Regular cancel request in btrfs_balance()
4450 * Then ret == -ECANCELED and balance_cancel_req > 0 in btrfs_balance()
4452 * - Fatal signal to "btrfs" process in btrfs_balance()
4454 * got -EINTR, or caught by btrfs_should_cancel_balance() and in btrfs_balance()
4455 * got -ECANCELED. in btrfs_balance()
4457 * ret == -EINTR or ret == -ECANCELED. in btrfs_balance()
4461 else if (ret == -ECANCELED || ret == -EINTR) in btrfs_balance()
4466 clear_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags); in btrfs_balance()
4479 wake_up(&fs_info->balance_wait_q); in btrfs_balance()
4483 if (bctl->flags & BTRFS_BALANCE_RESUME) in btrfs_balance()
4497 sb_start_write(fs_info->sb); in balance_kthread()
4498 mutex_lock(&fs_info->balance_mutex); in balance_kthread()
4499 if (fs_info->balance_ctl) in balance_kthread()
4500 ret = btrfs_balance(fs_info, fs_info->balance_ctl, NULL); in balance_kthread()
4501 mutex_unlock(&fs_info->balance_mutex); in balance_kthread()
4502 sb_end_write(fs_info->sb); in balance_kthread()
4511 mutex_lock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4512 if (!fs_info->balance_ctl) { in btrfs_resume_balance_async()
4513 mutex_unlock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4516 mutex_unlock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4523 spin_lock(&fs_info->super_lock); in btrfs_resume_balance_async()
4524 ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED); in btrfs_resume_balance_async()
4525 fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE; in btrfs_resume_balance_async()
4526 spin_unlock(&fs_info->super_lock); in btrfs_resume_balance_async()
4528 * A ro->rw remount sequence should continue with the paused balance in btrfs_resume_balance_async()
4529 * regardless of who pauses it, system or the user as of now, so set in btrfs_resume_balance_async()
4532 spin_lock(&fs_info->balance_lock); in btrfs_resume_balance_async()
4533 fs_info->balance_ctl->flags |= BTRFS_BALANCE_RESUME; in btrfs_resume_balance_async()
4534 spin_unlock(&fs_info->balance_lock); in btrfs_resume_balance_async()
4536 tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance"); in btrfs_resume_balance_async()
4552 return -ENOMEM; in btrfs_recover_balance()
4558 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); in btrfs_recover_balance()
4561 if (ret > 0) { /* ret = -ENOENT; */ in btrfs_recover_balance()
4568 ret = -ENOMEM; in btrfs_recover_balance()
4572 leaf = path->nodes[0]; in btrfs_recover_balance()
4573 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item); in btrfs_recover_balance()
4575 bctl->flags = btrfs_balance_flags(leaf, item); in btrfs_recover_balance()
4576 bctl->flags |= BTRFS_BALANCE_RESUME; in btrfs_recover_balance()
4579 btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs); in btrfs_recover_balance()
4581 btrfs_disk_balance_args_to_cpu(&bctl->meta, &disk_bargs); in btrfs_recover_balance()
4583 btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs); in btrfs_recover_balance()
4601 mutex_lock(&fs_info->balance_mutex); in btrfs_recover_balance()
4602 BUG_ON(fs_info->balance_ctl); in btrfs_recover_balance()
4603 spin_lock(&fs_info->balance_lock); in btrfs_recover_balance()
4604 fs_info->balance_ctl = bctl; in btrfs_recover_balance()
4605 spin_unlock(&fs_info->balance_lock); in btrfs_recover_balance()
4606 mutex_unlock(&fs_info->balance_mutex); in btrfs_recover_balance()
4616 mutex_lock(&fs_info->balance_mutex); in btrfs_pause_balance()
4617 if (!fs_info->balance_ctl) { in btrfs_pause_balance()
4618 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4619 return -ENOTCONN; in btrfs_pause_balance()
4622 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { in btrfs_pause_balance()
4623 atomic_inc(&fs_info->balance_pause_req); in btrfs_pause_balance()
4624 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4626 wait_event(fs_info->balance_wait_q, in btrfs_pause_balance()
4627 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_pause_balance()
4629 mutex_lock(&fs_info->balance_mutex); in btrfs_pause_balance()
4631 BUG_ON(test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_pause_balance()
4632 atomic_dec(&fs_info->balance_pause_req); in btrfs_pause_balance()
4634 ret = -ENOTCONN; in btrfs_pause_balance()
4637 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4643 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4644 if (!fs_info->balance_ctl) { in btrfs_cancel_balance()
4645 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4646 return -ENOTCONN; in btrfs_cancel_balance()
4651 * mount time if the mount is read-write. Otherwise it's still paused in btrfs_cancel_balance()
4654 if (sb_rdonly(fs_info->sb)) { in btrfs_cancel_balance()
4655 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4656 return -EROFS; in btrfs_cancel_balance()
4659 atomic_inc(&fs_info->balance_cancel_req); in btrfs_cancel_balance()
4664 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { in btrfs_cancel_balance()
4665 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4666 wait_event(fs_info->balance_wait_q, in btrfs_cancel_balance()
4667 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_cancel_balance()
4668 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4670 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4675 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4677 if (fs_info->balance_ctl) { in btrfs_cancel_balance()
4684 ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_cancel_balance()
4685 atomic_dec(&fs_info->balance_cancel_req); in btrfs_cancel_balance()
4686 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4693 struct btrfs_root *root = fs_info->tree_root; in btrfs_uuid_scan_kthread()
4706 ret = -ENOMEM; in btrfs_uuid_scan_kthread()
4733 eb = path->nodes[0]; in btrfs_uuid_scan_kthread()
4734 slot = path->slots[0]; in btrfs_uuid_scan_kthread()
4752 * 1 - subvol uuid item in btrfs_uuid_scan_kthread()
4753 * 1 - received_subvol uuid item in btrfs_uuid_scan_kthread()
4755 trans = btrfs_start_transaction(fs_info->uuid_root, 2); in btrfs_uuid_scan_kthread()
4798 if (key.offset < (u64)-1) { in btrfs_uuid_scan_kthread()
4803 } else if (key.objectid < (u64)-1) { in btrfs_uuid_scan_kthread()
4820 set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags); in btrfs_uuid_scan_kthread()
4821 up(&fs_info->uuid_tree_rescan_sem); in btrfs_uuid_scan_kthread()
4828 struct btrfs_root *tree_root = fs_info->tree_root; in btrfs_create_uuid_tree()
4834 * 1 - root node in btrfs_create_uuid_tree()
4835 * 1 - root item in btrfs_create_uuid_tree()
4849 fs_info->uuid_root = uuid_root; in btrfs_create_uuid_tree()
4855 down(&fs_info->uuid_tree_rescan_sem); in btrfs_create_uuid_tree()
4856 task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid"); in btrfs_create_uuid_tree()
4858 /* fs_info->update_uuid_tree_gen remains 0 in all error case */ in btrfs_create_uuid_tree()
4860 up(&fs_info->uuid_tree_rescan_sem); in btrfs_create_uuid_tree()
4874 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_shrink_device()
4875 struct btrfs_root *root = fs_info->dev_root; in btrfs_shrink_device()
4887 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_shrink_device()
4893 new_size = round_down(new_size, fs_info->sectorsize); in btrfs_shrink_device()
4895 diff = round_down(old_size - new_size, fs_info->sectorsize); in btrfs_shrink_device()
4897 if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) in btrfs_shrink_device()
4898 return -EINVAL; in btrfs_shrink_device()
4902 return -ENOMEM; in btrfs_shrink_device()
4904 path->reada = READA_BACK; in btrfs_shrink_device()
4912 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4915 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_shrink_device()
4916 device->fs_devices->total_rw_bytes -= diff; in btrfs_shrink_device()
4917 atomic64_sub(diff, &fs_info->free_chunk_space); in btrfs_shrink_device()
4922 * in-memory chunks are synced to disk so that the loop below sees them in btrfs_shrink_device()
4926 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4931 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4936 key.objectid = device->devid; in btrfs_shrink_device()
4937 key.offset = (u64)-1; in btrfs_shrink_device()
4941 mutex_lock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4944 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4950 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4958 l = path->nodes[0]; in btrfs_shrink_device()
4959 slot = path->slots[0]; in btrfs_shrink_device()
4960 btrfs_item_key_to_cpu(l, &key, path->slots[0]); in btrfs_shrink_device()
4962 if (key.objectid != device->devid) { in btrfs_shrink_device()
4963 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4972 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4988 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4993 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4994 if (ret == -ENOSPC) { in btrfs_shrink_device()
4997 if (ret == -ETXTBSY) { in btrfs_shrink_device()
5004 } while (key.offset-- > 0); in btrfs_shrink_device()
5011 ret = -ENOSPC; in btrfs_shrink_device()
5022 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
5024 clear_extent_bits(&device->alloc_state, new_size, (u64)-1, in btrfs_shrink_device()
5028 if (list_empty(&device->post_commit_list)) in btrfs_shrink_device()
5029 list_add_tail(&device->post_commit_list, in btrfs_shrink_device()
5030 &trans->transaction->dev_update_list); in btrfs_shrink_device()
5034 round_down(old_total - diff, fs_info->sectorsize)); in btrfs_shrink_device()
5035 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
5038 /* Now btrfs_update_device() will change the on-disk size. */ in btrfs_shrink_device()
5050 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
5052 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) in btrfs_shrink_device()
5053 device->fs_devices->total_rw_bytes += diff; in btrfs_shrink_device()
5054 atomic64_add(diff, &fs_info->free_chunk_space); in btrfs_shrink_device()
5055 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
5064 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_add_system_chunk()
5069 lockdep_assert_held(&fs_info->chunk_mutex); in btrfs_add_system_chunk()
5074 return -EFBIG; in btrfs_add_system_chunk()
5076 ptr = super_copy->sys_chunk_array + array_size; in btrfs_add_system_chunk()
5095 if (di_a->max_avail > di_b->max_avail) in btrfs_cmp_device_info()
5096 return -1; in btrfs_cmp_device_info()
5097 if (di_a->max_avail < di_b->max_avail) in btrfs_cmp_device_info()
5099 if (di_a->total_avail > di_b->total_avail) in btrfs_cmp_device_info()
5100 return -1; in btrfs_cmp_device_info()
5101 if (di_a->total_avail < di_b->total_avail) in btrfs_cmp_device_info()
5155 struct alloc_chunk_ctl *ctl) in init_alloc_chunk_ctl_policy_regular() argument
5159 space_info = btrfs_find_space_info(fs_devices->fs_info, ctl->type); in init_alloc_chunk_ctl_policy_regular()
5162 ctl->max_chunk_size = READ_ONCE(space_info->chunk_size); in init_alloc_chunk_ctl_policy_regular()
5163 ctl->max_stripe_size = min_t(u64, ctl->max_chunk_size, SZ_1G); in init_alloc_chunk_ctl_policy_regular()
5165 if (ctl->type & BTRFS_BLOCK_GROUP_SYSTEM) in init_alloc_chunk_ctl_policy_regular()
5166 ctl->devs_max = min_t(int, ctl->devs_max, BTRFS_MAX_DEVS_SYS_CHUNK); in init_alloc_chunk_ctl_policy_regular()
5169 ctl->max_chunk_size = min(mult_perc(fs_devices->total_rw_bytes, 10), in init_alloc_chunk_ctl_policy_regular()
5170 ctl->max_chunk_size); in init_alloc_chunk_ctl_policy_regular()
5171 ctl->dev_extent_min = btrfs_stripe_nr_to_offset(ctl->dev_stripes); in init_alloc_chunk_ctl_policy_regular()
5176 struct alloc_chunk_ctl *ctl) in init_alloc_chunk_ctl_policy_zoned() argument
5178 u64 zone_size = fs_devices->fs_info->zone_size; in init_alloc_chunk_ctl_policy_zoned()
5180 int min_num_stripes = ctl->devs_min * ctl->dev_stripes; in init_alloc_chunk_ctl_policy_zoned()
5181 int min_data_stripes = (min_num_stripes - ctl->nparity) / ctl->ncopies; in init_alloc_chunk_ctl_policy_zoned()
5183 u64 type = ctl->type; in init_alloc_chunk_ctl_policy_zoned()
5185 ctl->max_stripe_size = zone_size; in init_alloc_chunk_ctl_policy_zoned()
5187 ctl->max_chunk_size = round_down(BTRFS_MAX_DATA_CHUNK_SIZE, in init_alloc_chunk_ctl_policy_zoned()
5190 ctl->max_chunk_size = ctl->max_stripe_size; in init_alloc_chunk_ctl_policy_zoned()
5192 ctl->max_chunk_size = 2 * ctl->max_stripe_size; in init_alloc_chunk_ctl_policy_zoned()
5193 ctl->devs_max = min_t(int, ctl->devs_max, in init_alloc_chunk_ctl_policy_zoned()
5200 limit = max(round_down(mult_perc(fs_devices->total_rw_bytes, 10), in init_alloc_chunk_ctl_policy_zoned()
5203 ctl->max_chunk_size = min(limit, ctl->max_chunk_size); in init_alloc_chunk_ctl_policy_zoned()
5204 ctl->dev_extent_min = zone_size * ctl->dev_stripes; in init_alloc_chunk_ctl_policy_zoned()
5208 struct alloc_chunk_ctl *ctl) in init_alloc_chunk_ctl() argument
5210 int index = btrfs_bg_flags_to_raid_index(ctl->type); in init_alloc_chunk_ctl()
5212 ctl->sub_stripes = btrfs_raid_array[index].sub_stripes; in init_alloc_chunk_ctl()
5213 ctl->dev_stripes = btrfs_raid_array[index].dev_stripes; in init_alloc_chunk_ctl()
5214 ctl->devs_max = btrfs_raid_array[index].devs_max; in init_alloc_chunk_ctl()
5215 if (!ctl->devs_max) in init_alloc_chunk_ctl()
5216 ctl->devs_max = BTRFS_MAX_DEVS(fs_devices->fs_info); in init_alloc_chunk_ctl()
5217 ctl->devs_min = btrfs_raid_array[index].devs_min; in init_alloc_chunk_ctl()
5218 ctl->devs_increment = btrfs_raid_array[index].devs_increment; in init_alloc_chunk_ctl()
5219 ctl->ncopies = btrfs_raid_array[index].ncopies; in init_alloc_chunk_ctl()
5220 ctl->nparity = btrfs_raid_array[index].nparity; in init_alloc_chunk_ctl()
5221 ctl->ndevs = 0; in init_alloc_chunk_ctl()
5223 switch (fs_devices->chunk_alloc_policy) { in init_alloc_chunk_ctl()
5225 init_alloc_chunk_ctl_policy_regular(fs_devices, ctl); in init_alloc_chunk_ctl()
5228 init_alloc_chunk_ctl_policy_zoned(fs_devices, ctl); in init_alloc_chunk_ctl()
5236 struct alloc_chunk_ctl *ctl, in gather_device_info() argument
5239 struct btrfs_fs_info *info = fs_devices->fs_info; in gather_device_info()
5242 u64 dev_extent_want = ctl->max_stripe_size * ctl->dev_stripes; in gather_device_info()
5252 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) { in gather_device_info()
5253 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in gather_device_info()
5255 "BTRFS: read-only device in alloc_list\n"); in gather_device_info()
5260 &device->dev_state) || in gather_device_info()
5261 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) in gather_device_info()
5264 if (device->total_bytes > device->bytes_used) in gather_device_info()
5265 total_avail = device->total_bytes - device->bytes_used; in gather_device_info()
5270 if (total_avail < ctl->dev_extent_min) in gather_device_info()
5275 if (ret && ret != -ENOSPC) in gather_device_info()
5281 if (max_avail < ctl->dev_extent_min) { in gather_device_info()
5285 __func__, device->devid, max_avail, in gather_device_info()
5286 ctl->dev_extent_min); in gather_device_info()
5290 if (ndevs == fs_devices->rw_devices) { in gather_device_info()
5292 __func__, fs_devices->rw_devices); in gather_device_info()
5301 ctl->ndevs = ndevs; in gather_device_info()
5312 static int decide_stripe_size_regular(struct alloc_chunk_ctl *ctl, in decide_stripe_size_regular() argument
5325 ctl->stripe_size = div_u64(devices_info[ctl->ndevs - 1].max_avail, in decide_stripe_size_regular()
5326 ctl->dev_stripes); in decide_stripe_size_regular()
5327 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; in decide_stripe_size_regular()
5330 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; in decide_stripe_size_regular()
5338 if (ctl->stripe_size * data_stripes > ctl->max_chunk_size) { in decide_stripe_size_regular()
5344 ctl->stripe_size = min(round_up(div_u64(ctl->max_chunk_size, in decide_stripe_size_regular()
5346 ctl->stripe_size); in decide_stripe_size_regular()
5350 ctl->stripe_size = min_t(u64, ctl->stripe_size, SZ_1G); in decide_stripe_size_regular()
5353 ctl->stripe_size = round_down(ctl->stripe_size, BTRFS_STRIPE_LEN); in decide_stripe_size_regular()
5354 ctl->chunk_size = ctl->stripe_size * data_stripes; in decide_stripe_size_regular()
5359 static int decide_stripe_size_zoned(struct alloc_chunk_ctl *ctl, in decide_stripe_size_zoned() argument
5362 u64 zone_size = devices_info[0].dev->zone_info->zone_size; in decide_stripe_size_zoned()
5370 ASSERT(devices_info[ctl->ndevs - 1].max_avail == ctl->dev_extent_min); in decide_stripe_size_zoned()
5372 ctl->stripe_size = zone_size; in decide_stripe_size_zoned()
5373 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; in decide_stripe_size_zoned()
5374 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; in decide_stripe_size_zoned()
5377 if (ctl->stripe_size * data_stripes > ctl->max_chunk_size) { in decide_stripe_size_zoned()
5378 ctl->ndevs = div_u64(div_u64(ctl->max_chunk_size * ctl->ncopies, in decide_stripe_size_zoned()
5379 ctl->stripe_size) + ctl->nparity, in decide_stripe_size_zoned()
5380 ctl->dev_stripes); in decide_stripe_size_zoned()
5381 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; in decide_stripe_size_zoned()
5382 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; in decide_stripe_size_zoned()
5383 ASSERT(ctl->stripe_size * data_stripes <= ctl->max_chunk_size); in decide_stripe_size_zoned()
5386 ctl->chunk_size = ctl->stripe_size * data_stripes; in decide_stripe_size_zoned()
5392 struct alloc_chunk_ctl *ctl, in decide_stripe_size() argument
5395 struct btrfs_fs_info *info = fs_devices->fs_info; in decide_stripe_size()
5402 ctl->ndevs = rounddown(ctl->ndevs, ctl->devs_increment); in decide_stripe_size()
5404 if (ctl->ndevs < ctl->devs_min) { in decide_stripe_size()
5408 __func__, ctl->ndevs, ctl->devs_min); in decide_stripe_size()
5410 return -ENOSPC; in decide_stripe_size()
5413 ctl->ndevs = min(ctl->ndevs, ctl->devs_max); in decide_stripe_size()
5415 switch (fs_devices->chunk_alloc_policy) { in decide_stripe_size()
5417 return decide_stripe_size_regular(ctl, devices_info); in decide_stripe_size()
5419 return decide_stripe_size_zoned(ctl, devices_info); in decide_stripe_size()
5426 struct alloc_chunk_ctl *ctl, in create_chunk() argument
5429 struct btrfs_fs_info *info = trans->fs_info; in create_chunk()
5434 u64 start = ctl->start; in create_chunk()
5435 u64 type = ctl->type; in create_chunk()
5440 map = kmalloc(map_lookup_size(ctl->num_stripes), GFP_NOFS); in create_chunk()
5442 return ERR_PTR(-ENOMEM); in create_chunk()
5443 map->num_stripes = ctl->num_stripes; in create_chunk()
5445 for (i = 0; i < ctl->ndevs; ++i) { in create_chunk()
5446 for (j = 0; j < ctl->dev_stripes; ++j) { in create_chunk()
5447 int s = i * ctl->dev_stripes + j; in create_chunk()
5448 map->stripes[s].dev = devices_info[i].dev; in create_chunk()
5449 map->stripes[s].physical = devices_info[i].dev_offset + in create_chunk()
5450 j * ctl->stripe_size; in create_chunk()
5453 map->io_align = BTRFS_STRIPE_LEN; in create_chunk()
5454 map->io_width = BTRFS_STRIPE_LEN; in create_chunk()
5455 map->type = type; in create_chunk()
5456 map->sub_stripes = ctl->sub_stripes; in create_chunk()
5458 trace_btrfs_chunk_alloc(info, map, start, ctl->chunk_size); in create_chunk()
5463 return ERR_PTR(-ENOMEM); in create_chunk()
5465 set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); in create_chunk()
5466 em->map_lookup = map; in create_chunk()
5467 em->start = start; in create_chunk()
5468 em->len = ctl->chunk_size; in create_chunk()
5469 em->block_start = 0; in create_chunk()
5470 em->block_len = em->len; in create_chunk()
5471 em->orig_block_len = ctl->stripe_size; in create_chunk()
5473 em_tree = &info->mapping_tree; in create_chunk()
5474 write_lock(&em_tree->lock); in create_chunk()
5477 write_unlock(&em_tree->lock); in create_chunk()
5481 write_unlock(&em_tree->lock); in create_chunk()
5483 block_group = btrfs_make_block_group(trans, type, start, ctl->chunk_size); in create_chunk()
5487 for (i = 0; i < map->num_stripes; i++) { in create_chunk()
5488 struct btrfs_device *dev = map->stripes[i].dev; in create_chunk()
5491 dev->bytes_used + ctl->stripe_size); in create_chunk()
5492 if (list_empty(&dev->post_commit_list)) in create_chunk()
5493 list_add_tail(&dev->post_commit_list, in create_chunk()
5494 &trans->transaction->dev_update_list); in create_chunk()
5497 atomic64_sub(ctl->stripe_size * map->num_stripes, in create_chunk()
5498 &info->free_chunk_space); in create_chunk()
5507 write_lock(&em_tree->lock); in create_chunk()
5509 write_unlock(&em_tree->lock); in create_chunk()
5522 struct btrfs_fs_info *info = trans->fs_info; in btrfs_create_chunk()
5523 struct btrfs_fs_devices *fs_devices = info->fs_devices; in btrfs_create_chunk()
5525 struct alloc_chunk_ctl ctl; in btrfs_create_chunk() local
5529 lockdep_assert_held(&info->chunk_mutex); in btrfs_create_chunk()
5533 return ERR_PTR(-EINVAL); in btrfs_create_chunk()
5536 if (list_empty(&fs_devices->alloc_list)) { in btrfs_create_chunk()
5539 return ERR_PTR(-ENOSPC); in btrfs_create_chunk()
5545 return ERR_PTR(-EINVAL); in btrfs_create_chunk()
5548 ctl.start = find_next_chunk(info); in btrfs_create_chunk()
5549 ctl.type = type; in btrfs_create_chunk()
5550 init_alloc_chunk_ctl(fs_devices, &ctl); in btrfs_create_chunk()
5552 devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info), in btrfs_create_chunk()
5555 return ERR_PTR(-ENOMEM); in btrfs_create_chunk()
5557 ret = gather_device_info(fs_devices, &ctl, devices_info); in btrfs_create_chunk()
5563 ret = decide_stripe_size(fs_devices, &ctl, devices_info); in btrfs_create_chunk()
5569 block_group = create_chunk(trans, &ctl, devices_info); in btrfs_create_chunk()
5578 * phase 1 of chunk allocation. It belongs to phase 2 only when allocating system
5587 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_chunk_alloc_add_chunk_item()
5588 struct btrfs_root *chunk_root = fs_info->chunk_root; in btrfs_chunk_alloc_add_chunk_item()
5602 * the chunk_mutex, as well as updating the system chunk array in the in btrfs_chunk_alloc_add_chunk_item()
5610 * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the in btrfs_chunk_alloc_add_chunk_item()
5616 * acquires both mutexes - first the device_list_mutex and then the in btrfs_chunk_alloc_add_chunk_item()
5620 lockdep_assert_held(&fs_info->chunk_mutex); in btrfs_chunk_alloc_add_chunk_item()
5622 em = btrfs_get_chunk_map(fs_info, bg->start, bg->length); in btrfs_chunk_alloc_add_chunk_item()
5629 map = em->map_lookup; in btrfs_chunk_alloc_add_chunk_item()
5630 item_size = btrfs_chunk_item_size(map->num_stripes); in btrfs_chunk_alloc_add_chunk_item()
5634 ret = -ENOMEM; in btrfs_chunk_alloc_add_chunk_item()
5639 for (i = 0; i < map->num_stripes; i++) { in btrfs_chunk_alloc_add_chunk_item()
5640 struct btrfs_device *device = map->stripes[i].dev; in btrfs_chunk_alloc_add_chunk_item()
5647 stripe = &chunk->stripe; in btrfs_chunk_alloc_add_chunk_item()
5648 for (i = 0; i < map->num_stripes; i++) { in btrfs_chunk_alloc_add_chunk_item()
5649 struct btrfs_device *device = map->stripes[i].dev; in btrfs_chunk_alloc_add_chunk_item()
5650 const u64 dev_offset = map->stripes[i].physical; in btrfs_chunk_alloc_add_chunk_item()
5652 btrfs_set_stack_stripe_devid(stripe, device->devid); in btrfs_chunk_alloc_add_chunk_item()
5654 memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE); in btrfs_chunk_alloc_add_chunk_item()
5658 btrfs_set_stack_chunk_length(chunk, bg->length); in btrfs_chunk_alloc_add_chunk_item()
5661 btrfs_set_stack_chunk_type(chunk, map->type); in btrfs_chunk_alloc_add_chunk_item()
5662 btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes); in btrfs_chunk_alloc_add_chunk_item()
5665 btrfs_set_stack_chunk_sector_size(chunk, fs_info->sectorsize); in btrfs_chunk_alloc_add_chunk_item()
5666 btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes); in btrfs_chunk_alloc_add_chunk_item()
5670 key.offset = bg->start; in btrfs_chunk_alloc_add_chunk_item()
5676 set_bit(BLOCK_GROUP_FLAG_CHUNK_ITEM_INSERTED, &bg->runtime_flags); in btrfs_chunk_alloc_add_chunk_item()
5678 if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) { in btrfs_chunk_alloc_add_chunk_item()
5692 struct btrfs_fs_info *fs_info = trans->fs_info; in init_first_rw_device()
5698 * When adding a new device for sprouting, the seed device is read-only in init_first_rw_device()
5699 * so we must first allocate a metadata and a system chunk. But before in init_first_rw_device()
5704 * otherwise we would get -ENOSPC since the block groups from the in init_first_rw_device()
5705 * seed device are read-only; in init_first_rw_device()
5707 * 2) Add the device item for the new sprout device - finishing the setup in init_first_rw_device()
5710 * ensures this does not fail with -ENOSPC. in init_first_rw_device()
5733 const int index = btrfs_bg_flags_to_raid_index(map->type); in btrfs_chunk_max_errors()
5750 map = em->map_lookup; in btrfs_chunk_writeable()
5751 for (i = 0; i < map->num_stripes; i++) { in btrfs_chunk_writeable()
5753 &map->stripes[i].dev->dev_state)) { in btrfs_chunk_writeable()
5758 &map->stripes[i].dev->dev_state)) { in btrfs_chunk_writeable()
5780 write_lock(&tree->lock); in btrfs_mapping_tree_free()
5781 em = lookup_extent_mapping(tree, 0, (u64)-1); in btrfs_mapping_tree_free()
5784 write_unlock(&tree->lock); in btrfs_mapping_tree_free()
5811 map = em->map_lookup; in btrfs_num_copies()
5812 index = btrfs_bg_flags_to_raid_index(map->type); in btrfs_num_copies()
5814 /* Non-RAID56, use their ncopies from btrfs_raid_array. */ in btrfs_num_copies()
5815 if (!(map->type & BTRFS_BLOCK_GROUP_RAID56_MASK)) in btrfs_num_copies()
5817 else if (map->type & BTRFS_BLOCK_GROUP_RAID5) in btrfs_num_copies()
5819 else if (map->type & BTRFS_BLOCK_GROUP_RAID6) in btrfs_num_copies()
5827 ret = map->num_stripes; in btrfs_num_copies()
5837 unsigned long len = fs_info->sectorsize; in btrfs_full_stripe_len()
5845 map = em->map_lookup; in btrfs_full_stripe_len()
5846 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) in btrfs_full_stripe_len()
5865 map = em->map_lookup; in btrfs_is_parity_mirror()
5866 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) in btrfs_is_parity_mirror()
5883 ASSERT((map->type & in find_live_mirror()
5886 if (map->type & BTRFS_BLOCK_GROUP_RAID10) in find_live_mirror()
5887 num_stripes = map->sub_stripes; in find_live_mirror()
5889 num_stripes = map->num_stripes; in find_live_mirror()
5891 switch (fs_info->fs_devices->read_policy) { in find_live_mirror()
5896 fs_info->fs_devices->read_policy); in find_live_mirror()
5897 fs_info->fs_devices->read_policy = BTRFS_READ_POLICY_PID; in find_live_mirror()
5900 preferred_mirror = first + (current->pid % num_stripes); in find_live_mirror()
5905 fs_info->dev_replace.cont_reading_from_srcdev_mode == in find_live_mirror()
5907 srcdev = fs_info->dev_replace.srcdev; in find_live_mirror()
5913 * dev-replace procedure, only choose it if no other non-missing in find_live_mirror()
5917 if (map->stripes[preferred_mirror].dev->bdev && in find_live_mirror()
5918 (tolerance || map->stripes[preferred_mirror].dev != srcdev)) in find_live_mirror()
5921 if (map->stripes[i].dev->bdev && in find_live_mirror()
5922 (tolerance || map->stripes[i].dev != srcdev)) in find_live_mirror()
5948 refcount_set(&bioc->refs, 1); in alloc_btrfs_io_context()
5950 bioc->fs_info = fs_info; in alloc_btrfs_io_context()
5951 bioc->replace_stripe_src = -1; in alloc_btrfs_io_context()
5952 bioc->full_stripe_logical = (u64)-1; in alloc_btrfs_io_context()
5959 WARN_ON(!refcount_read(&bioc->refs)); in btrfs_get_bioc()
5960 refcount_inc(&bioc->refs); in btrfs_get_bioc()
5967 if (refcount_dec_and_test(&bioc->refs)) in btrfs_put_bioc()
6002 map = em->map_lookup; in btrfs_map_discard()
6005 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in btrfs_map_discard()
6006 ret = -EOPNOTSUPP; in btrfs_map_discard()
6010 offset = logical - em->start; in btrfs_map_discard()
6011 length = min_t(u64, em->start + em->len - logical, length); in btrfs_map_discard()
6021 stripe_offset = offset - btrfs_stripe_nr_to_offset(stripe_nr); in btrfs_map_discard()
6025 stripe_cnt = stripe_nr_end - stripe_nr; in btrfs_map_discard()
6026 stripe_end_offset = btrfs_stripe_nr_to_offset(stripe_nr_end) - in btrfs_map_discard()
6035 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | in btrfs_map_discard()
6037 if (map->type & BTRFS_BLOCK_GROUP_RAID0) in btrfs_map_discard()
6040 sub_stripes = map->sub_stripes; in btrfs_map_discard()
6042 factor = map->num_stripes / sub_stripes; in btrfs_map_discard()
6043 *num_stripes = min_t(u64, map->num_stripes, in btrfs_map_discard()
6051 last_stripe = ((stripe_nr_end - 1) % factor) * sub_stripes; in btrfs_map_discard()
6052 } else if (map->type & (BTRFS_BLOCK_GROUP_RAID1_MASK | in btrfs_map_discard()
6054 *num_stripes = map->num_stripes; in btrfs_map_discard()
6056 stripe_index = stripe_nr % map->num_stripes; in btrfs_map_discard()
6057 stripe_nr /= map->num_stripes; in btrfs_map_discard()
6062 ret = -ENOMEM; in btrfs_map_discard()
6068 map->stripes[stripe_index].physical + in btrfs_map_discard()
6070 stripes[i].dev = map->stripes[stripe_index].dev; in btrfs_map_discard()
6072 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | in btrfs_map_discard()
6083 * |-------|...|-------| in btrfs_map_discard()
6084 * |----------| in btrfs_map_discard()
6088 stripes[i].length -= stripe_offset; in btrfs_map_discard()
6092 sub_stripes - 1)) in btrfs_map_discard()
6093 stripes[i].length -= stripe_end_offset; in btrfs_map_discard()
6095 if (i == sub_stripes - 1) in btrfs_map_discard()
6102 if (stripe_index == map->num_stripes) { in btrfs_map_discard()
6126 ret = test_bit(BLOCK_GROUP_FLAG_TO_COPY, &cache->runtime_flags); in is_block_group_to_copy()
6138 u64 srcdev_devid = dev_replace->srcdev->devid; in handle_ops_on_dev_replace()
6150 * the dev-replace process. We can avoid cloning IO here. in handle_ops_on_dev_replace()
6152 if (is_block_group_to_copy(dev_replace->srcdev->fs_info, logical)) in handle_ops_on_dev_replace()
6156 * Duplicate the write operations while the dev-replace procedure is in handle_ops_on_dev_replace()
6162 * Note that device->missing is handled by the caller, and that the in handle_ops_on_dev_replace()
6166 struct btrfs_io_stripe *old = &bioc->stripes[i]; in handle_ops_on_dev_replace()
6167 struct btrfs_io_stripe *new = &bioc->stripes[num_stripes + nr_extra_stripes]; in handle_ops_on_dev_replace()
6169 if (old->dev->devid != srcdev_devid) in handle_ops_on_dev_replace()
6172 new->physical = old->physical; in handle_ops_on_dev_replace()
6173 new->dev = dev_replace->tgtdev; in handle_ops_on_dev_replace()
6174 if (bioc->map_type & BTRFS_BLOCK_GROUP_RAID56_MASK) in handle_ops_on_dev_replace()
6175 bioc->replace_stripe_src = i; in handle_ops_on_dev_replace()
6187 struct btrfs_io_stripe *first = &bioc->stripes[num_stripes]; in handle_ops_on_dev_replace()
6188 struct btrfs_io_stripe *second = &bioc->stripes[num_stripes + 1]; in handle_ops_on_dev_replace()
6191 ASSERT(bioc->map_type & BTRFS_BLOCK_GROUP_DUP); in handle_ops_on_dev_replace()
6197 if (first->physical > second->physical) { in handle_ops_on_dev_replace()
6198 swap(second->physical, first->physical); in handle_ops_on_dev_replace()
6199 swap(second->dev, first->dev); in handle_ops_on_dev_replace()
6200 nr_extra_stripes--; in handle_ops_on_dev_replace()
6206 bioc->replace_nr_stripes = nr_extra_stripes; in handle_ops_on_dev_replace()
6221 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in btrfs_max_io_len()
6245 return full_stripe_len - (offset - *full_stripe_start); in btrfs_max_io_len()
6252 if (map->type & BTRFS_BLOCK_GROUP_STRIPE_MASK) in btrfs_max_io_len()
6253 return BTRFS_STRIPE_LEN - *stripe_offset; in btrfs_max_io_len()
6260 dst->dev = map->stripes[stripe_index].dev; in set_io_stripe()
6261 dst->physical = map->stripes[stripe_index].physical + in set_io_stripe()
6289 * For non-RAID56 profiles, non-zero mirror_num means
6324 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace; in btrfs_map_block()
6327 u64 raid56_full_stripe_start = (u64)-1; in btrfs_map_block()
6332 num_copies = btrfs_num_copies(fs_info, logical, fs_info->sectorsize); in btrfs_map_block()
6334 return -EINVAL; in btrfs_map_block()
6340 map = em->map_lookup; in btrfs_map_block()
6343 map_offset = logical - em->start; in btrfs_map_block()
6346 *length = min_t(u64, em->len - map_offset, max_len); in btrfs_map_block()
6348 if (dev_replace->replace_task != current) in btrfs_map_block()
6349 down_read(&dev_replace->rwsem); in btrfs_map_block()
6356 if (!dev_replace_is_ongoing && dev_replace->replace_task != current) in btrfs_map_block()
6357 up_read(&dev_replace->rwsem); in btrfs_map_block()
6361 if (map->type & BTRFS_BLOCK_GROUP_RAID0) { in btrfs_map_block()
6362 stripe_index = stripe_nr % map->num_stripes; in btrfs_map_block()
6363 stripe_nr /= map->num_stripes; in btrfs_map_block()
6366 } else if (map->type & BTRFS_BLOCK_GROUP_RAID1_MASK) { in btrfs_map_block()
6368 num_stripes = map->num_stripes; in btrfs_map_block()
6370 stripe_index = mirror_num - 1; in btrfs_map_block()
6377 } else if (map->type & BTRFS_BLOCK_GROUP_DUP) { in btrfs_map_block()
6379 num_stripes = map->num_stripes; in btrfs_map_block()
6381 stripe_index = mirror_num - 1; in btrfs_map_block()
6386 } else if (map->type & BTRFS_BLOCK_GROUP_RAID10) { in btrfs_map_block()
6387 u32 factor = map->num_stripes / map->sub_stripes; in btrfs_map_block()
6389 stripe_index = (stripe_nr % factor) * map->sub_stripes; in btrfs_map_block()
6393 num_stripes = map->sub_stripes; in btrfs_map_block()
6395 stripe_index += mirror_num - 1; in btrfs_map_block()
6401 mirror_num = stripe_index - old_stripe_index + 1; in btrfs_map_block()
6404 } else if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in btrfs_map_block()
6418 num_stripes = map->num_stripes; in btrfs_map_block()
6423 raid56_full_stripe_start + em->start + in btrfs_map_block()
6424 btrfs_stripe_nr_to_offset(data_stripes)) - in btrfs_map_block()
6437 stripe_index = data_stripes + mirror_num - 2; in btrfs_map_block()
6440 stripe_index = (stripe_nr + stripe_index) % map->num_stripes; in btrfs_map_block()
6450 stripe_index = stripe_nr % map->num_stripes; in btrfs_map_block()
6451 stripe_nr /= map->num_stripes; in btrfs_map_block()
6454 if (stripe_index >= map->num_stripes) { in btrfs_map_block()
6457 stripe_index, map->num_stripes); in btrfs_map_block()
6458 ret = -EINVAL; in btrfs_map_block()
6463 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL && in btrfs_map_block()
6480 !((map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) && mirror_num > 1)) { in btrfs_map_block()
6491 ret = -ENOMEM; in btrfs_map_block()
6494 bioc->map_type = map->type; in btrfs_map_block()
6503 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK && need_raid_map && in btrfs_map_block()
6513 bioc->full_stripe_logical = em->start + in btrfs_map_block()
6516 set_io_stripe(&bioc->stripes[i], map, in btrfs_map_block()
6521 * For all other non-RAID56 profiles, just copy the target in btrfs_map_block()
6525 set_io_stripe(&bioc->stripes[i], map, stripe_index, in btrfs_map_block()
6534 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL && in btrfs_map_block()
6541 bioc->num_stripes = num_stripes; in btrfs_map_block()
6542 bioc->max_errors = max_errors; in btrfs_map_block()
6543 bioc->mirror_num = mirror_num; in btrfs_map_block()
6546 if (dev_replace_is_ongoing && dev_replace->replace_task != current) { in btrfs_map_block()
6547 lockdep_assert_held(&dev_replace->rwsem); in btrfs_map_block()
6549 up_read(&dev_replace->rwsem); in btrfs_map_block()
6558 if (args->fsid == NULL) in dev_args_match_fs_devices()
6560 if (memcmp(fs_devices->metadata_uuid, args->fsid, BTRFS_FSID_SIZE) == 0) in dev_args_match_fs_devices()
6568 if (args->missing) { in dev_args_match_device()
6569 if (test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state) && in dev_args_match_device()
6570 !device->bdev) in dev_args_match_device()
6575 if (device->devid != args->devid) in dev_args_match_device()
6577 if (args->uuid && memcmp(device->uuid, args->uuid, BTRFS_UUID_SIZE) != 0) in dev_args_match_device()
6596 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_find_device()
6602 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_find_device()
6605 list_for_each_entry(device, &seed_devs->devices, dev_list) { in btrfs_find_device()
6633 list_add(&device->dev_list, &fs_devices->devices); in add_missing_dev()
6634 device->fs_devices = fs_devices; in add_missing_dev()
6635 fs_devices->num_devices++; in add_missing_dev()
6637 set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in add_missing_dev()
6638 fs_devices->missing_devices++; in add_missing_dev()
6666 return ERR_PTR(-EINVAL); in btrfs_alloc_device()
6670 return ERR_PTR(-ENOMEM); in btrfs_alloc_device()
6672 INIT_LIST_HEAD(&dev->dev_list); in btrfs_alloc_device()
6673 INIT_LIST_HEAD(&dev->dev_alloc_list); in btrfs_alloc_device()
6674 INIT_LIST_HEAD(&dev->post_commit_list); in btrfs_alloc_device()
6676 atomic_set(&dev->dev_stats_ccnt, 0); in btrfs_alloc_device()
6678 extent_io_tree_init(fs_info, &dev->alloc_state, IO_TREE_DEVICE_ALLOC_STATE); in btrfs_alloc_device()
6691 dev->devid = tmp; in btrfs_alloc_device()
6694 memcpy(dev->uuid, uuid, BTRFS_UUID_SIZE); in btrfs_alloc_device()
6696 generate_random_uuid(dev->uuid); in btrfs_alloc_device()
6704 return ERR_PTR(-ENOMEM); in btrfs_alloc_device()
6706 rcu_assign_pointer(dev->name, name); in btrfs_alloc_device()
6725 const struct map_lookup *map = em->map_lookup; in btrfs_calc_stripe_length()
6726 const int data_stripes = calc_data_stripes(map->type, map->num_stripes); in btrfs_calc_stripe_length()
6728 return div_u64(em->len, data_stripes); in btrfs_calc_stripe_length()
6749 return -EOVERFLOW; in check_32bit_meta_chunk()
6778 return ERR_PTR(-ENOENT); in handle_missing_device()
6781 dev = add_missing_dev(fs_info->fs_devices, devid, uuid); in handle_missing_device()
6796 struct btrfs_fs_info *fs_info = leaf->fs_info; in read_one_chunk()
6797 struct extent_map_tree *map_tree = &fs_info->mapping_tree; in read_one_chunk()
6810 logical = key->offset; in read_one_chunk()
6825 * as chunk item in tree block is already verified by tree-checker. in read_one_chunk()
6827 if (leaf->start == BTRFS_SUPER_INFO_OFFSET) { in read_one_chunk()
6833 read_lock(&map_tree->lock); in read_one_chunk()
6835 read_unlock(&map_tree->lock); in read_one_chunk()
6838 if (em && em->start <= logical && em->start + em->len > logical) { in read_one_chunk()
6847 return -ENOMEM; in read_one_chunk()
6851 return -ENOMEM; in read_one_chunk()
6854 set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); in read_one_chunk()
6855 em->map_lookup = map; in read_one_chunk()
6856 em->start = logical; in read_one_chunk()
6857 em->len = length; in read_one_chunk()
6858 em->orig_start = 0; in read_one_chunk()
6859 em->block_start = 0; in read_one_chunk()
6860 em->block_len = em->len; in read_one_chunk()
6862 map->num_stripes = num_stripes; in read_one_chunk()
6863 map->io_width = btrfs_chunk_io_width(leaf, chunk); in read_one_chunk()
6864 map->io_align = btrfs_chunk_io_align(leaf, chunk); in read_one_chunk()
6865 map->type = type; in read_one_chunk()
6870 * In that case, it can cause divide-by-zero errors later. in read_one_chunk()
6874 map->sub_stripes = btrfs_raid_array[index].sub_stripes; in read_one_chunk()
6875 map->verified_stripes = 0; in read_one_chunk()
6876 em->orig_block_len = btrfs_calc_stripe_length(em); in read_one_chunk()
6878 map->stripes[i].physical = in read_one_chunk()
6886 map->stripes[i].dev = btrfs_find_device(fs_info->fs_devices, &args); in read_one_chunk()
6887 if (!map->stripes[i].dev) { in read_one_chunk()
6888 map->stripes[i].dev = handle_missing_device(fs_info, in read_one_chunk()
6890 if (IS_ERR(map->stripes[i].dev)) { in read_one_chunk()
6891 ret = PTR_ERR(map->stripes[i].dev); in read_one_chunk()
6898 &(map->stripes[i].dev->dev_state)); in read_one_chunk()
6901 write_lock(&map_tree->lock); in read_one_chunk()
6903 write_unlock(&map_tree->lock); in read_one_chunk()
6907 em->start, em->len, ret); in read_one_chunk()
6920 device->devid = btrfs_device_id(leaf, dev_item); in fill_device_from_item()
6921 device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item); in fill_device_from_item()
6922 device->total_bytes = device->disk_total_bytes; in fill_device_from_item()
6923 device->commit_total_bytes = device->disk_total_bytes; in fill_device_from_item()
6924 device->bytes_used = btrfs_device_bytes_used(leaf, dev_item); in fill_device_from_item()
6925 device->commit_bytes_used = device->bytes_used; in fill_device_from_item()
6926 device->type = btrfs_device_type(leaf, dev_item); in fill_device_from_item()
6927 device->io_align = btrfs_device_io_align(leaf, dev_item); in fill_device_from_item()
6928 device->io_width = btrfs_device_io_width(leaf, dev_item); in fill_device_from_item()
6929 device->sector_size = btrfs_device_sector_size(leaf, dev_item); in fill_device_from_item()
6930 WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID); in fill_device_from_item()
6931 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in fill_device_from_item()
6934 read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); in fill_device_from_item()
6946 /* This will match only for multi-device seed fs */ in open_seed_devices()
6947 list_for_each_entry(fs_devices, &fs_info->fs_devices->seed_list, seed_list) in open_seed_devices()
6948 if (!memcmp(fs_devices->fsid, fsid, BTRFS_FSID_SIZE)) in open_seed_devices()
6955 return ERR_PTR(-ENOENT); in open_seed_devices()
6961 fs_devices->seeding = true; in open_seed_devices()
6962 fs_devices->opened = 1; in open_seed_devices()
6968 * respective fs_devices and anchor it at fs_info->fs_devices->seed_list in open_seed_devices()
6974 ret = open_fs_devices(fs_devices, BLK_OPEN_READ, fs_info->bdev_holder); in open_seed_devices()
6980 if (!fs_devices->seeding) { in open_seed_devices()
6983 return ERR_PTR(-EINVAL); in open_seed_devices()
6986 list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list); in open_seed_devices()
6995 struct btrfs_fs_info *fs_info = leaf->fs_info; in read_one_dev()
6996 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in read_one_dev()
7012 if (memcmp(fs_uuid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE)) { in read_one_dev()
7018 device = btrfs_find_device(fs_info->fs_devices, &args); in read_one_dev()
7023 return -ENOENT; in read_one_dev()
7035 if (!device->bdev) { in read_one_dev()
7039 return -ENOENT; in read_one_dev()
7045 if (!device->bdev && in read_one_dev()
7046 !test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in read_one_dev()
7050 * device->bdev is NULL, and so we have to set in read_one_dev()
7051 * device->missing to one here in read_one_dev()
7053 device->fs_devices->missing_devices++; in read_one_dev()
7054 set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in read_one_dev()
7058 if (device->fs_devices != fs_devices) { in read_one_dev()
7060 &device->dev_state)); in read_one_dev()
7062 list_move(&device->dev_list, &fs_devices->devices); in read_one_dev()
7063 device->fs_devices->num_devices--; in read_one_dev()
7064 fs_devices->num_devices++; in read_one_dev()
7066 device->fs_devices->missing_devices--; in read_one_dev()
7067 fs_devices->missing_devices++; in read_one_dev()
7069 device->fs_devices = fs_devices; in read_one_dev()
7073 if (device->fs_devices != fs_info->fs_devices) { in read_one_dev()
7074 BUG_ON(test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)); in read_one_dev()
7075 if (device->generation != in read_one_dev()
7077 return -EINVAL; in read_one_dev()
7081 if (device->bdev) { in read_one_dev()
7082 u64 max_total_bytes = bdev_nr_bytes(device->bdev); in read_one_dev()
7084 if (device->total_bytes > max_total_bytes) { in read_one_dev()
7087 max_total_bytes, device->total_bytes); in read_one_dev()
7088 return -EINVAL; in read_one_dev()
7091 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in read_one_dev()
7092 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in read_one_dev()
7093 !test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in read_one_dev()
7094 device->fs_devices->total_rw_bytes += device->total_bytes; in read_one_dev()
7095 atomic64_add(device->total_bytes - device->bytes_used, in read_one_dev()
7096 &fs_info->free_chunk_space); in read_one_dev()
7104 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_read_sys_array()
7118 ASSERT(BTRFS_SUPER_INFO_SIZE <= fs_info->nodesize); in btrfs_read_sys_array()
7123 * that's fine, we will not go beyond system chunk array anyway. in btrfs_read_sys_array()
7127 return -ENOMEM; in btrfs_read_sys_array()
7133 array_ptr = super_copy->sys_chunk_array; in btrfs_read_sys_array()
7153 ret = -EIO; in btrfs_read_sys_array()
7171 ret = -EIO; in btrfs_read_sys_array()
7180 ret = -EIO; in btrfs_read_sys_array()
7205 return -EIO; in btrfs_read_sys_array()
7209 * Check if all chunks in the fs are OK for read-write degraded mount
7219 struct extent_map_tree *map_tree = &fs_info->mapping_tree; in btrfs_check_rw_degradable()
7224 read_lock(&map_tree->lock); in btrfs_check_rw_degradable()
7225 em = lookup_extent_mapping(map_tree, 0, (u64)-1); in btrfs_check_rw_degradable()
7226 read_unlock(&map_tree->lock); in btrfs_check_rw_degradable()
7238 map = em->map_lookup; in btrfs_check_rw_degradable()
7241 map->type); in btrfs_check_rw_degradable()
7242 for (i = 0; i < map->num_stripes; i++) { in btrfs_check_rw_degradable()
7243 struct btrfs_device *dev = map->stripes[i].dev; in btrfs_check_rw_degradable()
7245 if (!dev || !dev->bdev || in btrfs_check_rw_degradable()
7246 test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state) || in btrfs_check_rw_degradable()
7247 dev->last_flush_error) in btrfs_check_rw_degradable()
7256 em->start, missing, max_tolerated); in btrfs_check_rw_degradable()
7264 read_lock(&map_tree->lock); in btrfs_check_rw_degradable()
7266 (u64)(-1) - next_start); in btrfs_check_rw_degradable()
7267 read_unlock(&map_tree->lock); in btrfs_check_rw_degradable()
7284 struct btrfs_root *root = fs_info->chunk_root; in btrfs_read_chunk_tree()
7297 return -ENOMEM; in btrfs_read_chunk_tree()
7311 fs_info->fs_devices->total_rw_bytes = 0; in btrfs_read_chunk_tree()
7323 ASSERT(!test_bit(BTRFS_FS_OPEN, &fs_info->flags)); in btrfs_read_chunk_tree()
7324 path->skip_locking = 1; in btrfs_read_chunk_tree()
7330 * item - BTRFS_FIRST_CHUNK_TREE_OBJECTID). in btrfs_read_chunk_tree()
7336 struct extent_buffer *node = path->nodes[1]; in btrfs_read_chunk_tree()
7338 leaf = path->nodes[0]; in btrfs_read_chunk_tree()
7339 slot = path->slots[0]; in btrfs_read_chunk_tree()
7342 if (last_ra_node != node->start) { in btrfs_read_chunk_tree()
7344 last_ra_node = node->start; in btrfs_read_chunk_tree()
7360 * fs_info->chunk_mutex. Plus, to avoid lockdep warnings, in btrfs_read_chunk_tree()
7361 * we always lock first fs_info->chunk_mutex before in btrfs_read_chunk_tree()
7382 if (total_dev != fs_info->fs_devices->total_devices) { in btrfs_read_chunk_tree()
7385 btrfs_super_num_devices(fs_info->super_copy), in btrfs_read_chunk_tree()
7387 fs_info->fs_devices->total_devices = total_dev; in btrfs_read_chunk_tree()
7388 btrfs_set_super_num_devices(fs_info->super_copy, total_dev); in btrfs_read_chunk_tree()
7390 if (btrfs_super_total_bytes(fs_info->super_copy) < in btrfs_read_chunk_tree()
7391 fs_info->fs_devices->total_rw_bytes) { in btrfs_read_chunk_tree()
7394 btrfs_super_total_bytes(fs_info->super_copy), in btrfs_read_chunk_tree()
7395 fs_info->fs_devices->total_rw_bytes); in btrfs_read_chunk_tree()
7396 ret = -EINVAL; in btrfs_read_chunk_tree()
7409 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs; in btrfs_init_devices_late()
7413 fs_devices->fs_info = fs_info; in btrfs_init_devices_late()
7415 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_devices_late()
7416 list_for_each_entry(device, &fs_devices->devices, dev_list) in btrfs_init_devices_late()
7417 device->fs_info = fs_info; in btrfs_init_devices_late()
7419 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_init_devices_late()
7420 list_for_each_entry(device, &seed_devs->devices, dev_list) { in btrfs_init_devices_late()
7421 device->fs_info = fs_info; in btrfs_init_devices_late()
7427 seed_devs->fs_info = fs_info; in btrfs_init_devices_late()
7429 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_devices_late()
7466 if (!device->fs_info->dev_root) in btrfs_device_init_dev_stats()
7471 key.offset = device->devid; in btrfs_device_init_dev_stats()
7472 ret = btrfs_search_slot(NULL, device->fs_info->dev_root, &key, path, 0, 0); in btrfs_device_init_dev_stats()
7476 device->dev_stats_valid = 1; in btrfs_device_init_dev_stats()
7480 slot = path->slots[0]; in btrfs_device_init_dev_stats()
7481 eb = path->nodes[0]; in btrfs_device_init_dev_stats()
7494 device->dev_stats_valid = 1; in btrfs_device_init_dev_stats()
7503 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs; in btrfs_init_dev_stats()
7510 return -ENOMEM; in btrfs_init_dev_stats()
7512 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_dev_stats()
7513 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_init_dev_stats()
7518 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_init_dev_stats()
7519 list_for_each_entry(device, &seed_devs->devices, dev_list) { in btrfs_init_dev_stats()
7526 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_dev_stats()
7535 struct btrfs_fs_info *fs_info = trans->fs_info; in update_dev_stat_item()
7536 struct btrfs_root *dev_root = fs_info->dev_root; in update_dev_stat_item()
7546 key.offset = device->devid; in update_dev_stat_item()
7550 return -ENOMEM; in update_dev_stat_item()
7551 ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1); in update_dev_stat_item()
7560 btrfs_item_size(path->nodes[0], path->slots[0]) < sizeof(*ptr)) { in update_dev_stat_item()
7585 eb = path->nodes[0]; in update_dev_stat_item()
7586 ptr = btrfs_item_ptr(eb, path->slots[0], struct btrfs_dev_stats_item); in update_dev_stat_item()
7602 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_run_dev_stats()
7603 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_run_dev_stats()
7608 mutex_lock(&fs_devices->device_list_mutex); in btrfs_run_dev_stats()
7609 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_run_dev_stats()
7610 stats_cnt = atomic_read(&device->dev_stats_ccnt); in btrfs_run_dev_stats()
7611 if (!device->dev_stats_valid || stats_cnt == 0) in btrfs_run_dev_stats()
7616 * There is a LOAD-LOAD control dependency between the value of in btrfs_run_dev_stats()
7617 * dev_stats_ccnt and updating the on-disk values which requires in btrfs_run_dev_stats()
7618 * reading the in-memory counters. Such control dependencies in btrfs_run_dev_stats()
7630 atomic_sub(stats_cnt, &device->dev_stats_ccnt); in btrfs_run_dev_stats()
7632 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_run_dev_stats()
7641 if (!dev->dev_stats_valid) in btrfs_dev_stat_inc_and_print()
7643 btrfs_err_rl_in_rcu(dev->fs_info, in btrfs_dev_stat_inc_and_print()
7663 btrfs_info_in_rcu(dev->fs_info, in btrfs_dev_stat_print_on_load()
7678 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_get_dev_stats()
7681 mutex_lock(&fs_devices->device_list_mutex); in btrfs_get_dev_stats()
7682 args.devid = stats->devid; in btrfs_get_dev_stats()
7683 dev = btrfs_find_device(fs_info->fs_devices, &args); in btrfs_get_dev_stats()
7684 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_get_dev_stats()
7688 return -ENODEV; in btrfs_get_dev_stats()
7689 } else if (!dev->dev_stats_valid) { in btrfs_get_dev_stats()
7691 return -ENODEV; in btrfs_get_dev_stats()
7692 } else if (stats->flags & BTRFS_DEV_STATS_RESET) { in btrfs_get_dev_stats()
7694 if (stats->nr_items > i) in btrfs_get_dev_stats()
7695 stats->values[i] = in btrfs_get_dev_stats()
7701 current->comm, task_pid_nr(current)); in btrfs_get_dev_stats()
7704 if (stats->nr_items > i) in btrfs_get_dev_stats()
7705 stats->values[i] = btrfs_dev_stat_read(dev, i); in btrfs_get_dev_stats()
7707 if (stats->nr_items > BTRFS_DEV_STAT_VALUES_MAX) in btrfs_get_dev_stats()
7708 stats->nr_items = BTRFS_DEV_STAT_VALUES_MAX; in btrfs_get_dev_stats()
7723 ASSERT(trans->state == TRANS_STATE_COMMIT_DOING); in btrfs_commit_device_sizes()
7725 if (list_empty(&trans->dev_update_list)) in btrfs_commit_device_sizes()
7733 mutex_lock(&trans->fs_info->chunk_mutex); in btrfs_commit_device_sizes()
7734 list_for_each_entry_safe(curr, next, &trans->dev_update_list, in btrfs_commit_device_sizes()
7736 list_del_init(&curr->post_commit_list); in btrfs_commit_device_sizes()
7737 curr->commit_total_bytes = curr->disk_total_bytes; in btrfs_commit_device_sizes()
7738 curr->commit_bytes_used = curr->bytes_used; in btrfs_commit_device_sizes()
7740 mutex_unlock(&trans->fs_info->chunk_mutex); in btrfs_commit_device_sizes()
7744 * Multiplicity factor for simple profiles: DUP, RAID1-like and RAID10.
7760 struct extent_map_tree *em_tree = &fs_info->mapping_tree; in verify_one_dev_extent()
7769 read_lock(&em_tree->lock); in verify_one_dev_extent()
7771 read_unlock(&em_tree->lock); in verify_one_dev_extent()
7777 ret = -EUCLEAN; in verify_one_dev_extent()
7781 map = em->map_lookup; in verify_one_dev_extent()
7786 physical_offset, devid, em->start, physical_len, in verify_one_dev_extent()
7788 ret = -EUCLEAN; in verify_one_dev_extent()
7802 for (i = 0; i < map->num_stripes; i++) { in verify_one_dev_extent()
7803 if (map->stripes[i].dev->devid == devid && in verify_one_dev_extent()
7804 map->stripes[i].physical == physical_offset) { in verify_one_dev_extent()
7806 if (map->verified_stripes >= map->num_stripes) { in verify_one_dev_extent()
7809 em->start); in verify_one_dev_extent()
7810 ret = -EUCLEAN; in verify_one_dev_extent()
7813 map->verified_stripes++; in verify_one_dev_extent()
7821 ret = -EUCLEAN; in verify_one_dev_extent()
7825 dev = btrfs_find_device(fs_info->fs_devices, &args); in verify_one_dev_extent()
7828 ret = -EUCLEAN; in verify_one_dev_extent()
7832 if (physical_offset + physical_len > dev->disk_total_bytes) { in verify_one_dev_extent()
7836 dev->disk_total_bytes); in verify_one_dev_extent()
7837 ret = -EUCLEAN; in verify_one_dev_extent()
7841 if (dev->zone_info) { in verify_one_dev_extent()
7842 u64 zone_size = dev->zone_info->zone_size; in verify_one_dev_extent()
7849 ret = -EUCLEAN; in verify_one_dev_extent()
7861 struct extent_map_tree *em_tree = &fs_info->mapping_tree; in verify_chunk_dev_extent_mapping()
7866 read_lock(&em_tree->lock); in verify_chunk_dev_extent_mapping()
7867 for (node = rb_first_cached(&em_tree->map); node; node = rb_next(node)) { in verify_chunk_dev_extent_mapping()
7869 if (em->map_lookup->num_stripes != in verify_chunk_dev_extent_mapping()
7870 em->map_lookup->verified_stripes) { in verify_chunk_dev_extent_mapping()
7873 em->start, em->map_lookup->verified_stripes, in verify_chunk_dev_extent_mapping()
7874 em->map_lookup->num_stripes); in verify_chunk_dev_extent_mapping()
7875 ret = -EUCLEAN; in verify_chunk_dev_extent_mapping()
7880 read_unlock(&em_tree->lock); in verify_chunk_dev_extent_mapping()
7894 struct btrfs_root *root = fs_info->dev_root; in btrfs_verify_dev_extents()
7919 return -ENOMEM; in btrfs_verify_dev_extents()
7921 path->reada = READA_FORWARD; in btrfs_verify_dev_extents()
7926 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) { in btrfs_verify_dev_extents()
7932 ret = -EUCLEAN; in btrfs_verify_dev_extents()
7937 struct extent_buffer *leaf = path->nodes[0]; in btrfs_verify_dev_extents()
7939 int slot = path->slots[0]; in btrfs_verify_dev_extents()
7960 ret = -EUCLEAN; in btrfs_verify_dev_extents()
7996 spin_lock(&fs_info->swapfile_pins_lock); in btrfs_pinned_by_swapfile()
7997 node = fs_info->swapfile_pins.rb_node; in btrfs_pinned_by_swapfile()
8000 if (ptr < sp->ptr) in btrfs_pinned_by_swapfile()
8001 node = node->rb_left; in btrfs_pinned_by_swapfile()
8002 else if (ptr > sp->ptr) in btrfs_pinned_by_swapfile()
8003 node = node->rb_right; in btrfs_pinned_by_swapfile()
8007 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_pinned_by_swapfile()
8014 struct btrfs_fs_info *fs_info = cache->fs_info; in relocating_repair_kthread()
8018 target = cache->start; in relocating_repair_kthread()
8021 sb_start_write(fs_info->sb); in relocating_repair_kthread()
8026 sb_end_write(fs_info->sb); in relocating_repair_kthread()
8027 return -EBUSY; in relocating_repair_kthread()
8030 mutex_lock(&fs_info->reclaim_bgs_lock); in relocating_repair_kthread()
8037 if (!test_bit(BLOCK_GROUP_FLAG_RELOCATING_REPAIR, &cache->runtime_flags)) in relocating_repair_kthread()
8052 mutex_unlock(&fs_info->reclaim_bgs_lock); in relocating_repair_kthread()
8054 sb_end_write(fs_info->sb); in relocating_repair_kthread()
8074 if (test_and_set_bit(BLOCK_GROUP_FLAG_RELOCATING_REPAIR, &cache->runtime_flags)) { in btrfs_repair_one_zone()
8080 "btrfs-relocating-repair"); in btrfs_repair_one_zone()
8093 u64 stripe_start = bioc->full_stripe_logical + in map_raid56_repair_block()
8101 smap->dev = bioc->stripes[i].dev; in map_raid56_repair_block()
8102 smap->physical = bioc->stripes[i].physical + in map_raid56_repair_block()
8103 ((logical - bioc->full_stripe_logical) & in map_raid56_repair_block()
8116 * - Call btrfs_bio_counter_inc_blocked() first
8117 * - The range does not cross stripe boundary
8118 * - Has a valid @mirror_num passed in.
8143 /* Map the RAID56 multi-stripe writes to a single one. */ in btrfs_map_repair_block()
8144 if (bioc->map_type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in btrfs_map_repair_block()
8149 ASSERT(mirror_num <= bioc->num_stripes); in btrfs_map_repair_block()
8150 smap->dev = bioc->stripes[mirror_num - 1].dev; in btrfs_map_repair_block()
8151 smap->physical = bioc->stripes[mirror_num - 1].physical; in btrfs_map_repair_block()
8154 ASSERT(smap->dev); in btrfs_map_repair_block()