Lines Matching +full:path +full:- +full:map
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()
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()
704 if (fs_devices->fsid_change) in find_fsid_inprogress()
707 if (check_fsid_changed(fs_devices, disk_super->fsid)) in find_fsid_inprogress()
711 return find_fsid(disk_super->fsid, NULL); in find_fsid_inprogress()
724 * 1 - The fs still continues to have different METADATA/FSID uuids. in find_fsid_changed()
725 * 2 - The fs is switched back to its original FSID (METADATA/FSID in find_fsid_changed()
730 if (check_fsid_changed(fs_devices, disk_super->metadata_uuid) && in find_fsid_changed()
731 memcmp(fs_devices->fsid, disk_super->fsid, in find_fsid_changed()
736 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, in find_fsid_changed()
738 memcmp(fs_devices->fsid, disk_super->metadata_uuid, in find_fsid_changed()
761 if (!fs_devices->fsid_change) in find_fsid_reverted_metadata()
764 if (check_fsid_changed(fs_devices, disk_super->fsid)) in find_fsid_reverted_metadata()
777 static noinline struct btrfs_device *device_list_add(const char *path, in device_list_add() argument
785 u64 devid = btrfs_stack_device_id(&disk_super->dev_item); in device_list_add()
793 error = lookup_bdev(path, &path_devt); in device_list_add()
795 btrfs_err(NULL, "failed to lookup block device for path %s: %d", in device_list_add()
796 path, error); in device_list_add()
810 fs_devices = find_fsid(disk_super->fsid, NULL); in device_list_add()
815 fs_devices = alloc_fs_devices(disk_super->fsid, in device_list_add()
816 has_metadata_uuid ? disk_super->metadata_uuid : NULL); in device_list_add()
820 fs_devices->fsid_change = fsid_change_in_progress; in device_list_add()
822 mutex_lock(&fs_devices->device_list_mutex); in device_list_add()
823 list_add(&fs_devices->fs_list, &fs_uuids); in device_list_add()
829 .uuid = disk_super->dev_item.uuid, in device_list_add()
832 mutex_lock(&fs_devices->device_list_mutex); in device_list_add()
840 if (fs_devices->fsid_change && in device_list_add()
841 found_transid > fs_devices->latest_generation) { in device_list_add()
842 memcpy(fs_devices->fsid, disk_super->fsid, in device_list_add()
844 memcpy(fs_devices->metadata_uuid, in device_list_add()
846 fs_devices->fsid_change = false; in device_list_add()
853 if (fs_devices->opened) { in device_list_add()
856 path, fs_devices->fsid, current->comm, in device_list_add()
858 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
859 return ERR_PTR(-EBUSY); in device_list_add()
864 disk_super->dev_item.uuid, path); in device_list_add()
867 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
872 device->devt = path_devt; in device_list_add()
874 list_add_rcu(&device->dev_list, &fs_devices->devices); in device_list_add()
875 fs_devices->num_devices++; in device_list_add()
877 device->fs_devices = fs_devices; in device_list_add()
880 if (disk_super->label[0]) in device_list_add()
883 disk_super->label, devid, found_transid, path, in device_list_add()
884 current->comm, task_pid_nr(current)); in device_list_add()
888 disk_super->fsid, devid, found_transid, path, in device_list_add()
889 current->comm, task_pid_nr(current)); in device_list_add()
891 } else if (!device->name || strcmp(device->name->str, path)) { in device_list_add()
894 * 1. If you are here and if the device->name is NULL that in device_list_add()
896 * 2. If you are here and if the device->name is different in device_list_add()
897 * from 'path' that means either in device_list_add()
900 * b. The missing-disk-which-was-replaced, has in device_list_add()
906 * Further in case of 1 and 2a above, the disk at 'path' in device_list_add()
918 if (!fs_devices->opened && found_transid < device->generation) { in device_list_add()
923 * with larger generation number or the last-in if in device_list_add()
926 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
929 path, found_transid, device->generation); in device_list_add()
930 return ERR_PTR(-EEXIST); in device_list_add()
934 * We are going to replace the device path for a given devid, in device_list_add()
937 * NOTE: the device->fs_info may not be reliable here so pass in device_list_add()
939 * use-after-free when the fs_info and fs_info->sb are already in device_list_add()
942 if (device->bdev) { in device_list_add()
943 if (device->devt != path_devt) { in device_list_add()
944 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
947 path, devid, found_transid, in device_list_add()
948 current->comm, in device_list_add()
950 return ERR_PTR(-EEXIST); in device_list_add()
953 "devid %llu device path %s changed to %s scanned by %s (%d)", in device_list_add()
955 path, current->comm, in device_list_add()
959 name = rcu_string_strdup(path, GFP_NOFS); in device_list_add()
961 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
962 return ERR_PTR(-ENOMEM); in device_list_add()
964 rcu_string_free(device->name); in device_list_add()
965 rcu_assign_pointer(device->name, name); in device_list_add()
966 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in device_list_add()
967 fs_devices->missing_devices--; in device_list_add()
968 clear_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in device_list_add()
970 device->devt = path_devt; in device_list_add()
979 if (!fs_devices->opened) { in device_list_add()
980 device->generation = found_transid; in device_list_add()
981 fs_devices->latest_generation = max_t(u64, found_transid, in device_list_add()
982 fs_devices->latest_generation); in device_list_add()
985 fs_devices->total_devices = btrfs_super_num_devices(disk_super); in device_list_add()
987 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
1000 fs_devices = alloc_fs_devices(orig->fsid, NULL); in clone_fs_devices()
1004 fs_devices->total_devices = orig->total_devices; in clone_fs_devices()
1006 list_for_each_entry(orig_dev, &orig->devices, dev_list) { in clone_fs_devices()
1013 if (orig_dev->name) in clone_fs_devices()
1014 dev_path = orig_dev->name->str; in clone_fs_devices()
1016 device = btrfs_alloc_device(NULL, &orig_dev->devid, in clone_fs_devices()
1017 orig_dev->uuid, dev_path); in clone_fs_devices()
1023 if (orig_dev->zone_info) { in clone_fs_devices()
1029 ret = -ENOMEM; in clone_fs_devices()
1032 device->zone_info = zone_info; in clone_fs_devices()
1035 list_add(&device->dev_list, &fs_devices->devices); in clone_fs_devices()
1036 device->fs_devices = fs_devices; in clone_fs_devices()
1037 fs_devices->num_devices++; in clone_fs_devices()
1050 /* This is the initialized path, it is safe to release the devices. */ in __btrfs_free_extra_devids()
1051 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) { in __btrfs_free_extra_devids()
1052 if (test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state)) { in __btrfs_free_extra_devids()
1054 &device->dev_state) && in __btrfs_free_extra_devids()
1056 &device->dev_state) && in __btrfs_free_extra_devids()
1058 device->generation > (*latest_dev)->generation)) { in __btrfs_free_extra_devids()
1068 if (device->devid == BTRFS_DEV_REPLACE_DEVID) in __btrfs_free_extra_devids()
1071 if (device->bdev) { in __btrfs_free_extra_devids()
1072 blkdev_put(device->bdev, device->holder); in __btrfs_free_extra_devids()
1073 device->bdev = NULL; in __btrfs_free_extra_devids()
1074 fs_devices->open_devices--; in __btrfs_free_extra_devids()
1076 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in __btrfs_free_extra_devids()
1077 list_del_init(&device->dev_alloc_list); in __btrfs_free_extra_devids()
1078 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in __btrfs_free_extra_devids()
1079 fs_devices->rw_devices--; in __btrfs_free_extra_devids()
1081 list_del_init(&device->dev_list); in __btrfs_free_extra_devids()
1082 fs_devices->num_devices--; in __btrfs_free_extra_devids()
1100 list_for_each_entry(seed_dev, &fs_devices->seed_list, seed_list) in btrfs_free_extra_devids()
1103 fs_devices->latest_dev = latest_dev; in btrfs_free_extra_devids()
1110 if (!device->bdev) in btrfs_close_bdev()
1113 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_close_bdev()
1114 sync_blockdev(device->bdev); in btrfs_close_bdev()
1115 invalidate_bdev(device->bdev); in btrfs_close_bdev()
1118 blkdev_put(device->bdev, device->holder); in btrfs_close_bdev()
1123 struct btrfs_fs_devices *fs_devices = device->fs_devices; in btrfs_close_one_device()
1125 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_close_one_device()
1126 device->devid != BTRFS_DEV_REPLACE_DEVID) { in btrfs_close_one_device()
1127 list_del_init(&device->dev_alloc_list); in btrfs_close_one_device()
1128 fs_devices->rw_devices--; in btrfs_close_one_device()
1131 if (device->devid == BTRFS_DEV_REPLACE_DEVID) in btrfs_close_one_device()
1132 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in btrfs_close_one_device()
1134 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in btrfs_close_one_device()
1135 clear_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in btrfs_close_one_device()
1136 fs_devices->missing_devices--; in btrfs_close_one_device()
1140 if (device->bdev) { in btrfs_close_one_device()
1141 fs_devices->open_devices--; in btrfs_close_one_device()
1142 device->bdev = NULL; in btrfs_close_one_device()
1144 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_close_one_device()
1147 device->fs_info = NULL; in btrfs_close_one_device()
1148 atomic_set(&device->dev_stats_ccnt, 0); in btrfs_close_one_device()
1149 extent_io_tree_release(&device->alloc_state); in btrfs_close_one_device()
1157 * (btrfs_check_rw_degradable() should not fail) - if after mounting the in btrfs_close_one_device()
1162 device->last_flush_error = 0; in btrfs_close_one_device()
1165 WARN_ON(test_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state)); in btrfs_close_one_device()
1166 WARN_ON(test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)); in btrfs_close_one_device()
1167 WARN_ON(!list_empty(&device->dev_alloc_list)); in btrfs_close_one_device()
1168 WARN_ON(!list_empty(&device->post_commit_list)); in btrfs_close_one_device()
1177 if (--fs_devices->opened > 0) in close_fs_devices()
1180 list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list) in close_fs_devices()
1183 WARN_ON(fs_devices->open_devices); in close_fs_devices()
1184 WARN_ON(fs_devices->rw_devices); in close_fs_devices()
1185 fs_devices->opened = 0; in close_fs_devices()
1186 fs_devices->seeding = false; in close_fs_devices()
1187 fs_devices->fs_info = NULL; in close_fs_devices()
1197 if (!fs_devices->opened) { in btrfs_close_devices()
1198 list_splice_init(&fs_devices->seed_list, &list); in btrfs_close_devices()
1202 * other device, it can be re-initialized during the next mount in btrfs_close_devices()
1203 * without the needing device-scan step. Therefore, it can be in btrfs_close_devices()
1206 if (fs_devices->num_devices == 1) { in btrfs_close_devices()
1207 list_del(&fs_devices->fs_list); in btrfs_close_devices()
1215 list_del(&fs_devices->seed_list); in btrfs_close_devices()
1228 list_for_each_entry_safe(device, tmp_device, &fs_devices->devices, in open_fs_devices()
1234 (!latest_dev || device->generation > latest_dev->generation)) { in open_fs_devices()
1236 } else if (ret == -ENODATA) { in open_fs_devices()
1237 fs_devices->num_devices--; in open_fs_devices()
1238 list_del(&device->dev_list); in open_fs_devices()
1242 if (fs_devices->open_devices == 0) in open_fs_devices()
1243 return -EINVAL; in open_fs_devices()
1245 fs_devices->opened = 1; in open_fs_devices()
1246 fs_devices->latest_dev = latest_dev; in open_fs_devices()
1247 fs_devices->total_rw_bytes = 0; in open_fs_devices()
1248 fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_REGULAR; in open_fs_devices()
1249 fs_devices->read_policy = BTRFS_READ_POLICY_PID; in open_fs_devices()
1262 if (dev1->devid < dev2->devid) in devid_cmp()
1263 return -1; in devid_cmp()
1264 else if (dev1->devid > dev2->devid) in devid_cmp()
1283 if (fs_devices->opened) { in btrfs_open_devices()
1284 fs_devices->opened++; in btrfs_open_devices()
1287 list_sort(NULL, &fs_devices->devices, devid_cmp); in btrfs_open_devices()
1311 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1315 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1319 if ((bytenr + sizeof(*disk_super) - 1) >> PAGE_SHIFT != index) in btrfs_read_disk_super()
1320 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1323 page = read_cache_page_gfp(bdev->bd_inode->i_mapping, index, GFP_KERNEL); in btrfs_read_disk_super()
1336 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1339 if (disk_super->label[0] && disk_super->label[BTRFS_LABEL_SIZE - 1]) in btrfs_read_disk_super()
1340 disk_super->label[BTRFS_LABEL_SIZE - 1] = 0; in btrfs_read_disk_super()
1357 * Look for a btrfs signature on a device. This may be called out of the mount path
1361 struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags) in btrfs_scan_one_device() argument
1380 * Avoid an exclusive open here, as the systemd-udev may initiate the in btrfs_scan_one_device()
1389 bdev = blkdev_get_by_path(path, flags, NULL, NULL); in btrfs_scan_one_device()
1406 device = device_list_add(path, disk_super, &new_device_added); in btrfs_scan_one_device()
1408 btrfs_free_stale_devices(device->devt, device); in btrfs_scan_one_device()
1427 lockdep_assert_held(&device->fs_info->chunk_mutex); in contains_pending_extent()
1429 if (find_first_extent_bit(&device->alloc_state, *start, in contains_pending_extent()
1435 physical_end - physical_start)) { in contains_pending_extent()
1445 switch (device->fs_devices->chunk_alloc_policy) { in dev_extent_search_start()
1464 u64 zone_size = device->zone_info->zone_size; in dev_extent_hole_check_zoned()
1476 *hole_size = *hole_start + *hole_size - pos; in dev_extent_hole_check_zoned()
1490 if (ret == -ERANGE) { in dev_extent_hole_check_zoned()
1497 *hole_size -= zone_size; in dev_extent_hole_check_zoned()
1528 *hole_size = hole_end - *hole_start; in dev_extent_hole_check()
1534 switch (device->fs_devices->chunk_alloc_policy) { in dev_extent_hole_check()
1589 struct btrfs_fs_info *fs_info = device->fs_info; in find_free_dev_extent()
1590 struct btrfs_root *root = fs_info->dev_root; in find_free_dev_extent()
1593 struct btrfs_path *path; in find_free_dev_extent() local
1599 u64 search_end = device->total_bytes; in find_free_dev_extent()
1607 WARN_ON(device->zone_info && in find_free_dev_extent()
1608 !IS_ALIGNED(num_bytes, device->zone_info->zone_size)); in find_free_dev_extent()
1610 path = btrfs_alloc_path(); in find_free_dev_extent()
1611 if (!path) { in find_free_dev_extent()
1612 ret = -ENOMEM; in find_free_dev_extent()
1617 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in find_free_dev_extent()
1618 ret = -ENOSPC; in find_free_dev_extent()
1622 path->reada = READA_FORWARD; in find_free_dev_extent()
1623 path->search_commit_root = 1; in find_free_dev_extent()
1624 path->skip_locking = 1; in find_free_dev_extent()
1626 key.objectid = device->devid; in find_free_dev_extent()
1630 ret = btrfs_search_backwards(root, &key, path); in find_free_dev_extent()
1635 l = path->nodes[0]; in find_free_dev_extent()
1636 slot = path->slots[0]; in find_free_dev_extent()
1638 ret = btrfs_next_leaf(root, path); in find_free_dev_extent()
1648 if (key.objectid < device->devid) in find_free_dev_extent()
1651 if (key.objectid > device->devid) in find_free_dev_extent()
1661 hole_size = key.offset - search_start; in find_free_dev_extent()
1691 path->slots[0]++; in find_free_dev_extent()
1701 hole_size = search_end - search_start; in find_free_dev_extent()
1704 btrfs_release_path(path); in find_free_dev_extent()
1716 ret = -ENOSPC; in find_free_dev_extent()
1722 btrfs_free_path(path); in find_free_dev_extent()
1733 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_free_dev_extent()
1734 struct btrfs_root *root = fs_info->dev_root; in btrfs_free_dev_extent()
1736 struct btrfs_path *path; in btrfs_free_dev_extent() local
1742 path = btrfs_alloc_path(); in btrfs_free_dev_extent()
1743 if (!path) in btrfs_free_dev_extent()
1744 return -ENOMEM; in btrfs_free_dev_extent()
1746 key.objectid = device->devid; in btrfs_free_dev_extent()
1750 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_free_dev_extent()
1752 ret = btrfs_previous_item(root, path, key.objectid, in btrfs_free_dev_extent()
1756 leaf = path->nodes[0]; in btrfs_free_dev_extent()
1757 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_free_dev_extent()
1758 extent = btrfs_item_ptr(leaf, path->slots[0], in btrfs_free_dev_extent()
1763 btrfs_release_path(path); in btrfs_free_dev_extent()
1766 leaf = path->nodes[0]; in btrfs_free_dev_extent()
1767 extent = btrfs_item_ptr(leaf, path->slots[0], in btrfs_free_dev_extent()
1775 ret = btrfs_del_item(trans, root, path); in btrfs_free_dev_extent()
1777 set_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags); in btrfs_free_dev_extent()
1779 btrfs_free_path(path); in btrfs_free_dev_extent()
1790 em_tree = &fs_info->mapping_tree; in find_next_chunk()
1791 read_lock(&em_tree->lock); in find_next_chunk()
1792 n = rb_last(&em_tree->map.rb_root); in find_next_chunk()
1795 ret = em->start + em->len; in find_next_chunk()
1797 read_unlock(&em_tree->lock); in find_next_chunk()
1808 struct btrfs_path *path; in find_next_devid() local
1810 path = btrfs_alloc_path(); in find_next_devid()
1811 if (!path) in find_next_devid()
1812 return -ENOMEM; in find_next_devid()
1816 key.offset = (u64)-1; in find_next_devid()
1818 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0); in find_next_devid()
1824 btrfs_err(fs_info, "corrupted chunk tree devid -1 matched"); in find_next_devid()
1825 ret = -EUCLEAN; in find_next_devid()
1829 ret = btrfs_previous_item(fs_info->chunk_root, path, in find_next_devid()
1835 btrfs_item_key_to_cpu(path->nodes[0], &found_key, in find_next_devid()
1836 path->slots[0]); in find_next_devid()
1841 btrfs_free_path(path); in find_next_devid()
1853 struct btrfs_path *path; in btrfs_add_dev_item() local
1859 path = btrfs_alloc_path(); in btrfs_add_dev_item()
1860 if (!path) in btrfs_add_dev_item()
1861 return -ENOMEM; in btrfs_add_dev_item()
1865 key.offset = device->devid; in btrfs_add_dev_item()
1868 ret = btrfs_insert_empty_item(trans, trans->fs_info->chunk_root, path, in btrfs_add_dev_item()
1874 leaf = path->nodes[0]; in btrfs_add_dev_item()
1875 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); in btrfs_add_dev_item()
1877 btrfs_set_device_id(leaf, dev_item, device->devid); in btrfs_add_dev_item()
1879 btrfs_set_device_type(leaf, dev_item, device->type); in btrfs_add_dev_item()
1880 btrfs_set_device_io_align(leaf, dev_item, device->io_align); in btrfs_add_dev_item()
1881 btrfs_set_device_io_width(leaf, dev_item, device->io_width); in btrfs_add_dev_item()
1882 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size); in btrfs_add_dev_item()
1893 write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); in btrfs_add_dev_item()
1895 write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid, in btrfs_add_dev_item()
1901 btrfs_free_path(path); in btrfs_add_dev_item()
1906 * Function to update ctime/mtime for a given device path.
1913 struct path path; in update_dev_time() local
1916 ret = kern_path(device_path, LOOKUP_FOLLOW, &path); in update_dev_time()
1920 inode_update_time(d_inode(path.dentry), S_MTIME | S_CTIME | S_VERSION); in update_dev_time()
1921 path_put(&path); in update_dev_time()
1927 struct btrfs_root *root = device->fs_info->chunk_root; in btrfs_rm_dev_item()
1929 struct btrfs_path *path; in btrfs_rm_dev_item() local
1932 path = btrfs_alloc_path(); in btrfs_rm_dev_item()
1933 if (!path) in btrfs_rm_dev_item()
1934 return -ENOMEM; in btrfs_rm_dev_item()
1938 key.offset = device->devid; in btrfs_rm_dev_item()
1941 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_rm_dev_item()
1945 ret = -ENOENT; in btrfs_rm_dev_item()
1949 ret = btrfs_del_item(trans, root, path); in btrfs_rm_dev_item()
1951 btrfs_free_path(path); in btrfs_rm_dev_item()
1968 seq = read_seqbegin(&fs_info->profiles_lock); in btrfs_check_raid_min_devices()
1970 all_avail = fs_info->avail_data_alloc_bits | in btrfs_check_raid_min_devices()
1971 fs_info->avail_system_alloc_bits | in btrfs_check_raid_min_devices()
1972 fs_info->avail_metadata_alloc_bits; in btrfs_check_raid_min_devices()
1973 } while (read_seqretry(&fs_info->profiles_lock, seq)); in btrfs_check_raid_min_devices()
1991 list_for_each_entry(next_device, &fs_devs->devices, dev_list) { in btrfs_find_next_active_device()
1993 !test_bit(BTRFS_DEV_STATE_MISSING, &next_device->dev_state) in btrfs_find_next_active_device()
1994 && next_device->bdev) in btrfs_find_next_active_device()
2010 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_assign_next_active_device()
2013 next_device = btrfs_find_next_active_device(fs_info->fs_devices, in btrfs_assign_next_active_device()
2017 if (fs_info->sb->s_bdev && in btrfs_assign_next_active_device()
2018 (fs_info->sb->s_bdev == device->bdev)) in btrfs_assign_next_active_device()
2019 fs_info->sb->s_bdev = next_device->bdev; in btrfs_assign_next_active_device()
2021 if (fs_info->fs_devices->latest_dev->bdev == device->bdev) in btrfs_assign_next_active_device()
2022 fs_info->fs_devices->latest_dev = next_device; in btrfs_assign_next_active_device()
2031 u64 num_devices = fs_info->fs_devices->num_devices; in btrfs_num_devices()
2033 down_read(&fs_info->dev_replace.rwsem); in btrfs_num_devices()
2034 if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) { in btrfs_num_devices()
2036 num_devices--; in btrfs_num_devices()
2038 up_read(&fs_info->dev_replace.rwsem); in btrfs_num_devices()
2047 const size_t len = sizeof(disk_super->magic); in btrfs_scratch_superblock()
2055 memset(&disk_super->magic, 0, len); in btrfs_scratch_superblock()
2059 ret = sync_blockdev_range(bdev, bytenr, bytenr + len - 1); in btrfs_scratch_superblock()
2084 /* Update ctime/mtime for device path for libblkid */ in btrfs_scratch_superblocks()
2095 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_rm_device()
2101 return -EINVAL; in btrfs_rm_device()
2111 ret = btrfs_check_raid_min_devices(fs_info, num_devices - 1); in btrfs_rm_device()
2115 device = btrfs_find_device(fs_info->fs_devices, args); in btrfs_rm_device()
2117 if (args->missing) in btrfs_rm_device()
2120 ret = -ENOENT; in btrfs_rm_device()
2127 btrfs_dev_name(device), device->devid); in btrfs_rm_device()
2128 return -ETXTBSY; in btrfs_rm_device()
2131 if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) in btrfs_rm_device()
2134 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_rm_device()
2135 fs_info->fs_devices->rw_devices == 1) in btrfs_rm_device()
2138 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_rm_device()
2139 mutex_lock(&fs_info->chunk_mutex); in btrfs_rm_device()
2140 list_del_init(&device->dev_alloc_list); in btrfs_rm_device()
2141 device->fs_devices->rw_devices--; in btrfs_rm_device()
2142 mutex_unlock(&fs_info->chunk_mutex); in btrfs_rm_device()
2149 trans = btrfs_start_transaction(fs_info->chunk_root, 0); in btrfs_rm_device()
2160 device->devid, ret); in btrfs_rm_device()
2166 clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_rm_device()
2182 * its own fs_devices listed under the fs_devices->seed_list. in btrfs_rm_device()
2184 cur_devices = device->fs_devices; in btrfs_rm_device()
2185 mutex_lock(&fs_devices->device_list_mutex); in btrfs_rm_device()
2186 list_del_rcu(&device->dev_list); in btrfs_rm_device()
2188 cur_devices->num_devices--; in btrfs_rm_device()
2189 cur_devices->total_devices--; in btrfs_rm_device()
2192 fs_devices->total_devices--; in btrfs_rm_device()
2194 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) in btrfs_rm_device()
2195 cur_devices->missing_devices--; in btrfs_rm_device()
2199 if (device->bdev) { in btrfs_rm_device()
2200 cur_devices->open_devices--; in btrfs_rm_device()
2205 num_devices = btrfs_super_num_devices(fs_info->super_copy) - 1; in btrfs_rm_device()
2206 btrfs_set_super_num_devices(fs_info->super_copy, num_devices); in btrfs_rm_device()
2207 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_rm_device()
2215 * write lock, and blkdev_put() will pull in the ->open_mutex on the in btrfs_rm_device()
2219 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_rm_device()
2220 btrfs_scratch_superblocks(fs_info, device->bdev, in btrfs_rm_device()
2221 device->name->str); in btrfs_rm_device()
2222 if (device->bdev) { in btrfs_rm_device()
2223 sync_blockdev(device->bdev); in btrfs_rm_device()
2224 invalidate_bdev(device->bdev); in btrfs_rm_device()
2228 *bdev = device->bdev; in btrfs_rm_device()
2229 *holder = device->holder; in btrfs_rm_device()
2237 * seed_devices, we can simply decrement cur_devices->opened and then in btrfs_rm_device()
2240 if (cur_devices->num_devices == 0) { in btrfs_rm_device()
2241 list_del_init(&cur_devices->seed_list); in btrfs_rm_device()
2242 ASSERT(cur_devices->opened == 1); in btrfs_rm_device()
2243 cur_devices->opened--; in btrfs_rm_device()
2252 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_rm_device()
2253 mutex_lock(&fs_info->chunk_mutex); in btrfs_rm_device()
2254 list_add(&device->dev_alloc_list, in btrfs_rm_device()
2255 &fs_devices->alloc_list); in btrfs_rm_device()
2256 device->fs_devices->rw_devices++; in btrfs_rm_device()
2257 mutex_unlock(&fs_info->chunk_mutex); in btrfs_rm_device()
2266 lockdep_assert_held(&srcdev->fs_info->fs_devices->device_list_mutex); in btrfs_rm_dev_replace_remove_srcdev()
2269 * in case of fs with no seed, srcdev->fs_devices will point in btrfs_rm_dev_replace_remove_srcdev()
2274 fs_devices = srcdev->fs_devices; in btrfs_rm_dev_replace_remove_srcdev()
2276 list_del_rcu(&srcdev->dev_list); in btrfs_rm_dev_replace_remove_srcdev()
2277 list_del(&srcdev->dev_alloc_list); in btrfs_rm_dev_replace_remove_srcdev()
2278 fs_devices->num_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2279 if (test_bit(BTRFS_DEV_STATE_MISSING, &srcdev->dev_state)) in btrfs_rm_dev_replace_remove_srcdev()
2280 fs_devices->missing_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2282 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &srcdev->dev_state)) in btrfs_rm_dev_replace_remove_srcdev()
2283 fs_devices->rw_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2285 if (srcdev->bdev) in btrfs_rm_dev_replace_remove_srcdev()
2286 fs_devices->open_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2291 struct btrfs_fs_devices *fs_devices = srcdev->fs_devices; in btrfs_rm_dev_replace_free_srcdev()
2300 if (!fs_devices->num_devices) { in btrfs_rm_dev_replace_free_srcdev()
2307 ASSERT(fs_devices->seeding); in btrfs_rm_dev_replace_free_srcdev()
2309 list_del_init(&fs_devices->seed_list); in btrfs_rm_dev_replace_free_srcdev()
2318 struct btrfs_fs_devices *fs_devices = tgtdev->fs_info->fs_devices; in btrfs_destroy_dev_replace_tgtdev()
2320 mutex_lock(&fs_devices->device_list_mutex); in btrfs_destroy_dev_replace_tgtdev()
2324 if (tgtdev->bdev) in btrfs_destroy_dev_replace_tgtdev()
2325 fs_devices->open_devices--; in btrfs_destroy_dev_replace_tgtdev()
2327 fs_devices->num_devices--; in btrfs_destroy_dev_replace_tgtdev()
2331 list_del_rcu(&tgtdev->dev_list); in btrfs_destroy_dev_replace_tgtdev()
2333 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_destroy_dev_replace_tgtdev()
2335 btrfs_scratch_superblocks(tgtdev->fs_info, tgtdev->bdev, in btrfs_destroy_dev_replace_tgtdev()
2336 tgtdev->name->str); in btrfs_destroy_dev_replace_tgtdev()
2344 * Populate args from device at path.
2348 * @path: the path to the device
2350 * This will read the super block of the device at @path and populate @args with
2354 * and does some basic sanity checks. The caller must make sure that @path is
2359 * Return: 0 for success, -errno for failure
2363 const char *path) in btrfs_get_dev_args_from_path() argument
2369 if (!path || !path[0]) in btrfs_get_dev_args_from_path()
2370 return -EINVAL; in btrfs_get_dev_args_from_path()
2371 if (!strcmp(path, "missing")) { in btrfs_get_dev_args_from_path()
2372 args->missing = true; in btrfs_get_dev_args_from_path()
2376 args->uuid = kzalloc(BTRFS_UUID_SIZE, GFP_KERNEL); in btrfs_get_dev_args_from_path()
2377 args->fsid = kzalloc(BTRFS_FSID_SIZE, GFP_KERNEL); in btrfs_get_dev_args_from_path()
2378 if (!args->uuid || !args->fsid) { in btrfs_get_dev_args_from_path()
2380 return -ENOMEM; in btrfs_get_dev_args_from_path()
2383 ret = btrfs_get_bdev_and_sb(path, BLK_OPEN_READ, NULL, 0, in btrfs_get_dev_args_from_path()
2390 args->devid = btrfs_stack_device_id(&disk_super->dev_item); in btrfs_get_dev_args_from_path()
2391 memcpy(args->uuid, disk_super->dev_item.uuid, BTRFS_UUID_SIZE); in btrfs_get_dev_args_from_path()
2393 memcpy(args->fsid, disk_super->metadata_uuid, BTRFS_FSID_SIZE); in btrfs_get_dev_args_from_path()
2395 memcpy(args->fsid, disk_super->fsid, BTRFS_FSID_SIZE); in btrfs_get_dev_args_from_path()
2403 * allocate our ->uuid and ->fsid pointers, everybody else uses local variables
2408 kfree(args->uuid); in btrfs_put_dev_args_from_path()
2409 kfree(args->fsid); in btrfs_put_dev_args_from_path()
2410 args->uuid = NULL; in btrfs_put_dev_args_from_path()
2411 args->fsid = NULL; in btrfs_put_dev_args_from_path()
2424 device = btrfs_find_device(fs_info->fs_devices, &args); in btrfs_find_device_by_devspec()
2426 return ERR_PTR(-ENOENT); in btrfs_find_device_by_devspec()
2433 device = btrfs_find_device(fs_info->fs_devices, &args); in btrfs_find_device_by_devspec()
2436 return ERR_PTR(-ENOENT); in btrfs_find_device_by_devspec()
2442 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_init_sprout()
2447 if (!fs_devices->seeding) in btrfs_init_sprout()
2448 return ERR_PTR(-EINVAL); in btrfs_init_sprout()
2452 * fs_info->fs_devices->seed_list in btrfs_init_sprout()
2470 list_add(&old_devices->fs_list, &fs_uuids); in btrfs_init_sprout()
2473 seed_devices->opened = 1; in btrfs_init_sprout()
2474 INIT_LIST_HEAD(&seed_devices->devices); in btrfs_init_sprout()
2475 INIT_LIST_HEAD(&seed_devices->alloc_list); in btrfs_init_sprout()
2476 mutex_init(&seed_devices->device_list_mutex); in btrfs_init_sprout()
2483 * Generate a new fsid for the sprouted read-write filesystem.
2488 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_setup_sprout()
2489 struct btrfs_super_block *disk_super = fs_info->super_copy; in btrfs_setup_sprout()
2502 * - All device ops and balance - as we are in btrfs_exclop_start. in btrfs_setup_sprout()
2503 * - Various dev_list readers - are using RCU. in btrfs_setup_sprout()
2504 * - btrfs_ioctl_fitrim() - is using RCU. in btrfs_setup_sprout()
2506 * For-read threads as below are using device_list_mutex: in btrfs_setup_sprout()
2507 * - Readonly scrub btrfs_scrub_dev() in btrfs_setup_sprout()
2508 * - Readonly scrub btrfs_scrub_progress() in btrfs_setup_sprout()
2509 * - btrfs_get_dev_stats() in btrfs_setup_sprout()
2511 lockdep_assert_held(&fs_devices->device_list_mutex); in btrfs_setup_sprout()
2513 list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices, in btrfs_setup_sprout()
2515 list_for_each_entry(device, &seed_devices->devices, dev_list) in btrfs_setup_sprout()
2516 device->fs_devices = seed_devices; in btrfs_setup_sprout()
2518 fs_devices->seeding = false; in btrfs_setup_sprout()
2519 fs_devices->num_devices = 0; in btrfs_setup_sprout()
2520 fs_devices->open_devices = 0; in btrfs_setup_sprout()
2521 fs_devices->missing_devices = 0; in btrfs_setup_sprout()
2522 fs_devices->rotating = false; in btrfs_setup_sprout()
2523 list_add(&seed_devices->seed_list, &fs_devices->seed_list); in btrfs_setup_sprout()
2525 generate_random_uuid(fs_devices->fsid); in btrfs_setup_sprout()
2526 memcpy(fs_devices->metadata_uuid, fs_devices->fsid, BTRFS_FSID_SIZE); in btrfs_setup_sprout()
2527 memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE); in btrfs_setup_sprout()
2540 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_finish_sprout()
2541 struct btrfs_root *root = fs_info->chunk_root; in btrfs_finish_sprout()
2542 struct btrfs_path *path; in btrfs_finish_sprout() local
2551 path = btrfs_alloc_path(); in btrfs_finish_sprout()
2552 if (!path) in btrfs_finish_sprout()
2553 return -ENOMEM; in btrfs_finish_sprout()
2561 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); in btrfs_finish_sprout()
2566 leaf = path->nodes[0]; in btrfs_finish_sprout()
2568 if (path->slots[0] >= btrfs_header_nritems(leaf)) { in btrfs_finish_sprout()
2569 ret = btrfs_next_leaf(root, path); in btrfs_finish_sprout()
2574 leaf = path->nodes[0]; in btrfs_finish_sprout()
2575 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_finish_sprout()
2576 btrfs_release_path(path); in btrfs_finish_sprout()
2580 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_finish_sprout()
2585 dev_item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_finish_sprout()
2594 device = btrfs_find_device(fs_info->fs_devices, &args); in btrfs_finish_sprout()
2597 if (device->fs_devices->seeding) { in btrfs_finish_sprout()
2599 device->generation); in btrfs_finish_sprout()
2603 path->slots[0]++; in btrfs_finish_sprout()
2608 btrfs_free_path(path); in btrfs_finish_sprout()
2614 struct btrfs_root *root = fs_info->dev_root; in btrfs_init_new_device()
2618 struct super_block *sb = fs_info->sb; in btrfs_init_new_device()
2619 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_init_new_device()
2627 if (sb_rdonly(sb) && !fs_devices->seeding) in btrfs_init_new_device()
2628 return -EROFS; in btrfs_init_new_device()
2631 fs_info->bdev_holder, NULL); in btrfs_init_new_device()
2636 ret = -EINVAL; in btrfs_init_new_device()
2640 if (fs_devices->seeding) { in btrfs_init_new_device()
2642 down_write(&sb->s_umount); in btrfs_init_new_device()
2650 list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) { in btrfs_init_new_device()
2651 if (device->bdev == bdev) { in btrfs_init_new_device()
2652 ret = -EEXIST; in btrfs_init_new_device()
2666 device->fs_info = fs_info; in btrfs_init_new_device()
2667 device->bdev = bdev; in btrfs_init_new_device()
2668 ret = lookup_bdev(device_path, &device->devt); in btrfs_init_new_device()
2682 set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_init_new_device()
2683 device->generation = trans->transid; in btrfs_init_new_device()
2684 device->io_width = fs_info->sectorsize; in btrfs_init_new_device()
2685 device->io_align = fs_info->sectorsize; in btrfs_init_new_device()
2686 device->sector_size = fs_info->sectorsize; in btrfs_init_new_device()
2687 device->total_bytes = in btrfs_init_new_device()
2688 round_down(bdev_nr_bytes(bdev), fs_info->sectorsize); in btrfs_init_new_device()
2689 device->disk_total_bytes = device->total_bytes; in btrfs_init_new_device()
2690 device->commit_total_bytes = device->total_bytes; in btrfs_init_new_device()
2691 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_init_new_device()
2692 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in btrfs_init_new_device()
2693 device->holder = fs_info->bdev_holder; in btrfs_init_new_device()
2694 device->dev_stats_valid = 1; in btrfs_init_new_device()
2695 set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE); in btrfs_init_new_device()
2709 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_new_device()
2712 btrfs_assign_next_active_device(fs_info->fs_devices->latest_dev, in btrfs_init_new_device()
2716 device->fs_devices = fs_devices; in btrfs_init_new_device()
2718 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2719 list_add_rcu(&device->dev_list, &fs_devices->devices); in btrfs_init_new_device()
2720 list_add(&device->dev_alloc_list, &fs_devices->alloc_list); in btrfs_init_new_device()
2721 fs_devices->num_devices++; in btrfs_init_new_device()
2722 fs_devices->open_devices++; in btrfs_init_new_device()
2723 fs_devices->rw_devices++; in btrfs_init_new_device()
2724 fs_devices->total_devices++; in btrfs_init_new_device()
2725 fs_devices->total_rw_bytes += device->total_bytes; in btrfs_init_new_device()
2727 atomic64_add(device->total_bytes, &fs_info->free_chunk_space); in btrfs_init_new_device()
2730 fs_devices->rotating = true; in btrfs_init_new_device()
2732 orig_super_total_bytes = btrfs_super_total_bytes(fs_info->super_copy); in btrfs_init_new_device()
2733 btrfs_set_super_total_bytes(fs_info->super_copy, in btrfs_init_new_device()
2734 round_down(orig_super_total_bytes + device->total_bytes, in btrfs_init_new_device()
2735 fs_info->sectorsize)); in btrfs_init_new_device()
2737 orig_super_num_devices = btrfs_super_num_devices(fs_info->super_copy); in btrfs_init_new_device()
2738 btrfs_set_super_num_devices(fs_info->super_copy, in btrfs_init_new_device()
2747 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2752 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_new_device()
2755 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2757 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2788 up_write(&sb->s_umount); in btrfs_init_new_device()
2800 if (PTR_ERR(trans) == -ENOENT) in btrfs_init_new_device()
2813 * We can ignore the return value as it typically returns -EINVAL and in btrfs_init_new_device()
2816 btrfs_forget_devices(device->devt); in btrfs_init_new_device()
2825 mutex_lock(&fs_info->fs_devices->device_list_mutex); in btrfs_init_new_device()
2826 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2827 list_del_rcu(&device->dev_list); in btrfs_init_new_device()
2828 list_del(&device->dev_alloc_list); in btrfs_init_new_device()
2829 fs_info->fs_devices->num_devices--; in btrfs_init_new_device()
2830 fs_info->fs_devices->open_devices--; in btrfs_init_new_device()
2831 fs_info->fs_devices->rw_devices--; in btrfs_init_new_device()
2832 fs_info->fs_devices->total_devices--; in btrfs_init_new_device()
2833 fs_info->fs_devices->total_rw_bytes -= device->total_bytes; in btrfs_init_new_device()
2834 atomic64_sub(device->total_bytes, &fs_info->free_chunk_space); in btrfs_init_new_device()
2835 btrfs_set_super_total_bytes(fs_info->super_copy, in btrfs_init_new_device()
2837 btrfs_set_super_num_devices(fs_info->super_copy, in btrfs_init_new_device()
2839 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2840 mutex_unlock(&fs_info->fs_devices->device_list_mutex); in btrfs_init_new_device()
2851 blkdev_put(bdev, fs_info->bdev_holder); in btrfs_init_new_device()
2854 up_write(&sb->s_umount); in btrfs_init_new_device()
2863 struct btrfs_path *path; in btrfs_update_device() local
2864 struct btrfs_root *root = device->fs_info->chunk_root; in btrfs_update_device()
2869 path = btrfs_alloc_path(); in btrfs_update_device()
2870 if (!path) in btrfs_update_device()
2871 return -ENOMEM; in btrfs_update_device()
2875 key.offset = device->devid; in btrfs_update_device()
2877 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); in btrfs_update_device()
2882 ret = -ENOENT; in btrfs_update_device()
2886 leaf = path->nodes[0]; in btrfs_update_device()
2887 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); in btrfs_update_device()
2889 btrfs_set_device_id(leaf, dev_item, device->devid); in btrfs_update_device()
2890 btrfs_set_device_type(leaf, dev_item, device->type); in btrfs_update_device()
2891 btrfs_set_device_io_align(leaf, dev_item, device->io_align); in btrfs_update_device()
2892 btrfs_set_device_io_width(leaf, dev_item, device->io_width); in btrfs_update_device()
2893 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size); in btrfs_update_device()
2901 btrfs_free_path(path); in btrfs_update_device()
2908 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_grow_device()
2909 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_grow_device()
2914 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) in btrfs_grow_device()
2915 return -EACCES; in btrfs_grow_device()
2917 new_size = round_down(new_size, fs_info->sectorsize); in btrfs_grow_device()
2919 mutex_lock(&fs_info->chunk_mutex); in btrfs_grow_device()
2921 diff = round_down(new_size - device->total_bytes, fs_info->sectorsize); in btrfs_grow_device()
2923 if (new_size <= device->total_bytes || in btrfs_grow_device()
2924 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in btrfs_grow_device()
2925 mutex_unlock(&fs_info->chunk_mutex); in btrfs_grow_device()
2926 return -EINVAL; in btrfs_grow_device()
2930 round_down(old_total + diff, fs_info->sectorsize)); in btrfs_grow_device()
2931 device->fs_devices->total_rw_bytes += diff; in btrfs_grow_device()
2935 btrfs_clear_space_info_full(device->fs_info); in btrfs_grow_device()
2936 if (list_empty(&device->post_commit_list)) in btrfs_grow_device()
2937 list_add_tail(&device->post_commit_list, in btrfs_grow_device()
2938 &trans->transaction->dev_update_list); in btrfs_grow_device()
2939 mutex_unlock(&fs_info->chunk_mutex); in btrfs_grow_device()
2950 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_free_chunk()
2951 struct btrfs_root *root = fs_info->chunk_root; in btrfs_free_chunk()
2953 struct btrfs_path *path; in btrfs_free_chunk() local
2956 path = btrfs_alloc_path(); in btrfs_free_chunk()
2957 if (!path) in btrfs_free_chunk()
2958 return -ENOMEM; in btrfs_free_chunk()
2964 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_free_chunk()
2968 btrfs_handle_fs_error(fs_info, -ENOENT, in btrfs_free_chunk()
2970 ret = -ENOENT; in btrfs_free_chunk()
2974 ret = btrfs_del_item(trans, root, path); in btrfs_free_chunk()
2979 btrfs_free_path(path); in btrfs_free_chunk()
2985 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_del_sys_chunk()
2996 lockdep_assert_held(&fs_info->chunk_mutex); in btrfs_del_sys_chunk()
2999 ptr = super_copy->sys_chunk_array; in btrfs_del_sys_chunk()
3013 ret = -EIO; in btrfs_del_sys_chunk()
3018 memmove(ptr, ptr + len, array_size - (cur + len)); in btrfs_del_sys_chunk()
3019 array_size -= len; in btrfs_del_sys_chunk()
3030 * btrfs_get_chunk_map() - Find the mapping containing the given logical extent.
3042 em_tree = &fs_info->mapping_tree; in btrfs_get_chunk_map()
3043 read_lock(&em_tree->lock); in btrfs_get_chunk_map()
3045 read_unlock(&em_tree->lock); in btrfs_get_chunk_map()
3049 "unable to find chunk map for logical %llu length %llu", in btrfs_get_chunk_map()
3051 return ERR_PTR(-EINVAL); in btrfs_get_chunk_map()
3054 if (em->start > logical || em->start + em->len <= logical) { in btrfs_get_chunk_map()
3056 "found a bad chunk map, wanted %llu-%llu, found %llu-%llu", in btrfs_get_chunk_map()
3057 logical, logical + length, em->start, em->start + em->len); in btrfs_get_chunk_map()
3059 return ERR_PTR(-EINVAL); in btrfs_get_chunk_map()
3067 struct map_lookup *map, u64 chunk_offset) in remove_chunk_item() argument
3076 lockdep_assert_held(&trans->fs_info->chunk_mutex); in remove_chunk_item()
3078 for (i = 0; i < map->num_stripes; i++) { in remove_chunk_item()
3081 ret = btrfs_update_device(trans, map->stripes[i].dev); in remove_chunk_item()
3091 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_remove_chunk()
3093 struct map_lookup *map; in btrfs_remove_chunk() local
3096 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_remove_chunk()
3108 map = em->map_lookup; in btrfs_remove_chunk()
3114 * fs_info->chunk_mutex. Note that here we do not acquire the chunk_mutex in btrfs_remove_chunk()
3116 * items from the devices btree - COWing an extent buffer from the btree in btrfs_remove_chunk()
3118 * lock again fs_info->chunk_mutex. in btrfs_remove_chunk()
3120 mutex_lock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3121 for (i = 0; i < map->num_stripes; i++) { in btrfs_remove_chunk()
3122 struct btrfs_device *device = map->stripes[i].dev; in btrfs_remove_chunk()
3124 map->stripes[i].physical, in btrfs_remove_chunk()
3127 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3132 if (device->bytes_used > 0) { in btrfs_remove_chunk()
3133 mutex_lock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3135 device->bytes_used - dev_extent_len); in btrfs_remove_chunk()
3136 atomic64_add(dev_extent_len, &fs_info->free_chunk_space); in btrfs_remove_chunk()
3138 mutex_unlock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3141 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3144 * We acquire fs_info->chunk_mutex for 2 reasons: in btrfs_remove_chunk()
3153 * that replaces the device object associated with the map's stripes, in btrfs_remove_chunk()
3156 * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the in btrfs_remove_chunk()
3164 trans->removing_chunk = true; in btrfs_remove_chunk()
3165 mutex_lock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3167 check_system_chunk(trans, map->type); in btrfs_remove_chunk()
3169 ret = remove_chunk_item(trans, map, chunk_offset); in btrfs_remove_chunk()
3171 * Normally we should not get -ENOSPC since we reserved space before in btrfs_remove_chunk()
3182 * So if we get -ENOSPC, allocate a new system chunk and retry once. in btrfs_remove_chunk()
3184 if (ret == -ENOSPC) { in btrfs_remove_chunk()
3201 ret = remove_chunk_item(trans, map, chunk_offset); in btrfs_remove_chunk()
3211 trace_btrfs_chunk_free(fs_info, map, chunk_offset, em->len); in btrfs_remove_chunk()
3213 if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) { in btrfs_remove_chunk()
3221 mutex_unlock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3222 trans->removing_chunk = false; in btrfs_remove_chunk()
3237 if (trans->removing_chunk) { in btrfs_remove_chunk()
3238 mutex_unlock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3239 trans->removing_chunk = false; in btrfs_remove_chunk()
3248 struct btrfs_root *root = fs_info->chunk_root; in btrfs_relocate_chunk()
3257 return -EINVAL; in btrfs_relocate_chunk()
3269 * we release the path used to search the chunk/dev tree and before in btrfs_relocate_chunk()
3272 lockdep_assert_held(&fs_info->reclaim_bgs_lock); in btrfs_relocate_chunk()
3290 return -ENOENT; in btrfs_relocate_chunk()
3291 btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group); in btrfs_relocate_chunk()
3292 length = block_group->length; in btrfs_relocate_chunk()
3309 trans = btrfs_start_trans_remove_block_group(root->fs_info, in btrfs_relocate_chunk()
3313 btrfs_handle_fs_error(root->fs_info, ret, NULL); in btrfs_relocate_chunk()
3328 struct btrfs_root *chunk_root = fs_info->chunk_root; in btrfs_relocate_sys_chunks()
3329 struct btrfs_path *path; in btrfs_relocate_sys_chunks() local
3339 path = btrfs_alloc_path(); in btrfs_relocate_sys_chunks()
3340 if (!path) in btrfs_relocate_sys_chunks()
3341 return -ENOMEM; in btrfs_relocate_sys_chunks()
3345 key.offset = (u64)-1; in btrfs_relocate_sys_chunks()
3349 mutex_lock(&fs_info->reclaim_bgs_lock); in btrfs_relocate_sys_chunks()
3350 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0); in btrfs_relocate_sys_chunks()
3352 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_relocate_sys_chunks()
3357 ret = btrfs_previous_item(chunk_root, path, key.objectid, in btrfs_relocate_sys_chunks()
3360 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_relocate_sys_chunks()
3366 leaf = path->nodes[0]; in btrfs_relocate_sys_chunks()
3367 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_relocate_sys_chunks()
3369 chunk = btrfs_item_ptr(leaf, path->slots[0], in btrfs_relocate_sys_chunks()
3372 btrfs_release_path(path); in btrfs_relocate_sys_chunks()
3376 if (ret == -ENOSPC) in btrfs_relocate_sys_chunks()
3381 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_relocate_sys_chunks()
3385 key.offset = found_key.offset - 1; in btrfs_relocate_sys_chunks()
3393 ret = -ENOSPC; in btrfs_relocate_sys_chunks()
3396 btrfs_free_path(path); in btrfs_relocate_sys_chunks()
3414 chunk_type = cache->flags; in btrfs_may_alloc_data_chunk()
3420 spin_lock(&fs_info->data_sinfo->lock); in btrfs_may_alloc_data_chunk()
3421 bytes_used = fs_info->data_sinfo->bytes_used; in btrfs_may_alloc_data_chunk()
3422 spin_unlock(&fs_info->data_sinfo->lock); in btrfs_may_alloc_data_chunk()
3428 trans = btrfs_join_transaction(fs_info->tree_root); in btrfs_may_alloc_data_chunk()
3445 struct btrfs_root *root = fs_info->tree_root; in insert_balance_item()
3449 struct btrfs_path *path; in insert_balance_item() local
3454 path = btrfs_alloc_path(); in insert_balance_item()
3455 if (!path) in insert_balance_item()
3456 return -ENOMEM; in insert_balance_item()
3460 btrfs_free_path(path); in insert_balance_item()
3468 ret = btrfs_insert_empty_item(trans, root, path, &key, in insert_balance_item()
3473 leaf = path->nodes[0]; in insert_balance_item()
3474 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item); in insert_balance_item()
3478 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->data); in insert_balance_item()
3480 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->meta); in insert_balance_item()
3482 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->sys); in insert_balance_item()
3485 btrfs_set_balance_flags(leaf, item, bctl->flags); in insert_balance_item()
3489 btrfs_free_path(path); in insert_balance_item()
3498 struct btrfs_root *root = fs_info->tree_root; in del_balance_item()
3500 struct btrfs_path *path; in del_balance_item() local
3504 path = btrfs_alloc_path(); in del_balance_item()
3505 if (!path) in del_balance_item()
3506 return -ENOMEM; in del_balance_item()
3510 btrfs_free_path(path); in del_balance_item()
3518 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in del_balance_item()
3522 ret = -ENOENT; in del_balance_item()
3526 ret = btrfs_del_item(trans, root, path); in del_balance_item()
3528 btrfs_free_path(path); in del_balance_item()
3544 if (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3545 bctl->data.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3546 if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3547 bctl->sys.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3548 if (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3549 bctl->meta.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3555 * converted - that will keep us from relocating unconverted in update_balance_args()
3558 if (!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3559 !(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3560 !(bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3561 bctl->data.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3562 bctl->data.usage = 90; in update_balance_args()
3564 if (!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3565 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3566 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3567 bctl->sys.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3568 bctl->sys.usage = 90; in update_balance_args()
3570 if (!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3571 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3572 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3573 bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3574 bctl->meta.usage = 90; in update_balance_args()
3583 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in reset_balance_state()
3586 BUG_ON(!fs_info->balance_ctl); in reset_balance_state()
3588 spin_lock(&fs_info->balance_lock); in reset_balance_state()
3589 fs_info->balance_ctl = NULL; in reset_balance_state()
3590 spin_unlock(&fs_info->balance_lock); in reset_balance_state()
3608 if (bargs->profiles & chunk_type) in chunk_profiles_filter()
3624 chunk_used = cache->used; in chunk_usage_range_filter()
3626 if (bargs->usage_min == 0) in chunk_usage_range_filter()
3629 user_thresh_min = mult_perc(cache->length, bargs->usage_min); in chunk_usage_range_filter()
3631 if (bargs->usage_max == 0) in chunk_usage_range_filter()
3633 else if (bargs->usage_max > 100) in chunk_usage_range_filter()
3634 user_thresh_max = cache->length; in chunk_usage_range_filter()
3636 user_thresh_max = mult_perc(cache->length, bargs->usage_max); in chunk_usage_range_filter()
3653 chunk_used = cache->used; in chunk_usage_filter()
3655 if (bargs->usage_min == 0) in chunk_usage_filter()
3657 else if (bargs->usage > 100) in chunk_usage_filter()
3658 user_thresh = cache->length; in chunk_usage_filter()
3660 user_thresh = mult_perc(cache->length, bargs->usage); in chunk_usage_filter()
3679 if (btrfs_stripe_devid(leaf, stripe) == bargs->devid) in chunk_devid_filter()
3692 return (num_stripes - nparity) / ncopies; in calc_data_stripes()
3708 if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID)) in chunk_drange_filter()
3716 if (btrfs_stripe_devid(leaf, stripe) != bargs->devid) in chunk_drange_filter()
3723 if (stripe_offset < bargs->pend && in chunk_drange_filter()
3724 stripe_offset + stripe_length > bargs->pstart) in chunk_drange_filter()
3737 if (chunk_offset < bargs->vend && in chunk_vrange_filter()
3738 chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart) in chunk_vrange_filter()
3751 if (bargs->stripes_min <= num_stripes in chunk_stripes_range_filter()
3752 && num_stripes <= bargs->stripes_max) in chunk_stripes_range_filter()
3761 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT)) in chunk_soft_convert_filter()
3767 if (bargs->target == chunk_type) in chunk_soft_convert_filter()
3776 struct btrfs_fs_info *fs_info = leaf->fs_info; in should_balance_chunk()
3777 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in should_balance_chunk()
3783 (bctl->flags & BTRFS_BALANCE_TYPE_MASK))) { in should_balance_chunk()
3788 bargs = &bctl->data; in should_balance_chunk()
3790 bargs = &bctl->sys; in should_balance_chunk()
3792 bargs = &bctl->meta; in should_balance_chunk()
3795 if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) && in should_balance_chunk()
3801 if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) && in should_balance_chunk()
3804 } else if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in should_balance_chunk()
3810 if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) && in should_balance_chunk()
3816 if ((bargs->flags & BTRFS_BALANCE_ARGS_DRANGE) && in should_balance_chunk()
3822 if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) && in should_balance_chunk()
3828 if ((bargs->flags & BTRFS_BALANCE_ARGS_STRIPES_RANGE) && in should_balance_chunk()
3834 if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) && in should_balance_chunk()
3842 if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT)) { in should_balance_chunk()
3843 if (bargs->limit == 0) in should_balance_chunk()
3846 bargs->limit--; in should_balance_chunk()
3847 } else if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT_RANGE)) { in should_balance_chunk()
3853 if (bargs->limit_max == 0) in should_balance_chunk()
3856 bargs->limit_max--; in should_balance_chunk()
3864 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in __btrfs_balance()
3865 struct btrfs_root *chunk_root = fs_info->chunk_root; in __btrfs_balance()
3868 struct btrfs_path *path = NULL; in __btrfs_balance() local
3877 u64 limit_data = bctl->data.limit; in __btrfs_balance()
3878 u64 limit_meta = bctl->meta.limit; in __btrfs_balance()
3879 u64 limit_sys = bctl->sys.limit; in __btrfs_balance()
3885 path = btrfs_alloc_path(); in __btrfs_balance()
3886 if (!path) { in __btrfs_balance()
3887 ret = -ENOMEM; in __btrfs_balance()
3892 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3893 memset(&bctl->stat, 0, sizeof(bctl->stat)); in __btrfs_balance()
3894 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3901 bctl->data.limit = limit_data; in __btrfs_balance()
3902 bctl->meta.limit = limit_meta; in __btrfs_balance()
3903 bctl->sys.limit = limit_sys; in __btrfs_balance()
3906 key.offset = (u64)-1; in __btrfs_balance()
3910 if ((!counting && atomic_read(&fs_info->balance_pause_req)) || in __btrfs_balance()
3911 atomic_read(&fs_info->balance_cancel_req)) { in __btrfs_balance()
3912 ret = -ECANCELED; in __btrfs_balance()
3916 mutex_lock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
3917 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0); in __btrfs_balance()
3919 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
3930 ret = btrfs_previous_item(chunk_root, path, 0, in __btrfs_balance()
3933 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
3938 leaf = path->nodes[0]; in __btrfs_balance()
3939 slot = path->slots[0]; in __btrfs_balance()
3943 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
3951 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3952 bctl->stat.considered++; in __btrfs_balance()
3953 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3958 btrfs_release_path(path); in __btrfs_balance()
3960 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
3965 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
3966 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3967 bctl->stat.expected++; in __btrfs_balance()
3968 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3985 count_data < bctl->data.limit_min) in __btrfs_balance()
3987 count_meta < bctl->meta.limit_min) in __btrfs_balance()
3989 count_sys < bctl->sys.limit_min)) { in __btrfs_balance()
3990 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
4004 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
4012 mutex_unlock(&fs_info->reclaim_bgs_lock); in __btrfs_balance()
4013 if (ret == -ENOSPC) { in __btrfs_balance()
4015 } else if (ret == -ETXTBSY) { in __btrfs_balance()
4023 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
4024 bctl->stat.completed++; in __btrfs_balance()
4025 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
4030 key.offset = found_key.offset - 1; in __btrfs_balance()
4034 btrfs_release_path(path); in __btrfs_balance()
4039 btrfs_free_path(path); in __btrfs_balance()
4044 ret = -ENOSPC; in __btrfs_balance()
4082 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT)) in validate_convert_profile()
4086 if (alloc_profile_is_valid(bargs->target, 1) && in validate_convert_profile()
4087 (bargs->target & ~allowed) == 0) in validate_convert_profile()
4091 type, btrfs_bg_type_to_raid_name(bargs->target)); in validate_convert_profile()
4106 u64 flags = bargs->flags; in describe_balance_args()
4117 size_bp -= ret; \ in describe_balance_args()
4126 size_bp -= ret; \ in describe_balance_args()
4135 size_bp -= ret; \ in describe_balance_args()
4141 btrfs_bg_type_to_raid_name(bargs->target)); in describe_balance_args()
4147 btrfs_describe_block_groups(bargs->profiles, tmp_buf, in describe_balance_args()
4153 CHECK_APPEND_1ARG("usage=%llu,", bargs->usage); in describe_balance_args()
4157 bargs->usage_min, bargs->usage_max); in describe_balance_args()
4160 CHECK_APPEND_1ARG("devid=%llu,", bargs->devid); in describe_balance_args()
4164 bargs->pstart, bargs->pend); in describe_balance_args()
4168 bargs->vstart, bargs->vend); in describe_balance_args()
4171 CHECK_APPEND_1ARG("limit=%llu,", bargs->limit); in describe_balance_args()
4175 bargs->limit_min, bargs->limit_max); in describe_balance_args()
4179 bargs->stripes_min, bargs->stripes_max); in describe_balance_args()
4188 buf[size_buf - size_bp - 1] = '\0'; /* remove last , */ in describe_balance_args()
4201 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in describe_balance_start_or_resume()
4214 size_bp -= ret; \ in describe_balance_start_or_resume()
4218 if (bctl->flags & BTRFS_BALANCE_FORCE) in describe_balance_start_or_resume()
4219 CHECK_APPEND_1ARG("%s", "-f "); in describe_balance_start_or_resume()
4221 if (bctl->flags & BTRFS_BALANCE_DATA) { in describe_balance_start_or_resume()
4222 describe_balance_args(&bctl->data, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4223 CHECK_APPEND_1ARG("-d%s ", tmp_buf); in describe_balance_start_or_resume()
4226 if (bctl->flags & BTRFS_BALANCE_METADATA) { in describe_balance_start_or_resume()
4227 describe_balance_args(&bctl->meta, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4228 CHECK_APPEND_1ARG("-m%s ", tmp_buf); in describe_balance_start_or_resume()
4231 if (bctl->flags & BTRFS_BALANCE_SYSTEM) { in describe_balance_start_or_resume()
4232 describe_balance_args(&bctl->sys, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4233 CHECK_APPEND_1ARG("-s%s ", tmp_buf); in describe_balance_start_or_resume()
4241 buf[size_buf - size_bp - 1] = '\0'; /* remove last " " */ in describe_balance_start_or_resume()
4243 (bctl->flags & BTRFS_BALANCE_RESUME) ? in describe_balance_start_or_resume()
4267 atomic_read(&fs_info->balance_pause_req) || in btrfs_balance()
4269 ret = -EINVAL; in btrfs_balance()
4273 allowed = btrfs_super_incompat_flags(fs_info->super_copy); in btrfs_balance()
4282 if (mixed && (bctl->flags & allowed)) { in btrfs_balance()
4283 if (!(bctl->flags & BTRFS_BALANCE_DATA) || in btrfs_balance()
4284 !(bctl->flags & BTRFS_BALANCE_METADATA) || in btrfs_balance()
4285 memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) { in btrfs_balance()
4288 ret = -EINVAL; in btrfs_balance()
4297 num_devices = fs_info->fs_devices->rw_devices; in btrfs_balance()
4300 * SINGLE profile on-disk has no profile bit, but in-memory we have a in btrfs_balance()
4309 if (!validate_convert_profile(fs_info, &bctl->data, allowed, "data") || in btrfs_balance()
4310 !validate_convert_profile(fs_info, &bctl->meta, allowed, "metadata") || in btrfs_balance()
4311 !validate_convert_profile(fs_info, &bctl->sys, allowed, "system")) { in btrfs_balance()
4312 ret = -EINVAL; in btrfs_balance()
4327 seq = read_seqbegin(&fs_info->profiles_lock); in btrfs_balance()
4329 if (((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) && in btrfs_balance()
4330 (fs_info->avail_system_alloc_bits & allowed) && in btrfs_balance()
4331 !(bctl->sys.target & allowed)) || in btrfs_balance()
4332 ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) && in btrfs_balance()
4333 (fs_info->avail_metadata_alloc_bits & allowed) && in btrfs_balance()
4334 !(bctl->meta.target & allowed))) in btrfs_balance()
4340 meta_target = (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) ? in btrfs_balance()
4341 bctl->meta.target : fs_info->avail_metadata_alloc_bits; in btrfs_balance()
4342 data_target = (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) ? in btrfs_balance()
4343 bctl->data.target : fs_info->avail_data_alloc_bits; in btrfs_balance()
4344 } while (read_seqretry(&fs_info->profiles_lock, seq)); in btrfs_balance()
4347 if (bctl->flags & BTRFS_BALANCE_FORCE) { in btrfs_balance()
4352 "balance: reduces metadata redundancy, use --force if you want this"); in btrfs_balance()
4353 ret = -EINVAL; in btrfs_balance()
4367 if (ret && ret != -EEXIST) in btrfs_balance()
4370 if (!(bctl->flags & BTRFS_BALANCE_RESUME)) { in btrfs_balance()
4371 BUG_ON(ret == -EEXIST); in btrfs_balance()
4372 BUG_ON(fs_info->balance_ctl); in btrfs_balance()
4373 spin_lock(&fs_info->balance_lock); in btrfs_balance()
4374 fs_info->balance_ctl = bctl; in btrfs_balance()
4375 spin_unlock(&fs_info->balance_lock); in btrfs_balance()
4377 BUG_ON(ret != -EEXIST); in btrfs_balance()
4378 spin_lock(&fs_info->balance_lock); in btrfs_balance()
4380 spin_unlock(&fs_info->balance_lock); in btrfs_balance()
4383 ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_balance()
4384 set_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags); in btrfs_balance()
4386 mutex_unlock(&fs_info->balance_mutex); in btrfs_balance()
4390 mutex_lock(&fs_info->balance_mutex); in btrfs_balance()
4391 if (ret == -ECANCELED && atomic_read(&fs_info->balance_pause_req)) { in btrfs_balance()
4399 * - Regular cancel request in btrfs_balance()
4400 * Then ret == -ECANCELED and balance_cancel_req > 0 in btrfs_balance()
4402 * - Fatal signal to "btrfs" process in btrfs_balance()
4404 * got -EINTR, or caught by btrfs_should_cancel_balance() and in btrfs_balance()
4405 * got -ECANCELED. in btrfs_balance()
4407 * ret == -EINTR or ret == -ECANCELED. in btrfs_balance()
4411 else if (ret == -ECANCELED || ret == -EINTR) in btrfs_balance()
4416 clear_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags); in btrfs_balance()
4429 wake_up(&fs_info->balance_wait_q); in btrfs_balance()
4433 if (bctl->flags & BTRFS_BALANCE_RESUME) in btrfs_balance()
4447 sb_start_write(fs_info->sb); in balance_kthread()
4448 mutex_lock(&fs_info->balance_mutex); in balance_kthread()
4449 if (fs_info->balance_ctl) in balance_kthread()
4450 ret = btrfs_balance(fs_info, fs_info->balance_ctl, NULL); in balance_kthread()
4451 mutex_unlock(&fs_info->balance_mutex); in balance_kthread()
4452 sb_end_write(fs_info->sb); in balance_kthread()
4461 mutex_lock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4462 if (!fs_info->balance_ctl) { in btrfs_resume_balance_async()
4463 mutex_unlock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4466 mutex_unlock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4473 spin_lock(&fs_info->super_lock); in btrfs_resume_balance_async()
4474 ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED); in btrfs_resume_balance_async()
4475 fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE; in btrfs_resume_balance_async()
4476 spin_unlock(&fs_info->super_lock); in btrfs_resume_balance_async()
4478 * A ro->rw remount sequence should continue with the paused balance in btrfs_resume_balance_async()
4482 spin_lock(&fs_info->balance_lock); in btrfs_resume_balance_async()
4483 fs_info->balance_ctl->flags |= BTRFS_BALANCE_RESUME; in btrfs_resume_balance_async()
4484 spin_unlock(&fs_info->balance_lock); in btrfs_resume_balance_async()
4486 tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance"); in btrfs_resume_balance_async()
4495 struct btrfs_path *path; in btrfs_recover_balance() local
4500 path = btrfs_alloc_path(); in btrfs_recover_balance()
4501 if (!path) in btrfs_recover_balance()
4502 return -ENOMEM; in btrfs_recover_balance()
4508 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); in btrfs_recover_balance()
4511 if (ret > 0) { /* ret = -ENOENT; */ in btrfs_recover_balance()
4518 ret = -ENOMEM; in btrfs_recover_balance()
4522 leaf = path->nodes[0]; in btrfs_recover_balance()
4523 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item); in btrfs_recover_balance()
4525 bctl->flags = btrfs_balance_flags(leaf, item); in btrfs_recover_balance()
4526 bctl->flags |= BTRFS_BALANCE_RESUME; in btrfs_recover_balance()
4529 btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs); in btrfs_recover_balance()
4531 btrfs_disk_balance_args_to_cpu(&bctl->meta, &disk_bargs); in btrfs_recover_balance()
4533 btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs); in btrfs_recover_balance()
4549 btrfs_release_path(path); in btrfs_recover_balance()
4551 mutex_lock(&fs_info->balance_mutex); in btrfs_recover_balance()
4552 BUG_ON(fs_info->balance_ctl); in btrfs_recover_balance()
4553 spin_lock(&fs_info->balance_lock); in btrfs_recover_balance()
4554 fs_info->balance_ctl = bctl; in btrfs_recover_balance()
4555 spin_unlock(&fs_info->balance_lock); in btrfs_recover_balance()
4556 mutex_unlock(&fs_info->balance_mutex); in btrfs_recover_balance()
4558 btrfs_free_path(path); in btrfs_recover_balance()
4566 mutex_lock(&fs_info->balance_mutex); in btrfs_pause_balance()
4567 if (!fs_info->balance_ctl) { in btrfs_pause_balance()
4568 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4569 return -ENOTCONN; in btrfs_pause_balance()
4572 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { in btrfs_pause_balance()
4573 atomic_inc(&fs_info->balance_pause_req); in btrfs_pause_balance()
4574 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4576 wait_event(fs_info->balance_wait_q, in btrfs_pause_balance()
4577 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_pause_balance()
4579 mutex_lock(&fs_info->balance_mutex); in btrfs_pause_balance()
4581 BUG_ON(test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_pause_balance()
4582 atomic_dec(&fs_info->balance_pause_req); in btrfs_pause_balance()
4584 ret = -ENOTCONN; in btrfs_pause_balance()
4587 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4593 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4594 if (!fs_info->balance_ctl) { in btrfs_cancel_balance()
4595 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4596 return -ENOTCONN; in btrfs_cancel_balance()
4601 * mount time if the mount is read-write. Otherwise it's still paused in btrfs_cancel_balance()
4604 if (sb_rdonly(fs_info->sb)) { in btrfs_cancel_balance()
4605 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4606 return -EROFS; in btrfs_cancel_balance()
4609 atomic_inc(&fs_info->balance_cancel_req); in btrfs_cancel_balance()
4614 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { in btrfs_cancel_balance()
4615 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4616 wait_event(fs_info->balance_wait_q, in btrfs_cancel_balance()
4617 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_cancel_balance()
4618 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4620 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4625 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4627 if (fs_info->balance_ctl) { in btrfs_cancel_balance()
4634 ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_cancel_balance()
4635 atomic_dec(&fs_info->balance_cancel_req); in btrfs_cancel_balance()
4636 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4643 struct btrfs_root *root = fs_info->tree_root; in btrfs_uuid_scan_kthread()
4645 struct btrfs_path *path = NULL; in btrfs_uuid_scan_kthread() local
4654 path = btrfs_alloc_path(); in btrfs_uuid_scan_kthread()
4655 if (!path) { in btrfs_uuid_scan_kthread()
4656 ret = -ENOMEM; in btrfs_uuid_scan_kthread()
4669 ret = btrfs_search_forward(root, &key, path, in btrfs_uuid_scan_kthread()
4683 eb = path->nodes[0]; in btrfs_uuid_scan_kthread()
4684 slot = path->slots[0]; in btrfs_uuid_scan_kthread()
4700 btrfs_release_path(path); in btrfs_uuid_scan_kthread()
4702 * 1 - subvol uuid item in btrfs_uuid_scan_kthread()
4703 * 1 - received_subvol uuid item in btrfs_uuid_scan_kthread()
4705 trans = btrfs_start_transaction(fs_info->uuid_root, 2); in btrfs_uuid_scan_kthread()
4715 btrfs_release_path(path); in btrfs_uuid_scan_kthread()
4740 btrfs_release_path(path); in btrfs_uuid_scan_kthread()
4748 if (key.offset < (u64)-1) { in btrfs_uuid_scan_kthread()
4753 } else if (key.objectid < (u64)-1) { in btrfs_uuid_scan_kthread()
4764 btrfs_free_path(path); in btrfs_uuid_scan_kthread()
4770 set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags); in btrfs_uuid_scan_kthread()
4771 up(&fs_info->uuid_tree_rescan_sem); in btrfs_uuid_scan_kthread()
4778 struct btrfs_root *tree_root = fs_info->tree_root; in btrfs_create_uuid_tree()
4784 * 1 - root node in btrfs_create_uuid_tree()
4785 * 1 - root item in btrfs_create_uuid_tree()
4799 fs_info->uuid_root = uuid_root; in btrfs_create_uuid_tree()
4805 down(&fs_info->uuid_tree_rescan_sem); in btrfs_create_uuid_tree()
4806 task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid"); in btrfs_create_uuid_tree()
4808 /* fs_info->update_uuid_tree_gen remains 0 in all error case */ in btrfs_create_uuid_tree()
4810 up(&fs_info->uuid_tree_rescan_sem); in btrfs_create_uuid_tree()
4824 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_shrink_device()
4825 struct btrfs_root *root = fs_info->dev_root; in btrfs_shrink_device()
4828 struct btrfs_path *path; in btrfs_shrink_device() local
4837 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_shrink_device()
4843 new_size = round_down(new_size, fs_info->sectorsize); in btrfs_shrink_device()
4845 diff = round_down(old_size - new_size, fs_info->sectorsize); in btrfs_shrink_device()
4847 if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) in btrfs_shrink_device()
4848 return -EINVAL; in btrfs_shrink_device()
4850 path = btrfs_alloc_path(); in btrfs_shrink_device()
4851 if (!path) in btrfs_shrink_device()
4852 return -ENOMEM; in btrfs_shrink_device()
4854 path->reada = READA_BACK; in btrfs_shrink_device()
4858 btrfs_free_path(path); in btrfs_shrink_device()
4862 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4865 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_shrink_device()
4866 device->fs_devices->total_rw_bytes -= diff; in btrfs_shrink_device()
4867 atomic64_sub(diff, &fs_info->free_chunk_space); in btrfs_shrink_device()
4872 * in-memory chunks are synced to disk so that the loop below sees them in btrfs_shrink_device()
4876 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4881 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4886 key.objectid = device->devid; in btrfs_shrink_device()
4887 key.offset = (u64)-1; in btrfs_shrink_device()
4891 mutex_lock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4892 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); in btrfs_shrink_device()
4894 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4898 ret = btrfs_previous_item(root, path, 0, key.type); in btrfs_shrink_device()
4900 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4904 btrfs_release_path(path); in btrfs_shrink_device()
4908 l = path->nodes[0]; in btrfs_shrink_device()
4909 slot = path->slots[0]; in btrfs_shrink_device()
4910 btrfs_item_key_to_cpu(l, &key, path->slots[0]); in btrfs_shrink_device()
4912 if (key.objectid != device->devid) { in btrfs_shrink_device()
4913 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4914 btrfs_release_path(path); in btrfs_shrink_device()
4922 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4923 btrfs_release_path(path); in btrfs_shrink_device()
4928 btrfs_release_path(path); in btrfs_shrink_device()
4938 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4943 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_shrink_device()
4944 if (ret == -ENOSPC) { in btrfs_shrink_device()
4947 if (ret == -ETXTBSY) { in btrfs_shrink_device()
4954 } while (key.offset-- > 0); in btrfs_shrink_device()
4961 ret = -ENOSPC; in btrfs_shrink_device()
4972 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4974 clear_extent_bits(&device->alloc_state, new_size, (u64)-1, in btrfs_shrink_device()
4978 if (list_empty(&device->post_commit_list)) in btrfs_shrink_device()
4979 list_add_tail(&device->post_commit_list, in btrfs_shrink_device()
4980 &trans->transaction->dev_update_list); in btrfs_shrink_device()
4984 round_down(old_total - diff, fs_info->sectorsize)); in btrfs_shrink_device()
4985 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4988 /* Now btrfs_update_device() will change the on-disk size. */ in btrfs_shrink_device()
4998 btrfs_free_path(path); in btrfs_shrink_device()
5000 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
5002 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) in btrfs_shrink_device()
5003 device->fs_devices->total_rw_bytes += diff; in btrfs_shrink_device()
5004 atomic64_add(diff, &fs_info->free_chunk_space); in btrfs_shrink_device()
5005 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
5014 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_add_system_chunk()
5019 lockdep_assert_held(&fs_info->chunk_mutex); in btrfs_add_system_chunk()
5024 return -EFBIG; in btrfs_add_system_chunk()
5026 ptr = super_copy->sys_chunk_array + array_size; in btrfs_add_system_chunk()
5045 if (di_a->max_avail > di_b->max_avail) in btrfs_cmp_device_info()
5046 return -1; in btrfs_cmp_device_info()
5047 if (di_a->max_avail < di_b->max_avail) in btrfs_cmp_device_info()
5049 if (di_a->total_avail > di_b->total_avail) in btrfs_cmp_device_info()
5050 return -1; in btrfs_cmp_device_info()
5051 if (di_a->total_avail < di_b->total_avail) in btrfs_cmp_device_info()
5081 /* sub_stripes info for map */
5109 space_info = btrfs_find_space_info(fs_devices->fs_info, ctl->type); in init_alloc_chunk_ctl_policy_regular()
5112 ctl->max_chunk_size = READ_ONCE(space_info->chunk_size); in init_alloc_chunk_ctl_policy_regular()
5113 ctl->max_stripe_size = min_t(u64, ctl->max_chunk_size, SZ_1G); in init_alloc_chunk_ctl_policy_regular()
5115 if (ctl->type & BTRFS_BLOCK_GROUP_SYSTEM) in init_alloc_chunk_ctl_policy_regular()
5116 ctl->devs_max = min_t(int, ctl->devs_max, BTRFS_MAX_DEVS_SYS_CHUNK); in init_alloc_chunk_ctl_policy_regular()
5119 ctl->max_chunk_size = min(mult_perc(fs_devices->total_rw_bytes, 10), in init_alloc_chunk_ctl_policy_regular()
5120 ctl->max_chunk_size); in init_alloc_chunk_ctl_policy_regular()
5121 ctl->dev_extent_min = btrfs_stripe_nr_to_offset(ctl->dev_stripes); in init_alloc_chunk_ctl_policy_regular()
5128 u64 zone_size = fs_devices->fs_info->zone_size; in init_alloc_chunk_ctl_policy_zoned()
5130 int min_num_stripes = ctl->devs_min * ctl->dev_stripes; in init_alloc_chunk_ctl_policy_zoned()
5131 int min_data_stripes = (min_num_stripes - ctl->nparity) / ctl->ncopies; in init_alloc_chunk_ctl_policy_zoned()
5133 u64 type = ctl->type; in init_alloc_chunk_ctl_policy_zoned()
5135 ctl->max_stripe_size = zone_size; in init_alloc_chunk_ctl_policy_zoned()
5137 ctl->max_chunk_size = round_down(BTRFS_MAX_DATA_CHUNK_SIZE, in init_alloc_chunk_ctl_policy_zoned()
5140 ctl->max_chunk_size = ctl->max_stripe_size; in init_alloc_chunk_ctl_policy_zoned()
5142 ctl->max_chunk_size = 2 * ctl->max_stripe_size; in init_alloc_chunk_ctl_policy_zoned()
5143 ctl->devs_max = min_t(int, ctl->devs_max, in init_alloc_chunk_ctl_policy_zoned()
5150 limit = max(round_down(mult_perc(fs_devices->total_rw_bytes, 10), in init_alloc_chunk_ctl_policy_zoned()
5153 ctl->max_chunk_size = min(limit, ctl->max_chunk_size); in init_alloc_chunk_ctl_policy_zoned()
5154 ctl->dev_extent_min = zone_size * ctl->dev_stripes; in init_alloc_chunk_ctl_policy_zoned()
5160 int index = btrfs_bg_flags_to_raid_index(ctl->type); in init_alloc_chunk_ctl()
5162 ctl->sub_stripes = btrfs_raid_array[index].sub_stripes; in init_alloc_chunk_ctl()
5163 ctl->dev_stripes = btrfs_raid_array[index].dev_stripes; in init_alloc_chunk_ctl()
5164 ctl->devs_max = btrfs_raid_array[index].devs_max; in init_alloc_chunk_ctl()
5165 if (!ctl->devs_max) in init_alloc_chunk_ctl()
5166 ctl->devs_max = BTRFS_MAX_DEVS(fs_devices->fs_info); in init_alloc_chunk_ctl()
5167 ctl->devs_min = btrfs_raid_array[index].devs_min; in init_alloc_chunk_ctl()
5168 ctl->devs_increment = btrfs_raid_array[index].devs_increment; in init_alloc_chunk_ctl()
5169 ctl->ncopies = btrfs_raid_array[index].ncopies; in init_alloc_chunk_ctl()
5170 ctl->nparity = btrfs_raid_array[index].nparity; in init_alloc_chunk_ctl()
5171 ctl->ndevs = 0; in init_alloc_chunk_ctl()
5173 switch (fs_devices->chunk_alloc_policy) { in init_alloc_chunk_ctl()
5189 struct btrfs_fs_info *info = fs_devices->fs_info; in gather_device_info()
5192 u64 dev_extent_want = ctl->max_stripe_size * ctl->dev_stripes; in gather_device_info()
5202 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) { in gather_device_info()
5203 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in gather_device_info()
5205 "BTRFS: read-only device in alloc_list\n"); in gather_device_info()
5210 &device->dev_state) || in gather_device_info()
5211 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) in gather_device_info()
5214 if (device->total_bytes > device->bytes_used) in gather_device_info()
5215 total_avail = device->total_bytes - device->bytes_used; in gather_device_info()
5220 if (total_avail < ctl->dev_extent_min) in gather_device_info()
5225 if (ret && ret != -ENOSPC) in gather_device_info()
5231 if (max_avail < ctl->dev_extent_min) { in gather_device_info()
5235 __func__, device->devid, max_avail, in gather_device_info()
5236 ctl->dev_extent_min); in gather_device_info()
5240 if (ndevs == fs_devices->rw_devices) { in gather_device_info()
5242 __func__, fs_devices->rw_devices); in gather_device_info()
5251 ctl->ndevs = ndevs; in gather_device_info()
5275 ctl->stripe_size = div_u64(devices_info[ctl->ndevs - 1].max_avail, in decide_stripe_size_regular()
5276 ctl->dev_stripes); in decide_stripe_size_regular()
5277 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; in decide_stripe_size_regular()
5280 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; in decide_stripe_size_regular()
5288 if (ctl->stripe_size * data_stripes > ctl->max_chunk_size) { in decide_stripe_size_regular()
5294 ctl->stripe_size = min(round_up(div_u64(ctl->max_chunk_size, in decide_stripe_size_regular()
5296 ctl->stripe_size); in decide_stripe_size_regular()
5300 ctl->stripe_size = min_t(u64, ctl->stripe_size, SZ_1G); in decide_stripe_size_regular()
5303 ctl->stripe_size = round_down(ctl->stripe_size, BTRFS_STRIPE_LEN); in decide_stripe_size_regular()
5304 ctl->chunk_size = ctl->stripe_size * data_stripes; in decide_stripe_size_regular()
5312 u64 zone_size = devices_info[0].dev->zone_info->zone_size; in decide_stripe_size_zoned()
5320 ASSERT(devices_info[ctl->ndevs - 1].max_avail == ctl->dev_extent_min); in decide_stripe_size_zoned()
5322 ctl->stripe_size = zone_size; in decide_stripe_size_zoned()
5323 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; in decide_stripe_size_zoned()
5324 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; in decide_stripe_size_zoned()
5327 if (ctl->stripe_size * data_stripes > ctl->max_chunk_size) { in decide_stripe_size_zoned()
5328 ctl->ndevs = div_u64(div_u64(ctl->max_chunk_size * ctl->ncopies, in decide_stripe_size_zoned()
5329 ctl->stripe_size) + ctl->nparity, in decide_stripe_size_zoned()
5330 ctl->dev_stripes); in decide_stripe_size_zoned()
5331 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; in decide_stripe_size_zoned()
5332 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; in decide_stripe_size_zoned()
5333 ASSERT(ctl->stripe_size * data_stripes <= ctl->max_chunk_size); in decide_stripe_size_zoned()
5336 ctl->chunk_size = ctl->stripe_size * data_stripes; in decide_stripe_size_zoned()
5345 struct btrfs_fs_info *info = fs_devices->fs_info; in decide_stripe_size()
5352 ctl->ndevs = rounddown(ctl->ndevs, ctl->devs_increment); in decide_stripe_size()
5354 if (ctl->ndevs < ctl->devs_min) { in decide_stripe_size()
5358 __func__, ctl->ndevs, ctl->devs_min); in decide_stripe_size()
5360 return -ENOSPC; in decide_stripe_size()
5363 ctl->ndevs = min(ctl->ndevs, ctl->devs_max); in decide_stripe_size()
5365 switch (fs_devices->chunk_alloc_policy) { in decide_stripe_size()
5379 struct btrfs_fs_info *info = trans->fs_info; in create_chunk()
5380 struct map_lookup *map = NULL; in create_chunk() local
5384 u64 start = ctl->start; in create_chunk()
5385 u64 type = ctl->type; in create_chunk()
5390 map = kmalloc(map_lookup_size(ctl->num_stripes), GFP_NOFS); in create_chunk()
5391 if (!map) in create_chunk()
5392 return ERR_PTR(-ENOMEM); in create_chunk()
5393 map->num_stripes = ctl->num_stripes; in create_chunk()
5395 for (i = 0; i < ctl->ndevs; ++i) { in create_chunk()
5396 for (j = 0; j < ctl->dev_stripes; ++j) { in create_chunk()
5397 int s = i * ctl->dev_stripes + j; in create_chunk()
5398 map->stripes[s].dev = devices_info[i].dev; in create_chunk()
5399 map->stripes[s].physical = devices_info[i].dev_offset + in create_chunk()
5400 j * ctl->stripe_size; in create_chunk()
5403 map->io_align = BTRFS_STRIPE_LEN; in create_chunk()
5404 map->io_width = BTRFS_STRIPE_LEN; in create_chunk()
5405 map->type = type; in create_chunk()
5406 map->sub_stripes = ctl->sub_stripes; in create_chunk()
5408 trace_btrfs_chunk_alloc(info, map, start, ctl->chunk_size); in create_chunk()
5412 kfree(map); in create_chunk()
5413 return ERR_PTR(-ENOMEM); in create_chunk()
5415 set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); in create_chunk()
5416 em->map_lookup = map; in create_chunk()
5417 em->start = start; in create_chunk()
5418 em->len = ctl->chunk_size; in create_chunk()
5419 em->block_start = 0; in create_chunk()
5420 em->block_len = em->len; in create_chunk()
5421 em->orig_block_len = ctl->stripe_size; in create_chunk()
5423 em_tree = &info->mapping_tree; in create_chunk()
5424 write_lock(&em_tree->lock); in create_chunk()
5427 write_unlock(&em_tree->lock); in create_chunk()
5431 write_unlock(&em_tree->lock); in create_chunk()
5433 block_group = btrfs_make_block_group(trans, type, start, ctl->chunk_size); in create_chunk()
5437 for (i = 0; i < map->num_stripes; i++) { in create_chunk()
5438 struct btrfs_device *dev = map->stripes[i].dev; in create_chunk()
5441 dev->bytes_used + ctl->stripe_size); in create_chunk()
5442 if (list_empty(&dev->post_commit_list)) in create_chunk()
5443 list_add_tail(&dev->post_commit_list, in create_chunk()
5444 &trans->transaction->dev_update_list); in create_chunk()
5447 atomic64_sub(ctl->stripe_size * map->num_stripes, in create_chunk()
5448 &info->free_chunk_space); in create_chunk()
5457 write_lock(&em_tree->lock); in create_chunk()
5459 write_unlock(&em_tree->lock); in create_chunk()
5472 struct btrfs_fs_info *info = trans->fs_info; in btrfs_create_chunk()
5473 struct btrfs_fs_devices *fs_devices = info->fs_devices; in btrfs_create_chunk()
5479 lockdep_assert_held(&info->chunk_mutex); in btrfs_create_chunk()
5483 return ERR_PTR(-EINVAL); in btrfs_create_chunk()
5486 if (list_empty(&fs_devices->alloc_list)) { in btrfs_create_chunk()
5489 return ERR_PTR(-ENOSPC); in btrfs_create_chunk()
5495 return ERR_PTR(-EINVAL); in btrfs_create_chunk()
5502 devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info), in btrfs_create_chunk()
5505 return ERR_PTR(-ENOMEM); in btrfs_create_chunk()
5537 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_chunk_alloc_add_chunk_item()
5538 struct btrfs_root *chunk_root = fs_info->chunk_root; in btrfs_chunk_alloc_add_chunk_item()
5543 struct map_lookup *map; in btrfs_chunk_alloc_add_chunk_item() local
5557 * that replaces the device object associated with the map's stripes, in btrfs_chunk_alloc_add_chunk_item()
5560 * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the in btrfs_chunk_alloc_add_chunk_item()
5566 * acquires both mutexes - first the device_list_mutex and then the in btrfs_chunk_alloc_add_chunk_item()
5570 lockdep_assert_held(&fs_info->chunk_mutex); in btrfs_chunk_alloc_add_chunk_item()
5572 em = btrfs_get_chunk_map(fs_info, bg->start, bg->length); in btrfs_chunk_alloc_add_chunk_item()
5579 map = em->map_lookup; in btrfs_chunk_alloc_add_chunk_item()
5580 item_size = btrfs_chunk_item_size(map->num_stripes); in btrfs_chunk_alloc_add_chunk_item()
5584 ret = -ENOMEM; in btrfs_chunk_alloc_add_chunk_item()
5589 for (i = 0; i < map->num_stripes; i++) { in btrfs_chunk_alloc_add_chunk_item()
5590 struct btrfs_device *device = map->stripes[i].dev; in btrfs_chunk_alloc_add_chunk_item()
5597 stripe = &chunk->stripe; in btrfs_chunk_alloc_add_chunk_item()
5598 for (i = 0; i < map->num_stripes; i++) { in btrfs_chunk_alloc_add_chunk_item()
5599 struct btrfs_device *device = map->stripes[i].dev; in btrfs_chunk_alloc_add_chunk_item()
5600 const u64 dev_offset = map->stripes[i].physical; in btrfs_chunk_alloc_add_chunk_item()
5602 btrfs_set_stack_stripe_devid(stripe, device->devid); in btrfs_chunk_alloc_add_chunk_item()
5604 memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE); in btrfs_chunk_alloc_add_chunk_item()
5608 btrfs_set_stack_chunk_length(chunk, bg->length); in btrfs_chunk_alloc_add_chunk_item()
5611 btrfs_set_stack_chunk_type(chunk, map->type); in btrfs_chunk_alloc_add_chunk_item()
5612 btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes); in btrfs_chunk_alloc_add_chunk_item()
5615 btrfs_set_stack_chunk_sector_size(chunk, fs_info->sectorsize); in btrfs_chunk_alloc_add_chunk_item()
5616 btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes); in btrfs_chunk_alloc_add_chunk_item()
5620 key.offset = bg->start; in btrfs_chunk_alloc_add_chunk_item()
5626 set_bit(BLOCK_GROUP_FLAG_CHUNK_ITEM_INSERTED, &bg->runtime_flags); in btrfs_chunk_alloc_add_chunk_item()
5628 if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) { in btrfs_chunk_alloc_add_chunk_item()
5642 struct btrfs_fs_info *fs_info = trans->fs_info; in init_first_rw_device()
5648 * When adding a new device for sprouting, the seed device is read-only in init_first_rw_device()
5654 * otherwise we would get -ENOSPC since the block groups from the in init_first_rw_device()
5655 * seed device are read-only; in init_first_rw_device()
5657 * 2) Add the device item for the new sprout device - finishing the setup in init_first_rw_device()
5660 * ensures this does not fail with -ENOSPC. in init_first_rw_device()
5681 static inline int btrfs_chunk_max_errors(struct map_lookup *map) in btrfs_chunk_max_errors() argument
5683 const int index = btrfs_bg_flags_to_raid_index(map->type); in btrfs_chunk_max_errors()
5691 struct map_lookup *map; in btrfs_chunk_writeable() local
5700 map = em->map_lookup; in btrfs_chunk_writeable()
5701 for (i = 0; i < map->num_stripes; i++) { in btrfs_chunk_writeable()
5703 &map->stripes[i].dev->dev_state)) { in btrfs_chunk_writeable()
5708 &map->stripes[i].dev->dev_state)) { in btrfs_chunk_writeable()
5718 if (miss_ndevs > btrfs_chunk_max_errors(map)) in btrfs_chunk_writeable()
5730 write_lock(&tree->lock); in btrfs_mapping_tree_free()
5731 em = lookup_extent_mapping(tree, 0, (u64)-1); in btrfs_mapping_tree_free()
5734 write_unlock(&tree->lock); in btrfs_mapping_tree_free()
5747 struct map_lookup *map; in btrfs_num_copies() local
5761 map = em->map_lookup; in btrfs_num_copies()
5762 index = btrfs_bg_flags_to_raid_index(map->type); in btrfs_num_copies()
5764 /* Non-RAID56, use their ncopies from btrfs_raid_array. */ in btrfs_num_copies()
5765 if (!(map->type & BTRFS_BLOCK_GROUP_RAID56_MASK)) in btrfs_num_copies()
5767 else if (map->type & BTRFS_BLOCK_GROUP_RAID5) in btrfs_num_copies()
5769 else if (map->type & BTRFS_BLOCK_GROUP_RAID6) in btrfs_num_copies()
5777 ret = map->num_stripes; in btrfs_num_copies()
5786 struct map_lookup *map; in btrfs_full_stripe_len() local
5787 unsigned long len = fs_info->sectorsize; in btrfs_full_stripe_len()
5795 map = em->map_lookup; in btrfs_full_stripe_len()
5796 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) in btrfs_full_stripe_len()
5797 len = btrfs_stripe_nr_to_offset(nr_data_stripes(map)); in btrfs_full_stripe_len()
5806 struct map_lookup *map; in btrfs_is_parity_mirror() local
5815 map = em->map_lookup; in btrfs_is_parity_mirror()
5816 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) in btrfs_is_parity_mirror()
5824 struct map_lookup *map, int first, in find_live_mirror() argument
5833 ASSERT((map->type & in find_live_mirror()
5836 if (map->type & BTRFS_BLOCK_GROUP_RAID10) in find_live_mirror()
5837 num_stripes = map->sub_stripes; in find_live_mirror()
5839 num_stripes = map->num_stripes; in find_live_mirror()
5841 switch (fs_info->fs_devices->read_policy) { in find_live_mirror()
5846 fs_info->fs_devices->read_policy); in find_live_mirror()
5847 fs_info->fs_devices->read_policy = BTRFS_READ_POLICY_PID; in find_live_mirror()
5850 preferred_mirror = first + (current->pid % num_stripes); in find_live_mirror()
5855 fs_info->dev_replace.cont_reading_from_srcdev_mode == in find_live_mirror()
5857 srcdev = fs_info->dev_replace.srcdev; in find_live_mirror()
5863 * dev-replace procedure, only choose it if no other non-missing in find_live_mirror()
5867 if (map->stripes[preferred_mirror].dev->bdev && in find_live_mirror()
5868 (tolerance || map->stripes[preferred_mirror].dev != srcdev)) in find_live_mirror()
5871 if (map->stripes[i].dev->bdev && in find_live_mirror()
5872 (tolerance || map->stripes[i].dev != srcdev)) in find_live_mirror()
5898 refcount_set(&bioc->refs, 1); in alloc_btrfs_io_context()
5900 bioc->fs_info = fs_info; in alloc_btrfs_io_context()
5901 bioc->replace_stripe_src = -1; in alloc_btrfs_io_context()
5902 bioc->full_stripe_logical = (u64)-1; in alloc_btrfs_io_context()
5909 WARN_ON(!refcount_read(&bioc->refs)); in btrfs_get_bioc()
5910 refcount_inc(&bioc->refs); in btrfs_get_bioc()
5917 if (refcount_dec_and_test(&bioc->refs)) in btrfs_put_bioc()
5930 struct map_lookup *map; in btrfs_map_discard() local
5952 map = em->map_lookup; in btrfs_map_discard()
5955 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in btrfs_map_discard()
5956 ret = -EOPNOTSUPP; in btrfs_map_discard()
5960 offset = logical - em->start; in btrfs_map_discard()
5961 length = min_t(u64, em->start + em->len - logical, length); in btrfs_map_discard()
5971 stripe_offset = offset - btrfs_stripe_nr_to_offset(stripe_nr); in btrfs_map_discard()
5975 stripe_cnt = stripe_nr_end - stripe_nr; in btrfs_map_discard()
5976 stripe_end_offset = btrfs_stripe_nr_to_offset(stripe_nr_end) - in btrfs_map_discard()
5985 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | in btrfs_map_discard()
5987 if (map->type & BTRFS_BLOCK_GROUP_RAID0) in btrfs_map_discard()
5990 sub_stripes = map->sub_stripes; in btrfs_map_discard()
5992 factor = map->num_stripes / sub_stripes; in btrfs_map_discard()
5993 *num_stripes = min_t(u64, map->num_stripes, in btrfs_map_discard()
6001 last_stripe = ((stripe_nr_end - 1) % factor) * sub_stripes; in btrfs_map_discard()
6002 } else if (map->type & (BTRFS_BLOCK_GROUP_RAID1_MASK | in btrfs_map_discard()
6004 *num_stripes = map->num_stripes; in btrfs_map_discard()
6006 stripe_index = stripe_nr % map->num_stripes; in btrfs_map_discard()
6007 stripe_nr /= map->num_stripes; in btrfs_map_discard()
6012 ret = -ENOMEM; in btrfs_map_discard()
6018 map->stripes[stripe_index].physical + in btrfs_map_discard()
6020 stripes[i].dev = map->stripes[stripe_index].dev; in btrfs_map_discard()
6022 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | in btrfs_map_discard()
6033 * |-------|...|-------| in btrfs_map_discard()
6034 * |----------| in btrfs_map_discard()
6038 stripes[i].length -= stripe_offset; in btrfs_map_discard()
6042 sub_stripes - 1)) in btrfs_map_discard()
6043 stripes[i].length -= stripe_end_offset; in btrfs_map_discard()
6045 if (i == sub_stripes - 1) in btrfs_map_discard()
6052 if (stripe_index == map->num_stripes) { in btrfs_map_discard()
6076 ret = test_bit(BLOCK_GROUP_FLAG_TO_COPY, &cache->runtime_flags); in is_block_group_to_copy()
6088 u64 srcdev_devid = dev_replace->srcdev->devid; in handle_ops_on_dev_replace()
6100 * the dev-replace process. We can avoid cloning IO here. in handle_ops_on_dev_replace()
6102 if (is_block_group_to_copy(dev_replace->srcdev->fs_info, logical)) in handle_ops_on_dev_replace()
6106 * Duplicate the write operations while the dev-replace procedure is in handle_ops_on_dev_replace()
6112 * Note that device->missing is handled by the caller, and that the in handle_ops_on_dev_replace()
6116 struct btrfs_io_stripe *old = &bioc->stripes[i]; in handle_ops_on_dev_replace()
6117 struct btrfs_io_stripe *new = &bioc->stripes[num_stripes + nr_extra_stripes]; in handle_ops_on_dev_replace()
6119 if (old->dev->devid != srcdev_devid) in handle_ops_on_dev_replace()
6122 new->physical = old->physical; in handle_ops_on_dev_replace()
6123 new->dev = dev_replace->tgtdev; in handle_ops_on_dev_replace()
6124 if (bioc->map_type & BTRFS_BLOCK_GROUP_RAID56_MASK) in handle_ops_on_dev_replace()
6125 bioc->replace_stripe_src = i; in handle_ops_on_dev_replace()
6137 struct btrfs_io_stripe *first = &bioc->stripes[num_stripes]; in handle_ops_on_dev_replace()
6138 struct btrfs_io_stripe *second = &bioc->stripes[num_stripes + 1]; in handle_ops_on_dev_replace()
6141 ASSERT(bioc->map_type & BTRFS_BLOCK_GROUP_DUP); in handle_ops_on_dev_replace()
6147 if (first->physical > second->physical) { in handle_ops_on_dev_replace()
6148 swap(second->physical, first->physical); in handle_ops_on_dev_replace()
6149 swap(second->dev, first->dev); in handle_ops_on_dev_replace()
6150 nr_extra_stripes--; in handle_ops_on_dev_replace()
6156 bioc->replace_nr_stripes = nr_extra_stripes; in handle_ops_on_dev_replace()
6159 static u64 btrfs_max_io_len(struct map_lookup *map, enum btrfs_map_op op, in btrfs_max_io_len() argument
6171 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in btrfs_max_io_len()
6173 btrfs_stripe_nr_to_offset(nr_data_stripes(map)); in btrfs_max_io_len()
6186 rounddown(*stripe_nr, nr_data_stripes(map))); in btrfs_max_io_len()
6195 return full_stripe_len - (offset - *full_stripe_start); in btrfs_max_io_len()
6202 if (map->type & BTRFS_BLOCK_GROUP_STRIPE_MASK) in btrfs_max_io_len()
6203 return BTRFS_STRIPE_LEN - *stripe_offset; in btrfs_max_io_len()
6207 static void set_io_stripe(struct btrfs_io_stripe *dst, const struct map_lookup *map, in set_io_stripe() argument
6210 dst->dev = map->stripes[stripe_index].dev; in set_io_stripe()
6211 dst->physical = map->stripes[stripe_index].physical + in set_io_stripe()
6216 * Map one logical range to one or more physical ranges.
6229 * If the map request can be fulfilled by one single
6239 * For non-RAID56 profiles, non-zero mirror_num means
6250 * @need_raid_map: (Used only for integrity checker) whether the map wants
6251 * a full stripe map (including all data and P/Q stripes)
6261 struct map_lookup *map; in btrfs_map_block() local
6274 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace; in btrfs_map_block()
6277 u64 raid56_full_stripe_start = (u64)-1; in btrfs_map_block()
6282 num_copies = btrfs_num_copies(fs_info, logical, fs_info->sectorsize); in btrfs_map_block()
6284 return -EINVAL; in btrfs_map_block()
6290 map = em->map_lookup; in btrfs_map_block()
6291 data_stripes = nr_data_stripes(map); in btrfs_map_block()
6293 map_offset = logical - em->start; in btrfs_map_block()
6294 max_len = btrfs_max_io_len(map, op, map_offset, &stripe_nr, in btrfs_map_block()
6296 *length = min_t(u64, em->len - map_offset, max_len); in btrfs_map_block()
6298 down_read(&dev_replace->rwsem); in btrfs_map_block()
6305 up_read(&dev_replace->rwsem); in btrfs_map_block()
6309 if (map->type & BTRFS_BLOCK_GROUP_RAID0) { in btrfs_map_block()
6310 stripe_index = stripe_nr % map->num_stripes; in btrfs_map_block()
6311 stripe_nr /= map->num_stripes; in btrfs_map_block()
6314 } else if (map->type & BTRFS_BLOCK_GROUP_RAID1_MASK) { in btrfs_map_block()
6316 num_stripes = map->num_stripes; in btrfs_map_block()
6318 stripe_index = mirror_num - 1; in btrfs_map_block()
6320 stripe_index = find_live_mirror(fs_info, map, 0, in btrfs_map_block()
6325 } else if (map->type & BTRFS_BLOCK_GROUP_DUP) { in btrfs_map_block()
6327 num_stripes = map->num_stripes; in btrfs_map_block()
6329 stripe_index = mirror_num - 1; in btrfs_map_block()
6334 } else if (map->type & BTRFS_BLOCK_GROUP_RAID10) { in btrfs_map_block()
6335 u32 factor = map->num_stripes / map->sub_stripes; in btrfs_map_block()
6337 stripe_index = (stripe_nr % factor) * map->sub_stripes; in btrfs_map_block()
6341 num_stripes = map->sub_stripes; in btrfs_map_block()
6343 stripe_index += mirror_num - 1; in btrfs_map_block()
6346 stripe_index = find_live_mirror(fs_info, map, in btrfs_map_block()
6349 mirror_num = stripe_index - old_stripe_index + 1; in btrfs_map_block()
6352 } else if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in btrfs_map_block()
6366 num_stripes = map->num_stripes; in btrfs_map_block()
6367 max_errors = btrfs_chunk_max_errors(map); in btrfs_map_block()
6371 raid56_full_stripe_start + em->start + in btrfs_map_block()
6372 btrfs_stripe_nr_to_offset(data_stripes)) - in btrfs_map_block()
6385 stripe_index = data_stripes + mirror_num - 2; in btrfs_map_block()
6388 stripe_index = (stripe_nr + stripe_index) % map->num_stripes; in btrfs_map_block()
6398 stripe_index = stripe_nr % map->num_stripes; in btrfs_map_block()
6399 stripe_nr /= map->num_stripes; in btrfs_map_block()
6402 if (stripe_index >= map->num_stripes) { in btrfs_map_block()
6405 stripe_index, map->num_stripes); in btrfs_map_block()
6406 ret = -EINVAL; in btrfs_map_block()
6411 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL && in btrfs_map_block()
6428 !((map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) && mirror_num > 1)) { in btrfs_map_block()
6429 set_io_stripe(smap, map, stripe_index, stripe_offset, stripe_nr); in btrfs_map_block()
6439 ret = -ENOMEM; in btrfs_map_block()
6442 bioc->map_type = map->type; in btrfs_map_block()
6445 * For RAID56 full map, we need to make sure the stripes[] follows the in btrfs_map_block()
6451 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK && need_raid_map && in btrfs_map_block()
6461 bioc->full_stripe_logical = em->start + in btrfs_map_block()
6464 set_io_stripe(&bioc->stripes[i], map, in btrfs_map_block()
6469 * For all other non-RAID56 profiles, just copy the target in btrfs_map_block()
6473 set_io_stripe(&bioc->stripes[i], map, stripe_index, in btrfs_map_block()
6480 max_errors = btrfs_chunk_max_errors(map); in btrfs_map_block()
6482 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL && in btrfs_map_block()
6489 bioc->num_stripes = num_stripes; in btrfs_map_block()
6490 bioc->max_errors = max_errors; in btrfs_map_block()
6491 bioc->mirror_num = mirror_num; in btrfs_map_block()
6495 lockdep_assert_held(&dev_replace->rwsem); in btrfs_map_block()
6497 up_read(&dev_replace->rwsem); in btrfs_map_block()
6506 if (args->fsid == NULL) in dev_args_match_fs_devices()
6508 if (memcmp(fs_devices->metadata_uuid, args->fsid, BTRFS_FSID_SIZE) == 0) in dev_args_match_fs_devices()
6516 if (args->missing) { in dev_args_match_device()
6517 if (test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state) && in dev_args_match_device()
6518 !device->bdev) in dev_args_match_device()
6523 if (device->devid != args->devid) in dev_args_match_device()
6525 if (args->uuid && memcmp(device->uuid, args->uuid, BTRFS_UUID_SIZE) != 0) in dev_args_match_device()
6544 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_find_device()
6550 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_find_device()
6553 list_for_each_entry(device, &seed_devs->devices, dev_list) { in btrfs_find_device()
6581 list_add(&device->dev_list, &fs_devices->devices); in add_missing_dev()
6582 device->fs_devices = fs_devices; in add_missing_dev()
6583 fs_devices->num_devices++; in add_missing_dev()
6585 set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in add_missing_dev()
6586 fs_devices->missing_devices++; in add_missing_dev()
6600 * @path: a pointer to device path if available, NULL otherwise.
6608 const char *path) in btrfs_alloc_device() argument
6614 return ERR_PTR(-EINVAL); in btrfs_alloc_device()
6618 return ERR_PTR(-ENOMEM); in btrfs_alloc_device()
6620 INIT_LIST_HEAD(&dev->dev_list); in btrfs_alloc_device()
6621 INIT_LIST_HEAD(&dev->dev_alloc_list); in btrfs_alloc_device()
6622 INIT_LIST_HEAD(&dev->post_commit_list); in btrfs_alloc_device()
6624 atomic_set(&dev->dev_stats_ccnt, 0); in btrfs_alloc_device()
6626 extent_io_tree_init(fs_info, &dev->alloc_state, IO_TREE_DEVICE_ALLOC_STATE); in btrfs_alloc_device()
6639 dev->devid = tmp; in btrfs_alloc_device()
6642 memcpy(dev->uuid, uuid, BTRFS_UUID_SIZE); in btrfs_alloc_device()
6644 generate_random_uuid(dev->uuid); in btrfs_alloc_device()
6646 if (path) { in btrfs_alloc_device()
6649 name = rcu_string_strdup(path, GFP_KERNEL); in btrfs_alloc_device()
6652 return ERR_PTR(-ENOMEM); in btrfs_alloc_device()
6654 rcu_assign_pointer(dev->name, name); in btrfs_alloc_device()
6673 const struct map_lookup *map = em->map_lookup; in btrfs_calc_stripe_length() local
6674 const int data_stripes = calc_data_stripes(map->type, map->num_stripes); in btrfs_calc_stripe_length()
6676 return div_u64(em->len, data_stripes); in btrfs_calc_stripe_length()
6697 return -EOVERFLOW; in check_32bit_meta_chunk()
6726 return ERR_PTR(-ENOENT); in handle_missing_device()
6729 dev = add_missing_dev(fs_info->fs_devices, devid, uuid); in handle_missing_device()
6744 struct btrfs_fs_info *fs_info = leaf->fs_info; in read_one_chunk()
6745 struct extent_map_tree *map_tree = &fs_info->mapping_tree; in read_one_chunk()
6746 struct map_lookup *map; in read_one_chunk() local
6758 logical = key->offset; in read_one_chunk()
6773 * as chunk item in tree block is already verified by tree-checker. in read_one_chunk()
6775 if (leaf->start == BTRFS_SUPER_INFO_OFFSET) { in read_one_chunk()
6781 read_lock(&map_tree->lock); in read_one_chunk()
6783 read_unlock(&map_tree->lock); in read_one_chunk()
6786 if (em && em->start <= logical && em->start + em->len > logical) { in read_one_chunk()
6795 return -ENOMEM; in read_one_chunk()
6796 map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS); in read_one_chunk()
6797 if (!map) { in read_one_chunk()
6799 return -ENOMEM; in read_one_chunk()
6802 set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); in read_one_chunk()
6803 em->map_lookup = map; in read_one_chunk()
6804 em->start = logical; in read_one_chunk()
6805 em->len = length; in read_one_chunk()
6806 em->orig_start = 0; in read_one_chunk()
6807 em->block_start = 0; in read_one_chunk()
6808 em->block_len = em->len; in read_one_chunk()
6810 map->num_stripes = num_stripes; in read_one_chunk()
6811 map->io_width = btrfs_chunk_io_width(leaf, chunk); in read_one_chunk()
6812 map->io_align = btrfs_chunk_io_align(leaf, chunk); in read_one_chunk()
6813 map->type = type; in read_one_chunk()
6818 * In that case, it can cause divide-by-zero errors later. in read_one_chunk()
6822 map->sub_stripes = btrfs_raid_array[index].sub_stripes; in read_one_chunk()
6823 map->verified_stripes = 0; in read_one_chunk()
6824 em->orig_block_len = btrfs_calc_stripe_length(em); in read_one_chunk()
6826 map->stripes[i].physical = in read_one_chunk()
6834 map->stripes[i].dev = btrfs_find_device(fs_info->fs_devices, &args); in read_one_chunk()
6835 if (!map->stripes[i].dev) { in read_one_chunk()
6836 map->stripes[i].dev = handle_missing_device(fs_info, in read_one_chunk()
6838 if (IS_ERR(map->stripes[i].dev)) { in read_one_chunk()
6839 ret = PTR_ERR(map->stripes[i].dev); in read_one_chunk()
6846 &(map->stripes[i].dev->dev_state)); in read_one_chunk()
6849 write_lock(&map_tree->lock); in read_one_chunk()
6851 write_unlock(&map_tree->lock); in read_one_chunk()
6854 "failed to add chunk map, start=%llu len=%llu: %d", in read_one_chunk()
6855 em->start, em->len, ret); in read_one_chunk()
6868 device->devid = btrfs_device_id(leaf, dev_item); in fill_device_from_item()
6869 device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item); in fill_device_from_item()
6870 device->total_bytes = device->disk_total_bytes; in fill_device_from_item()
6871 device->commit_total_bytes = device->disk_total_bytes; in fill_device_from_item()
6872 device->bytes_used = btrfs_device_bytes_used(leaf, dev_item); in fill_device_from_item()
6873 device->commit_bytes_used = device->bytes_used; in fill_device_from_item()
6874 device->type = btrfs_device_type(leaf, dev_item); in fill_device_from_item()
6875 device->io_align = btrfs_device_io_align(leaf, dev_item); in fill_device_from_item()
6876 device->io_width = btrfs_device_io_width(leaf, dev_item); in fill_device_from_item()
6877 device->sector_size = btrfs_device_sector_size(leaf, dev_item); in fill_device_from_item()
6878 WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID); in fill_device_from_item()
6879 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in fill_device_from_item()
6882 read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); in fill_device_from_item()
6894 /* This will match only for multi-device seed fs */ in open_seed_devices()
6895 list_for_each_entry(fs_devices, &fs_info->fs_devices->seed_list, seed_list) in open_seed_devices()
6896 if (!memcmp(fs_devices->fsid, fsid, BTRFS_FSID_SIZE)) in open_seed_devices()
6903 return ERR_PTR(-ENOENT); in open_seed_devices()
6909 fs_devices->seeding = true; in open_seed_devices()
6910 fs_devices->opened = 1; in open_seed_devices()
6916 * respective fs_devices and anchor it at fs_info->fs_devices->seed_list in open_seed_devices()
6922 ret = open_fs_devices(fs_devices, BLK_OPEN_READ, fs_info->bdev_holder); in open_seed_devices()
6928 if (!fs_devices->seeding) { in open_seed_devices()
6931 return ERR_PTR(-EINVAL); in open_seed_devices()
6934 list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list); in open_seed_devices()
6943 struct btrfs_fs_info *fs_info = leaf->fs_info; in read_one_dev()
6944 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in read_one_dev()
6960 if (memcmp(fs_uuid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE)) { in read_one_dev()
6966 device = btrfs_find_device(fs_info->fs_devices, &args); in read_one_dev()
6971 return -ENOENT; in read_one_dev()
6983 if (!device->bdev) { in read_one_dev()
6987 return -ENOENT; in read_one_dev()
6993 if (!device->bdev && in read_one_dev()
6994 !test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in read_one_dev()
6998 * device->bdev is NULL, and so we have to set in read_one_dev()
6999 * device->missing to one here in read_one_dev()
7001 device->fs_devices->missing_devices++; in read_one_dev()
7002 set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in read_one_dev()
7006 if (device->fs_devices != fs_devices) { in read_one_dev()
7008 &device->dev_state)); in read_one_dev()
7010 list_move(&device->dev_list, &fs_devices->devices); in read_one_dev()
7011 device->fs_devices->num_devices--; in read_one_dev()
7012 fs_devices->num_devices++; in read_one_dev()
7014 device->fs_devices->missing_devices--; in read_one_dev()
7015 fs_devices->missing_devices++; in read_one_dev()
7017 device->fs_devices = fs_devices; in read_one_dev()
7021 if (device->fs_devices != fs_info->fs_devices) { in read_one_dev()
7022 BUG_ON(test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)); in read_one_dev()
7023 if (device->generation != in read_one_dev()
7025 return -EINVAL; in read_one_dev()
7029 if (device->bdev) { in read_one_dev()
7030 u64 max_total_bytes = bdev_nr_bytes(device->bdev); in read_one_dev()
7032 if (device->total_bytes > max_total_bytes) { in read_one_dev()
7035 max_total_bytes, device->total_bytes); in read_one_dev()
7036 return -EINVAL; in read_one_dev()
7039 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in read_one_dev()
7040 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in read_one_dev()
7041 !test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in read_one_dev()
7042 device->fs_devices->total_rw_bytes += device->total_bytes; in read_one_dev()
7043 atomic64_add(device->total_bytes - device->bytes_used, in read_one_dev()
7044 &fs_info->free_chunk_space); in read_one_dev()
7052 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_read_sys_array()
7066 ASSERT(BTRFS_SUPER_INFO_SIZE <= fs_info->nodesize); in btrfs_read_sys_array()
7075 return -ENOMEM; in btrfs_read_sys_array()
7081 array_ptr = super_copy->sys_chunk_array; in btrfs_read_sys_array()
7101 ret = -EIO; in btrfs_read_sys_array()
7119 ret = -EIO; in btrfs_read_sys_array()
7128 ret = -EIO; in btrfs_read_sys_array()
7153 return -EIO; in btrfs_read_sys_array()
7157 * Check if all chunks in the fs are OK for read-write degraded mount
7167 struct extent_map_tree *map_tree = &fs_info->mapping_tree; in btrfs_check_rw_degradable()
7172 read_lock(&map_tree->lock); in btrfs_check_rw_degradable()
7173 em = lookup_extent_mapping(map_tree, 0, (u64)-1); in btrfs_check_rw_degradable()
7174 read_unlock(&map_tree->lock); in btrfs_check_rw_degradable()
7181 struct map_lookup *map; in btrfs_check_rw_degradable() local
7186 map = em->map_lookup; in btrfs_check_rw_degradable()
7189 map->type); in btrfs_check_rw_degradable()
7190 for (i = 0; i < map->num_stripes; i++) { in btrfs_check_rw_degradable()
7191 struct btrfs_device *dev = map->stripes[i].dev; in btrfs_check_rw_degradable()
7193 if (!dev || !dev->bdev || in btrfs_check_rw_degradable()
7194 test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state) || in btrfs_check_rw_degradable()
7195 dev->last_flush_error) in btrfs_check_rw_degradable()
7204 em->start, missing, max_tolerated); in btrfs_check_rw_degradable()
7212 read_lock(&map_tree->lock); in btrfs_check_rw_degradable()
7214 (u64)(-1) - next_start); in btrfs_check_rw_degradable()
7215 read_unlock(&map_tree->lock); in btrfs_check_rw_degradable()
7232 struct btrfs_root *root = fs_info->chunk_root; in btrfs_read_chunk_tree()
7233 struct btrfs_path *path; in btrfs_read_chunk_tree() local
7243 path = btrfs_alloc_path(); in btrfs_read_chunk_tree()
7244 if (!path) in btrfs_read_chunk_tree()
7245 return -ENOMEM; in btrfs_read_chunk_tree()
7255 * we execute this code path, but open_fs_devices failed to clear in btrfs_read_chunk_tree()
7259 fs_info->fs_devices->total_rw_bytes = 0; in btrfs_read_chunk_tree()
7271 ASSERT(!test_bit(BTRFS_FS_OPEN, &fs_info->flags)); in btrfs_read_chunk_tree()
7272 path->skip_locking = 1; in btrfs_read_chunk_tree()
7278 * item - BTRFS_FIRST_CHUNK_TREE_OBJECTID). in btrfs_read_chunk_tree()
7283 btrfs_for_each_slot(root, &key, &found_key, path, iter_ret) { in btrfs_read_chunk_tree()
7284 struct extent_buffer *node = path->nodes[1]; in btrfs_read_chunk_tree()
7286 leaf = path->nodes[0]; in btrfs_read_chunk_tree()
7287 slot = path->slots[0]; in btrfs_read_chunk_tree()
7290 if (last_ra_node != node->start) { in btrfs_read_chunk_tree()
7292 last_ra_node = node->start; in btrfs_read_chunk_tree()
7308 * fs_info->chunk_mutex. Plus, to avoid lockdep warnings, in btrfs_read_chunk_tree()
7309 * we always lock first fs_info->chunk_mutex before in btrfs_read_chunk_tree()
7330 if (total_dev != fs_info->fs_devices->total_devices) { in btrfs_read_chunk_tree()
7333 btrfs_super_num_devices(fs_info->super_copy), in btrfs_read_chunk_tree()
7335 fs_info->fs_devices->total_devices = total_dev; in btrfs_read_chunk_tree()
7336 btrfs_set_super_num_devices(fs_info->super_copy, total_dev); in btrfs_read_chunk_tree()
7338 if (btrfs_super_total_bytes(fs_info->super_copy) < in btrfs_read_chunk_tree()
7339 fs_info->fs_devices->total_rw_bytes) { in btrfs_read_chunk_tree()
7342 btrfs_super_total_bytes(fs_info->super_copy), in btrfs_read_chunk_tree()
7343 fs_info->fs_devices->total_rw_bytes); in btrfs_read_chunk_tree()
7344 ret = -EINVAL; in btrfs_read_chunk_tree()
7351 btrfs_free_path(path); in btrfs_read_chunk_tree()
7357 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs; in btrfs_init_devices_late()
7361 fs_devices->fs_info = fs_info; in btrfs_init_devices_late()
7363 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_devices_late()
7364 list_for_each_entry(device, &fs_devices->devices, dev_list) in btrfs_init_devices_late()
7365 device->fs_info = fs_info; in btrfs_init_devices_late()
7367 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_init_devices_late()
7368 list_for_each_entry(device, &seed_devs->devices, dev_list) { in btrfs_init_devices_late()
7369 device->fs_info = fs_info; in btrfs_init_devices_late()
7375 seed_devs->fs_info = fs_info; in btrfs_init_devices_late()
7377 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_devices_late()
7406 struct btrfs_path *path) in btrfs_device_init_dev_stats() argument
7414 if (!device->fs_info->dev_root) in btrfs_device_init_dev_stats()
7419 key.offset = device->devid; in btrfs_device_init_dev_stats()
7420 ret = btrfs_search_slot(NULL, device->fs_info->dev_root, &key, path, 0, 0); in btrfs_device_init_dev_stats()
7424 device->dev_stats_valid = 1; in btrfs_device_init_dev_stats()
7425 btrfs_release_path(path); in btrfs_device_init_dev_stats()
7428 slot = path->slots[0]; in btrfs_device_init_dev_stats()
7429 eb = path->nodes[0]; in btrfs_device_init_dev_stats()
7442 device->dev_stats_valid = 1; in btrfs_device_init_dev_stats()
7444 btrfs_release_path(path); in btrfs_device_init_dev_stats()
7451 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs; in btrfs_init_dev_stats()
7453 struct btrfs_path *path = NULL; in btrfs_init_dev_stats() local
7456 path = btrfs_alloc_path(); in btrfs_init_dev_stats()
7457 if (!path) in btrfs_init_dev_stats()
7458 return -ENOMEM; in btrfs_init_dev_stats()
7460 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_dev_stats()
7461 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_init_dev_stats()
7462 ret = btrfs_device_init_dev_stats(device, path); in btrfs_init_dev_stats()
7466 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_init_dev_stats()
7467 list_for_each_entry(device, &seed_devs->devices, dev_list) { in btrfs_init_dev_stats()
7468 ret = btrfs_device_init_dev_stats(device, path); in btrfs_init_dev_stats()
7474 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_dev_stats()
7476 btrfs_free_path(path); in btrfs_init_dev_stats()
7483 struct btrfs_fs_info *fs_info = trans->fs_info; in update_dev_stat_item()
7484 struct btrfs_root *dev_root = fs_info->dev_root; in update_dev_stat_item()
7485 struct btrfs_path *path; in update_dev_stat_item() local
7494 key.offset = device->devid; in update_dev_stat_item()
7496 path = btrfs_alloc_path(); in update_dev_stat_item()
7497 if (!path) in update_dev_stat_item()
7498 return -ENOMEM; in update_dev_stat_item()
7499 ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1); in update_dev_stat_item()
7508 btrfs_item_size(path->nodes[0], path->slots[0]) < sizeof(*ptr)) { in update_dev_stat_item()
7510 ret = btrfs_del_item(trans, dev_root, path); in update_dev_stat_item()
7522 btrfs_release_path(path); in update_dev_stat_item()
7523 ret = btrfs_insert_empty_item(trans, dev_root, path, in update_dev_stat_item()
7533 eb = path->nodes[0]; in update_dev_stat_item()
7534 ptr = btrfs_item_ptr(eb, path->slots[0], struct btrfs_dev_stats_item); in update_dev_stat_item()
7541 btrfs_free_path(path); in update_dev_stat_item()
7550 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_run_dev_stats()
7551 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_run_dev_stats()
7556 mutex_lock(&fs_devices->device_list_mutex); in btrfs_run_dev_stats()
7557 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_run_dev_stats()
7558 stats_cnt = atomic_read(&device->dev_stats_ccnt); in btrfs_run_dev_stats()
7559 if (!device->dev_stats_valid || stats_cnt == 0) in btrfs_run_dev_stats()
7564 * There is a LOAD-LOAD control dependency between the value of in btrfs_run_dev_stats()
7565 * dev_stats_ccnt and updating the on-disk values which requires in btrfs_run_dev_stats()
7566 * reading the in-memory counters. Such control dependencies in btrfs_run_dev_stats()
7578 atomic_sub(stats_cnt, &device->dev_stats_ccnt); in btrfs_run_dev_stats()
7580 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_run_dev_stats()
7589 if (!dev->dev_stats_valid) in btrfs_dev_stat_inc_and_print()
7591 btrfs_err_rl_in_rcu(dev->fs_info, in btrfs_dev_stat_inc_and_print()
7611 btrfs_info_in_rcu(dev->fs_info, in btrfs_dev_stat_print_on_load()
7626 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_get_dev_stats()
7629 mutex_lock(&fs_devices->device_list_mutex); in btrfs_get_dev_stats()
7630 args.devid = stats->devid; in btrfs_get_dev_stats()
7631 dev = btrfs_find_device(fs_info->fs_devices, &args); in btrfs_get_dev_stats()
7632 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_get_dev_stats()
7636 return -ENODEV; in btrfs_get_dev_stats()
7637 } else if (!dev->dev_stats_valid) { in btrfs_get_dev_stats()
7639 return -ENODEV; in btrfs_get_dev_stats()
7640 } else if (stats->flags & BTRFS_DEV_STATS_RESET) { in btrfs_get_dev_stats()
7642 if (stats->nr_items > i) in btrfs_get_dev_stats()
7643 stats->values[i] = in btrfs_get_dev_stats()
7649 current->comm, task_pid_nr(current)); in btrfs_get_dev_stats()
7652 if (stats->nr_items > i) in btrfs_get_dev_stats()
7653 stats->values[i] = btrfs_dev_stat_read(dev, i); in btrfs_get_dev_stats()
7655 if (stats->nr_items > BTRFS_DEV_STAT_VALUES_MAX) in btrfs_get_dev_stats()
7656 stats->nr_items = BTRFS_DEV_STAT_VALUES_MAX; in btrfs_get_dev_stats()
7671 ASSERT(trans->state == TRANS_STATE_COMMIT_DOING); in btrfs_commit_device_sizes()
7673 if (list_empty(&trans->dev_update_list)) in btrfs_commit_device_sizes()
7681 mutex_lock(&trans->fs_info->chunk_mutex); in btrfs_commit_device_sizes()
7682 list_for_each_entry_safe(curr, next, &trans->dev_update_list, in btrfs_commit_device_sizes()
7684 list_del_init(&curr->post_commit_list); in btrfs_commit_device_sizes()
7685 curr->commit_total_bytes = curr->disk_total_bytes; in btrfs_commit_device_sizes()
7686 curr->commit_bytes_used = curr->bytes_used; in btrfs_commit_device_sizes()
7688 mutex_unlock(&trans->fs_info->chunk_mutex); in btrfs_commit_device_sizes()
7692 * Multiplicity factor for simple profiles: DUP, RAID1-like and RAID10.
7708 struct extent_map_tree *em_tree = &fs_info->mapping_tree; in verify_one_dev_extent()
7710 struct map_lookup *map; in verify_one_dev_extent() local
7717 read_lock(&em_tree->lock); in verify_one_dev_extent()
7719 read_unlock(&em_tree->lock); in verify_one_dev_extent()
7725 ret = -EUCLEAN; in verify_one_dev_extent()
7729 map = em->map_lookup; in verify_one_dev_extent()
7734 physical_offset, devid, em->start, physical_len, in verify_one_dev_extent()
7736 ret = -EUCLEAN; in verify_one_dev_extent()
7750 for (i = 0; i < map->num_stripes; i++) { in verify_one_dev_extent()
7751 if (map->stripes[i].dev->devid == devid && in verify_one_dev_extent()
7752 map->stripes[i].physical == physical_offset) { in verify_one_dev_extent()
7754 if (map->verified_stripes >= map->num_stripes) { in verify_one_dev_extent()
7757 em->start); in verify_one_dev_extent()
7758 ret = -EUCLEAN; in verify_one_dev_extent()
7761 map->verified_stripes++; in verify_one_dev_extent()
7769 ret = -EUCLEAN; in verify_one_dev_extent()
7773 dev = btrfs_find_device(fs_info->fs_devices, &args); in verify_one_dev_extent()
7776 ret = -EUCLEAN; in verify_one_dev_extent()
7780 if (physical_offset + physical_len > dev->disk_total_bytes) { in verify_one_dev_extent()
7784 dev->disk_total_bytes); in verify_one_dev_extent()
7785 ret = -EUCLEAN; in verify_one_dev_extent()
7789 if (dev->zone_info) { in verify_one_dev_extent()
7790 u64 zone_size = dev->zone_info->zone_size; in verify_one_dev_extent()
7797 ret = -EUCLEAN; in verify_one_dev_extent()
7809 struct extent_map_tree *em_tree = &fs_info->mapping_tree; in verify_chunk_dev_extent_mapping()
7814 read_lock(&em_tree->lock); in verify_chunk_dev_extent_mapping()
7815 for (node = rb_first_cached(&em_tree->map); node; node = rb_next(node)) { in verify_chunk_dev_extent_mapping()
7817 if (em->map_lookup->num_stripes != in verify_chunk_dev_extent_mapping()
7818 em->map_lookup->verified_stripes) { in verify_chunk_dev_extent_mapping()
7821 em->start, em->map_lookup->verified_stripes, in verify_chunk_dev_extent_mapping()
7822 em->map_lookup->num_stripes); in verify_chunk_dev_extent_mapping()
7823 ret = -EUCLEAN; in verify_chunk_dev_extent_mapping()
7828 read_unlock(&em_tree->lock); in verify_chunk_dev_extent_mapping()
7841 struct btrfs_path *path; in btrfs_verify_dev_extents() local
7842 struct btrfs_root *root = fs_info->dev_root; in btrfs_verify_dev_extents()
7865 path = btrfs_alloc_path(); in btrfs_verify_dev_extents()
7866 if (!path) in btrfs_verify_dev_extents()
7867 return -ENOMEM; in btrfs_verify_dev_extents()
7869 path->reada = READA_FORWARD; in btrfs_verify_dev_extents()
7870 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); in btrfs_verify_dev_extents()
7874 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) { in btrfs_verify_dev_extents()
7875 ret = btrfs_next_leaf(root, path); in btrfs_verify_dev_extents()
7880 ret = -EUCLEAN; in btrfs_verify_dev_extents()
7885 struct extent_buffer *leaf = path->nodes[0]; in btrfs_verify_dev_extents()
7887 int slot = path->slots[0]; in btrfs_verify_dev_extents()
7908 ret = -EUCLEAN; in btrfs_verify_dev_extents()
7919 ret = btrfs_next_item(root, path); in btrfs_verify_dev_extents()
7931 btrfs_free_path(path); in btrfs_verify_dev_extents()
7944 spin_lock(&fs_info->swapfile_pins_lock); in btrfs_pinned_by_swapfile()
7945 node = fs_info->swapfile_pins.rb_node; in btrfs_pinned_by_swapfile()
7948 if (ptr < sp->ptr) in btrfs_pinned_by_swapfile()
7949 node = node->rb_left; in btrfs_pinned_by_swapfile()
7950 else if (ptr > sp->ptr) in btrfs_pinned_by_swapfile()
7951 node = node->rb_right; in btrfs_pinned_by_swapfile()
7955 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_pinned_by_swapfile()
7962 struct btrfs_fs_info *fs_info = cache->fs_info; in relocating_repair_kthread()
7966 target = cache->start; in relocating_repair_kthread()
7969 sb_start_write(fs_info->sb); in relocating_repair_kthread()
7974 sb_end_write(fs_info->sb); in relocating_repair_kthread()
7975 return -EBUSY; in relocating_repair_kthread()
7978 mutex_lock(&fs_info->reclaim_bgs_lock); in relocating_repair_kthread()
7985 if (!test_bit(BLOCK_GROUP_FLAG_RELOCATING_REPAIR, &cache->runtime_flags)) in relocating_repair_kthread()
8000 mutex_unlock(&fs_info->reclaim_bgs_lock); in relocating_repair_kthread()
8002 sb_end_write(fs_info->sb); in relocating_repair_kthread()
8022 if (test_and_set_bit(BLOCK_GROUP_FLAG_RELOCATING_REPAIR, &cache->runtime_flags)) { in btrfs_repair_one_zone()
8028 "btrfs-relocating-repair"); in btrfs_repair_one_zone()
8041 u64 stripe_start = bioc->full_stripe_logical + in map_raid56_repair_block()
8049 smap->dev = bioc->stripes[i].dev; in map_raid56_repair_block()
8050 smap->physical = bioc->stripes[i].physical + in map_raid56_repair_block()
8051 ((logical - bioc->full_stripe_logical) & in map_raid56_repair_block()
8056 * Map a repair write into a single device.
8060 * Not update any other mirrors nor go through RMW path.
8064 * - Call btrfs_bio_counter_inc_blocked() first
8065 * - The range does not cross stripe boundary
8066 * - Has a valid @mirror_num passed in.
8084 /* The map range should not cross stripe boundary. */ in btrfs_map_repair_block()
8091 /* Map the RAID56 multi-stripe writes to a single one. */ in btrfs_map_repair_block()
8092 if (bioc->map_type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in btrfs_map_repair_block()
8097 ASSERT(mirror_num <= bioc->num_stripes); in btrfs_map_repair_block()
8098 smap->dev = bioc->stripes[mirror_num - 1].dev; in btrfs_map_repair_block()
8099 smap->physical = bioc->stripes[mirror_num - 1].physical; in btrfs_map_repair_block()
8102 ASSERT(smap->dev); in btrfs_map_repair_block()