Lines Matching +full:path +full:- +full:map
1 // SPDX-License-Identifier: GPL-2.0
21 #include "disk-io.h"
23 #include "print-tree.h"
26 #include "async-thread.h"
27 #include "check-integrity.h"
28 #include "rcu-string.h"
29 #include "dev-replace.h"
31 #include "tree-checker.h"
32 #include "space-info.h"
33 #include "block-group.h"
189 size_bp -= ret; \ in btrfs_describe_block_groups()
207 size_bp -= ret; in btrfs_describe_block_groups()
211 buf[size_buf - size_bp - 1] = '\0'; /* remove last | */ in btrfs_describe_block_groups()
234 * There are several mutexes that protect manipulation of devices and low-level
238 * ------------------------
239 * protects the fs_uuids list that tracks all per-fs fs_devices, resulting from
243 * the mutex can be very coarse and can cover long-running operations
248 * global::fs_devs - add, remove, updates to the global list
254 * btrfs_device::name - renames (write side), read is RCU
256 * fs_devices::device_list_mutex (per-fs, with RCU)
257 * ------------------------------------------------
260 * simple list traversal with read-only actions can be done with RCU protection
269 * -------------
274 * -----------
281 * -------------
301 * - Balance (*)
302 * - Device add
303 * - Device remove
304 * - Device replace (*)
305 * - Resize
309 * - Running state
310 * - Paused state
311 * - Completed state
316 * - ioctl (only Balance can be Paused through ioctl)
317 * - filesystem remounted as read-only
318 * - filesystem unmounted and mounted as read-only
319 * - system power-cycle and filesystem mounted as read-only
320 * - filesystem or device errors leading to forced read-only
325 * either by ioctl (Balance only) or when remounted as read-write.
338 * alloc_fs_devices - allocate struct btrfs_fs_devices
353 return ERR_PTR(-ENOMEM); in alloc_fs_devices()
355 mutex_init(&fs_devs->device_list_mutex); in alloc_fs_devices()
357 INIT_LIST_HEAD(&fs_devs->devices); in alloc_fs_devices()
358 INIT_LIST_HEAD(&fs_devs->alloc_list); in alloc_fs_devices()
359 INIT_LIST_HEAD(&fs_devs->fs_list); in alloc_fs_devices()
360 INIT_LIST_HEAD(&fs_devs->seed_list); in alloc_fs_devices()
362 memcpy(fs_devs->fsid, fsid, BTRFS_FSID_SIZE); in alloc_fs_devices()
365 memcpy(fs_devs->metadata_uuid, metadata_fsid, BTRFS_FSID_SIZE); in alloc_fs_devices()
367 memcpy(fs_devs->metadata_uuid, fsid, BTRFS_FSID_SIZE); in alloc_fs_devices()
374 WARN_ON(!list_empty(&device->post_commit_list)); in btrfs_free_device()
375 rcu_string_free(device->name); in btrfs_free_device()
376 extent_io_tree_release(&device->alloc_state); in btrfs_free_device()
377 bio_put(device->flush_bio); in btrfs_free_device()
385 WARN_ON(fs_devices->opened); in free_fs_devices()
386 while (!list_empty(&fs_devices->devices)) { in free_fs_devices()
387 device = list_entry(fs_devices->devices.next, in free_fs_devices()
389 list_del(&device->dev_list); in free_fs_devices()
402 list_del(&fs_devices->fs_list); in btrfs_cleanup_fs_uuids()
418 return ERR_PTR(-ENOMEM); in __alloc_device()
424 dev->flush_bio = bio_alloc_bioset(GFP_KERNEL, 0, NULL); in __alloc_device()
425 if (!dev->flush_bio) { in __alloc_device()
427 return ERR_PTR(-ENOMEM); in __alloc_device()
430 INIT_LIST_HEAD(&dev->dev_list); in __alloc_device()
431 INIT_LIST_HEAD(&dev->dev_alloc_list); in __alloc_device()
432 INIT_LIST_HEAD(&dev->post_commit_list); in __alloc_device()
434 atomic_set(&dev->reada_in_flight, 0); in __alloc_device()
435 atomic_set(&dev->dev_stats_ccnt, 0); in __alloc_device()
437 INIT_RADIX_TREE(&dev->reada_zones, GFP_NOFS & ~__GFP_DIRECT_RECLAIM); in __alloc_device()
438 INIT_RADIX_TREE(&dev->reada_extents, GFP_NOFS & ~__GFP_DIRECT_RECLAIM); in __alloc_device()
439 extent_io_tree_init(fs_info, &dev->alloc_state, in __alloc_device()
452 /* Handle non-split brain cases */ in find_fsid()
455 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0 in find_fsid()
456 && memcmp(metadata_fsid, fs_devices->metadata_uuid, in find_fsid()
460 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0) in find_fsid()
480 if (fs_devices->fsid_change && in find_fsid_with_metadata_uuid()
481 memcmp(disk_super->metadata_uuid, fs_devices->fsid, in find_fsid_with_metadata_uuid()
483 memcmp(fs_devices->fsid, fs_devices->metadata_uuid, in find_fsid_with_metadata_uuid()
495 if (fs_devices->fsid_change && in find_fsid_with_metadata_uuid()
496 memcmp(fs_devices->metadata_uuid, in find_fsid_with_metadata_uuid()
497 fs_devices->fsid, BTRFS_FSID_SIZE) != 0 && in find_fsid_with_metadata_uuid()
498 memcmp(disk_super->metadata_uuid, fs_devices->metadata_uuid, in find_fsid_with_metadata_uuid()
504 return find_fsid(disk_super->fsid, disk_super->metadata_uuid); in find_fsid_with_metadata_uuid()
523 filemap_write_and_wait((*bdev)->bd_inode->i_mapping); in btrfs_get_bdev_and_sb()
545 * Check if the device in the path matches the device in the given struct device.
551 static bool device_matched(const struct btrfs_device *device, const char *path) in device_matched() argument
561 if (!device->name) in device_matched()
569 scnprintf(device_name, BTRFS_PATH_NAME_MAX, "%s", rcu_str_deref(device->name)); in device_matched()
577 bdev_new = lookup_bdev(path); in device_matched()
590 * path: Optional. When provided will it release all unmounted devices
591 * matching this path only.
594 * Return: 0 for success or if @path is NULL.
595 * -EBUSY if @path is a mounted device.
596 * -ENOENT if @path does not match any device in the list.
598 static int btrfs_free_stale_devices(const char *path, in btrfs_free_stale_devices() argument
607 if (path) in btrfs_free_stale_devices()
608 ret = -ENOENT; in btrfs_free_stale_devices()
612 mutex_lock(&fs_devices->device_list_mutex); in btrfs_free_stale_devices()
614 &fs_devices->devices, dev_list) { in btrfs_free_stale_devices()
617 if (path && !device_matched(device, path)) in btrfs_free_stale_devices()
619 if (fs_devices->opened) { in btrfs_free_stale_devices()
621 if (path && ret != 0) in btrfs_free_stale_devices()
622 ret = -EBUSY; in btrfs_free_stale_devices()
627 fs_devices->num_devices--; in btrfs_free_stale_devices()
628 list_del(&device->dev_list); in btrfs_free_stale_devices()
633 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_free_stale_devices()
635 if (fs_devices->num_devices == 0) { in btrfs_free_stale_devices()
637 list_del(&fs_devices->fs_list); in btrfs_free_stale_devices()
648 * fs_devices->device_list_mutex here.
660 if (device->bdev) in btrfs_open_one_device()
661 return -EINVAL; in btrfs_open_one_device()
662 if (!device->name) in btrfs_open_one_device()
663 return -EINVAL; in btrfs_open_one_device()
665 ret = btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1, in btrfs_open_one_device()
670 devid = btrfs_stack_device_id(&disk_super->dev_item); in btrfs_open_one_device()
671 if (devid != device->devid) in btrfs_open_one_device()
674 if (memcmp(device->uuid, disk_super->dev_item.uuid, BTRFS_UUID_SIZE)) in btrfs_open_one_device()
677 device->generation = btrfs_super_generation(disk_super); in btrfs_open_one_device()
683 "BTRFS: Invalid seeding and uuid-changed device detected\n"); in btrfs_open_one_device()
687 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_open_one_device()
688 fs_devices->seeding = true; in btrfs_open_one_device()
691 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_open_one_device()
693 set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_open_one_device()
698 fs_devices->rotating = true; in btrfs_open_one_device()
700 device->bdev = bdev; in btrfs_open_one_device()
701 clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_open_one_device()
702 device->mode = flags; in btrfs_open_one_device()
704 fs_devices->open_devices++; in btrfs_open_one_device()
705 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_open_one_device()
706 device->devid != BTRFS_DEV_REPLACE_DEVID) { in btrfs_open_one_device()
707 fs_devices->rw_devices++; in btrfs_open_one_device()
708 list_add_tail(&device->dev_alloc_list, &fs_devices->alloc_list); in btrfs_open_one_device()
718 return -EINVAL; in btrfs_open_one_device()
726 return has_metadata_uuid ? sb->metadata_uuid : sb->fsid; in btrfs_sb_fsid_ptr()
741 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, in find_fsid_inprogress()
743 memcmp(fs_devices->metadata_uuid, disk_super->fsid, in find_fsid_inprogress()
744 BTRFS_FSID_SIZE) == 0 && !fs_devices->fsid_change) { in find_fsid_inprogress()
749 return find_fsid(disk_super->fsid, NULL); in find_fsid_inprogress()
763 * 1 - The fs still continues to have different METADATA/FSID uuids. in find_fsid_changed()
764 * 2 - The fs is switched back to its original FSID (METADATA/FSID in find_fsid_changed()
769 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, in find_fsid_changed()
771 memcmp(fs_devices->metadata_uuid, disk_super->metadata_uuid, in find_fsid_changed()
773 memcmp(fs_devices->fsid, disk_super->fsid, in find_fsid_changed()
778 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, in find_fsid_changed()
780 memcmp(fs_devices->fsid, disk_super->metadata_uuid, in find_fsid_changed()
803 if (memcmp(fs_devices->fsid, fs_devices->metadata_uuid, in find_fsid_reverted_metadata()
805 memcmp(fs_devices->metadata_uuid, disk_super->fsid, in find_fsid_reverted_metadata()
807 fs_devices->fsid_change) in find_fsid_reverted_metadata()
820 static noinline struct btrfs_device *device_list_add(const char *path, in device_list_add() argument
828 u64 devid = btrfs_stack_device_id(&disk_super->dev_item); in device_list_add()
844 fs_devices = find_fsid(disk_super->fsid, NULL); in device_list_add()
850 fs_devices = alloc_fs_devices(disk_super->fsid, in device_list_add()
851 disk_super->metadata_uuid); in device_list_add()
853 fs_devices = alloc_fs_devices(disk_super->fsid, NULL); in device_list_add()
858 fs_devices->fsid_change = fsid_change_in_progress; in device_list_add()
860 mutex_lock(&fs_devices->device_list_mutex); in device_list_add()
861 list_add(&fs_devices->fs_list, &fs_uuids); in device_list_add()
865 mutex_lock(&fs_devices->device_list_mutex); in device_list_add()
867 disk_super->dev_item.uuid, NULL, false); in device_list_add()
874 if (fs_devices->fsid_change && in device_list_add()
875 found_transid > fs_devices->latest_generation) { in device_list_add()
876 memcpy(fs_devices->fsid, disk_super->fsid, in device_list_add()
880 memcpy(fs_devices->metadata_uuid, in device_list_add()
881 disk_super->metadata_uuid, in device_list_add()
884 memcpy(fs_devices->metadata_uuid, in device_list_add()
885 disk_super->fsid, BTRFS_FSID_SIZE); in device_list_add()
887 fs_devices->fsid_change = false; in device_list_add()
892 if (fs_devices->opened) { in device_list_add()
893 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
894 return ERR_PTR(-EBUSY); in device_list_add()
898 disk_super->dev_item.uuid); in device_list_add()
900 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
905 name = rcu_string_strdup(path, GFP_NOFS); in device_list_add()
908 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
909 return ERR_PTR(-ENOMEM); in device_list_add()
911 rcu_assign_pointer(device->name, name); in device_list_add()
913 list_add_rcu(&device->dev_list, &fs_devices->devices); in device_list_add()
914 fs_devices->num_devices++; in device_list_add()
916 device->fs_devices = fs_devices; in device_list_add()
919 if (disk_super->label[0]) in device_list_add()
922 disk_super->label, devid, found_transid, path, in device_list_add()
923 current->comm, task_pid_nr(current)); in device_list_add()
927 disk_super->fsid, devid, found_transid, path, in device_list_add()
928 current->comm, task_pid_nr(current)); in device_list_add()
930 } else if (!device->name || strcmp(device->name->str, path)) { in device_list_add()
933 * 1. If you are here and if the device->name is NULL that in device_list_add()
935 * 2. If you are here and if the device->name is different in device_list_add()
936 * from 'path' that means either in device_list_add()
939 * b. The missing-disk-which-was-replaced, has in device_list_add()
945 * Further in case of 1 and 2a above, the disk at 'path' in device_list_add()
957 if (!fs_devices->opened && found_transid < device->generation) { in device_list_add()
962 * with larger generation number or the last-in if in device_list_add()
965 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
966 return ERR_PTR(-EEXIST); in device_list_add()
970 * We are going to replace the device path for a given devid, in device_list_add()
973 if (device->bdev) { in device_list_add()
976 path_bdev = lookup_bdev(path); in device_list_add()
978 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
982 if (device->bdev != path_bdev) { in device_list_add()
984 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
986 * device->fs_info may not be reliable here, so in device_list_add()
988 * possible use-after-free when the fs_info and in device_list_add()
989 * fs_info->sb are already torn down. in device_list_add()
993 path, devid, found_transid, in device_list_add()
994 current->comm, in device_list_add()
996 return ERR_PTR(-EEXIST); in device_list_add()
999 btrfs_info_in_rcu(device->fs_info, in device_list_add()
1000 "devid %llu device path %s changed to %s scanned by %s (%d)", in device_list_add()
1001 devid, rcu_str_deref(device->name), in device_list_add()
1002 path, current->comm, in device_list_add()
1006 name = rcu_string_strdup(path, GFP_NOFS); in device_list_add()
1008 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
1009 return ERR_PTR(-ENOMEM); in device_list_add()
1011 rcu_string_free(device->name); in device_list_add()
1012 rcu_assign_pointer(device->name, name); in device_list_add()
1013 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in device_list_add()
1014 fs_devices->missing_devices--; in device_list_add()
1015 clear_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in device_list_add()
1025 if (!fs_devices->opened) { in device_list_add()
1026 device->generation = found_transid; in device_list_add()
1027 fs_devices->latest_generation = max_t(u64, found_transid, in device_list_add()
1028 fs_devices->latest_generation); in device_list_add()
1031 fs_devices->total_devices = btrfs_super_num_devices(disk_super); in device_list_add()
1033 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
1046 fs_devices = alloc_fs_devices(orig->fsid, NULL); in clone_fs_devices()
1050 fs_devices->total_devices = orig->total_devices; in clone_fs_devices()
1052 list_for_each_entry(orig_dev, &orig->devices, dev_list) { in clone_fs_devices()
1055 device = btrfs_alloc_device(NULL, &orig_dev->devid, in clone_fs_devices()
1056 orig_dev->uuid); in clone_fs_devices()
1066 if (orig_dev->name) { in clone_fs_devices()
1067 name = rcu_string_strdup(orig_dev->name->str, in clone_fs_devices()
1071 ret = -ENOMEM; in clone_fs_devices()
1074 rcu_assign_pointer(device->name, name); in clone_fs_devices()
1077 list_add(&device->dev_list, &fs_devices->devices); in clone_fs_devices()
1078 device->fs_devices = fs_devices; in clone_fs_devices()
1079 fs_devices->num_devices++; in clone_fs_devices()
1092 /* This is the initialized path, it is safe to release the devices. */ in __btrfs_free_extra_devids()
1093 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) { in __btrfs_free_extra_devids()
1094 if (test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state)) { in __btrfs_free_extra_devids()
1096 &device->dev_state) && in __btrfs_free_extra_devids()
1098 &device->dev_state) && in __btrfs_free_extra_devids()
1100 device->generation > (*latest_dev)->generation)) { in __btrfs_free_extra_devids()
1110 if (device->devid == BTRFS_DEV_REPLACE_DEVID) in __btrfs_free_extra_devids()
1113 if (device->bdev) { in __btrfs_free_extra_devids()
1114 blkdev_put(device->bdev, device->mode); in __btrfs_free_extra_devids()
1115 device->bdev = NULL; in __btrfs_free_extra_devids()
1116 fs_devices->open_devices--; in __btrfs_free_extra_devids()
1118 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in __btrfs_free_extra_devids()
1119 list_del_init(&device->dev_alloc_list); in __btrfs_free_extra_devids()
1120 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in __btrfs_free_extra_devids()
1121 fs_devices->rw_devices--; in __btrfs_free_extra_devids()
1123 list_del_init(&device->dev_list); in __btrfs_free_extra_devids()
1124 fs_devices->num_devices--; in __btrfs_free_extra_devids()
1142 list_for_each_entry(seed_dev, &fs_devices->seed_list, seed_list) in btrfs_free_extra_devids()
1145 fs_devices->latest_bdev = latest_dev->bdev; in btrfs_free_extra_devids()
1152 if (!device->bdev) in btrfs_close_bdev()
1155 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_close_bdev()
1156 sync_blockdev(device->bdev); in btrfs_close_bdev()
1157 invalidate_bdev(device->bdev); in btrfs_close_bdev()
1160 blkdev_put(device->bdev, device->mode); in btrfs_close_bdev()
1165 struct btrfs_fs_devices *fs_devices = device->fs_devices; in btrfs_close_one_device()
1167 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_close_one_device()
1168 device->devid != BTRFS_DEV_REPLACE_DEVID) { in btrfs_close_one_device()
1169 list_del_init(&device->dev_alloc_list); in btrfs_close_one_device()
1170 fs_devices->rw_devices--; in btrfs_close_one_device()
1173 if (device->devid == BTRFS_DEV_REPLACE_DEVID) in btrfs_close_one_device()
1174 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in btrfs_close_one_device()
1176 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in btrfs_close_one_device()
1177 clear_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in btrfs_close_one_device()
1178 fs_devices->missing_devices--; in btrfs_close_one_device()
1182 if (device->bdev) { in btrfs_close_one_device()
1183 fs_devices->open_devices--; in btrfs_close_one_device()
1184 device->bdev = NULL; in btrfs_close_one_device()
1186 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_close_one_device()
1188 device->fs_info = NULL; in btrfs_close_one_device()
1189 atomic_set(&device->dev_stats_ccnt, 0); in btrfs_close_one_device()
1190 extent_io_tree_release(&device->alloc_state); in btrfs_close_one_device()
1198 * (btrfs_check_rw_degradable() should not fail) - if after mounting the in btrfs_close_one_device()
1203 device->last_flush_error = 0; in btrfs_close_one_device()
1206 ASSERT(!test_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state)); in btrfs_close_one_device()
1207 ASSERT(!test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)); in btrfs_close_one_device()
1208 ASSERT(list_empty(&device->dev_alloc_list)); in btrfs_close_one_device()
1209 ASSERT(list_empty(&device->post_commit_list)); in btrfs_close_one_device()
1210 ASSERT(atomic_read(&device->reada_in_flight) == 0); in btrfs_close_one_device()
1219 if (--fs_devices->opened > 0) in close_fs_devices()
1222 list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list) in close_fs_devices()
1225 WARN_ON(fs_devices->open_devices); in close_fs_devices()
1226 WARN_ON(fs_devices->rw_devices); in close_fs_devices()
1227 fs_devices->opened = 0; in close_fs_devices()
1228 fs_devices->seeding = false; in close_fs_devices()
1229 fs_devices->fs_info = NULL; in close_fs_devices()
1239 if (!fs_devices->opened) { in btrfs_close_devices()
1240 list_splice_init(&fs_devices->seed_list, &list); in btrfs_close_devices()
1244 * other device, it can be re-initialized during the next mount in btrfs_close_devices()
1245 * without the needing device-scan step. Therefore, it can be in btrfs_close_devices()
1248 if (fs_devices->num_devices == 1) { in btrfs_close_devices()
1249 list_del(&fs_devices->fs_list); in btrfs_close_devices()
1257 list_del(&fs_devices->seed_list); in btrfs_close_devices()
1272 list_for_each_entry_safe(device, tmp_device, &fs_devices->devices, in open_fs_devices()
1278 (!latest_dev || device->generation > latest_dev->generation)) { in open_fs_devices()
1280 } else if (ret == -ENODATA) { in open_fs_devices()
1281 fs_devices->num_devices--; in open_fs_devices()
1282 list_del(&device->dev_list); in open_fs_devices()
1286 if (fs_devices->open_devices == 0) in open_fs_devices()
1287 return -EINVAL; in open_fs_devices()
1289 fs_devices->opened = 1; in open_fs_devices()
1290 fs_devices->latest_bdev = latest_dev->bdev; in open_fs_devices()
1291 fs_devices->total_rw_bytes = 0; in open_fs_devices()
1292 fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_REGULAR; in open_fs_devices()
1305 if (dev1->devid < dev2->devid) in devid_cmp()
1306 return -1; in devid_cmp()
1307 else if (dev1->devid > dev2->devid) in devid_cmp()
1326 if (fs_devices->opened) { in btrfs_open_devices()
1327 fs_devices->opened++; in btrfs_open_devices()
1330 list_sort(NULL, &fs_devices->devices, devid_cmp); in btrfs_open_devices()
1353 if (bytenr + PAGE_SIZE >= i_size_read(bdev->bd_inode)) in btrfs_read_disk_super()
1354 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1358 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1362 if ((bytenr + sizeof(*disk_super) - 1) >> PAGE_SHIFT != index) in btrfs_read_disk_super()
1363 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1366 page = read_cache_page_gfp(bdev->bd_inode->i_mapping, index, GFP_KERNEL); in btrfs_read_disk_super()
1379 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1382 if (disk_super->label[0] && disk_super->label[BTRFS_LABEL_SIZE - 1]) in btrfs_read_disk_super()
1383 disk_super->label[BTRFS_LABEL_SIZE - 1] = 0; in btrfs_read_disk_super()
1388 int btrfs_forget_devices(const char *path) in btrfs_forget_devices() argument
1393 ret = btrfs_free_stale_devices(strlen(path) ? path : NULL, NULL); in btrfs_forget_devices()
1400 * Look for a btrfs signature on a device. This may be called out of the mount path
1404 struct btrfs_device *btrfs_scan_one_device(const char *path, fmode_t flags, in btrfs_scan_one_device() argument
1424 * Avoid using flag |= FMODE_EXCL here, as the systemd-udev may in btrfs_scan_one_device()
1433 bdev = blkdev_get_by_path(path, flags, holder); in btrfs_scan_one_device()
1443 device = device_list_add(path, disk_super, &new_device_added); in btrfs_scan_one_device()
1446 btrfs_free_stale_devices(path, device); in btrfs_scan_one_device()
1466 lockdep_assert_held(&device->fs_info->chunk_mutex); in contains_pending_extent()
1468 if (!find_first_extent_bit(&device->alloc_state, *start, in contains_pending_extent()
1474 physical_end - physical_start)) { in contains_pending_extent()
1484 switch (device->fs_devices->chunk_alloc_policy) { in dev_extent_search_start()
1498 * dev_extent_hole_check - check if specified hole is suitable for allocation
1519 *hole_size = hole_end - *hole_start; in dev_extent_hole_check()
1525 switch (device->fs_devices->chunk_alloc_policy) { in dev_extent_hole_check()
1537 * find_free_dev_extent_start - find free space in the specified device
1567 struct btrfs_fs_info *fs_info = device->fs_info; in find_free_dev_extent_start()
1568 struct btrfs_root *root = fs_info->dev_root; in find_free_dev_extent_start()
1571 struct btrfs_path *path; in find_free_dev_extent_start() local
1576 u64 search_end = device->total_bytes; in find_free_dev_extent_start()
1583 path = btrfs_alloc_path(); in find_free_dev_extent_start()
1584 if (!path) in find_free_dev_extent_start()
1585 return -ENOMEM; in find_free_dev_extent_start()
1592 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in find_free_dev_extent_start()
1593 ret = -ENOSPC; in find_free_dev_extent_start()
1597 path->reada = READA_FORWARD; in find_free_dev_extent_start()
1598 path->search_commit_root = 1; in find_free_dev_extent_start()
1599 path->skip_locking = 1; in find_free_dev_extent_start()
1601 key.objectid = device->devid; in find_free_dev_extent_start()
1605 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); in find_free_dev_extent_start()
1609 ret = btrfs_previous_item(root, path, key.objectid, key.type); in find_free_dev_extent_start()
1615 l = path->nodes[0]; in find_free_dev_extent_start()
1616 slot = path->slots[0]; in find_free_dev_extent_start()
1618 ret = btrfs_next_leaf(root, path); in find_free_dev_extent_start()
1628 if (key.objectid < device->devid) in find_free_dev_extent_start()
1631 if (key.objectid > device->devid) in find_free_dev_extent_start()
1641 hole_size = key.offset - search_start; in find_free_dev_extent_start()
1671 path->slots[0]++; in find_free_dev_extent_start()
1681 hole_size = search_end - search_start; in find_free_dev_extent_start()
1684 btrfs_release_path(path); in find_free_dev_extent_start()
1696 ret = -ENOSPC; in find_free_dev_extent_start()
1702 btrfs_free_path(path); in find_free_dev_extent_start()
1720 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_free_dev_extent()
1721 struct btrfs_root *root = fs_info->dev_root; in btrfs_free_dev_extent()
1723 struct btrfs_path *path; in btrfs_free_dev_extent() local
1729 path = btrfs_alloc_path(); in btrfs_free_dev_extent()
1730 if (!path) in btrfs_free_dev_extent()
1731 return -ENOMEM; in btrfs_free_dev_extent()
1733 key.objectid = device->devid; in btrfs_free_dev_extent()
1737 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_free_dev_extent()
1739 ret = btrfs_previous_item(root, path, key.objectid, in btrfs_free_dev_extent()
1743 leaf = path->nodes[0]; in btrfs_free_dev_extent()
1744 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_free_dev_extent()
1745 extent = btrfs_item_ptr(leaf, path->slots[0], in btrfs_free_dev_extent()
1750 btrfs_release_path(path); in btrfs_free_dev_extent()
1753 leaf = path->nodes[0]; in btrfs_free_dev_extent()
1754 extent = btrfs_item_ptr(leaf, path->slots[0], in btrfs_free_dev_extent()
1763 ret = btrfs_del_item(trans, root, path); in btrfs_free_dev_extent()
1768 set_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags); in btrfs_free_dev_extent()
1771 btrfs_free_path(path); in btrfs_free_dev_extent()
1780 struct btrfs_path *path; in btrfs_alloc_dev_extent() local
1781 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_alloc_dev_extent()
1782 struct btrfs_root *root = fs_info->dev_root; in btrfs_alloc_dev_extent()
1787 WARN_ON(!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state)); in btrfs_alloc_dev_extent()
1788 WARN_ON(test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)); in btrfs_alloc_dev_extent()
1789 path = btrfs_alloc_path(); in btrfs_alloc_dev_extent()
1790 if (!path) in btrfs_alloc_dev_extent()
1791 return -ENOMEM; in btrfs_alloc_dev_extent()
1793 key.objectid = device->devid; in btrfs_alloc_dev_extent()
1796 ret = btrfs_insert_empty_item(trans, root, path, &key, in btrfs_alloc_dev_extent()
1801 leaf = path->nodes[0]; in btrfs_alloc_dev_extent()
1802 extent = btrfs_item_ptr(leaf, path->slots[0], in btrfs_alloc_dev_extent()
1813 btrfs_free_path(path); in btrfs_alloc_dev_extent()
1824 em_tree = &fs_info->mapping_tree; in find_next_chunk()
1825 read_lock(&em_tree->lock); in find_next_chunk()
1826 n = rb_last(&em_tree->map.rb_root); in find_next_chunk()
1829 ret = em->start + em->len; in find_next_chunk()
1831 read_unlock(&em_tree->lock); in find_next_chunk()
1842 struct btrfs_path *path; in find_next_devid() local
1844 path = btrfs_alloc_path(); in find_next_devid()
1845 if (!path) in find_next_devid()
1846 return -ENOMEM; in find_next_devid()
1850 key.offset = (u64)-1; in find_next_devid()
1852 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0); in find_next_devid()
1858 btrfs_err(fs_info, "corrupted chunk tree devid -1 matched"); in find_next_devid()
1859 ret = -EUCLEAN; in find_next_devid()
1863 ret = btrfs_previous_item(fs_info->chunk_root, path, in find_next_devid()
1869 btrfs_item_key_to_cpu(path->nodes[0], &found_key, in find_next_devid()
1870 path->slots[0]); in find_next_devid()
1875 btrfs_free_path(path); in find_next_devid()
1887 struct btrfs_path *path; in btrfs_add_dev_item() local
1893 path = btrfs_alloc_path(); in btrfs_add_dev_item()
1894 if (!path) in btrfs_add_dev_item()
1895 return -ENOMEM; in btrfs_add_dev_item()
1899 key.offset = device->devid; in btrfs_add_dev_item()
1901 ret = btrfs_insert_empty_item(trans, trans->fs_info->chunk_root, path, in btrfs_add_dev_item()
1906 leaf = path->nodes[0]; in btrfs_add_dev_item()
1907 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); in btrfs_add_dev_item()
1909 btrfs_set_device_id(leaf, dev_item, device->devid); in btrfs_add_dev_item()
1911 btrfs_set_device_type(leaf, dev_item, device->type); in btrfs_add_dev_item()
1912 btrfs_set_device_io_align(leaf, dev_item, device->io_align); in btrfs_add_dev_item()
1913 btrfs_set_device_io_width(leaf, dev_item, device->io_width); in btrfs_add_dev_item()
1914 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size); in btrfs_add_dev_item()
1925 write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); in btrfs_add_dev_item()
1927 write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid, in btrfs_add_dev_item()
1933 btrfs_free_path(path); in btrfs_add_dev_item()
1938 * Function to update ctime/mtime for a given device path.
1945 struct path path; in update_dev_time() local
1949 ret = kern_path(device_path, LOOKUP_FOLLOW, &path); in update_dev_time()
1953 now = current_time(d_inode(path.dentry)); in update_dev_time()
1954 inode_update_time(d_inode(path.dentry), &now, S_MTIME | S_CTIME); in update_dev_time()
1955 path_put(&path); in update_dev_time()
1960 struct btrfs_root *root = device->fs_info->chunk_root; in btrfs_rm_dev_item()
1962 struct btrfs_path *path; in btrfs_rm_dev_item() local
1966 path = btrfs_alloc_path(); in btrfs_rm_dev_item()
1967 if (!path) in btrfs_rm_dev_item()
1968 return -ENOMEM; in btrfs_rm_dev_item()
1972 btrfs_free_path(path); in btrfs_rm_dev_item()
1977 key.offset = device->devid; in btrfs_rm_dev_item()
1979 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_rm_dev_item()
1982 ret = -ENOENT; in btrfs_rm_dev_item()
1988 ret = btrfs_del_item(trans, root, path); in btrfs_rm_dev_item()
1995 btrfs_free_path(path); in btrfs_rm_dev_item()
2014 seq = read_seqbegin(&fs_info->profiles_lock); in btrfs_check_raid_min_devices()
2016 all_avail = fs_info->avail_data_alloc_bits | in btrfs_check_raid_min_devices()
2017 fs_info->avail_system_alloc_bits | in btrfs_check_raid_min_devices()
2018 fs_info->avail_metadata_alloc_bits; in btrfs_check_raid_min_devices()
2019 } while (read_seqretry(&fs_info->profiles_lock, seq)); in btrfs_check_raid_min_devices()
2041 list_for_each_entry(next_device, &fs_devs->devices, dev_list) { in btrfs_find_next_active_device()
2043 !test_bit(BTRFS_DEV_STATE_MISSING, &next_device->dev_state) in btrfs_find_next_active_device()
2044 && next_device->bdev) in btrfs_find_next_active_device()
2060 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_assign_next_active_device()
2063 next_device = btrfs_find_next_active_device(fs_info->fs_devices, in btrfs_assign_next_active_device()
2067 if (fs_info->sb->s_bdev && in btrfs_assign_next_active_device()
2068 (fs_info->sb->s_bdev == device->bdev)) in btrfs_assign_next_active_device()
2069 fs_info->sb->s_bdev = next_device->bdev; in btrfs_assign_next_active_device()
2071 if (fs_info->fs_devices->latest_bdev == device->bdev) in btrfs_assign_next_active_device()
2072 fs_info->fs_devices->latest_bdev = next_device->bdev; in btrfs_assign_next_active_device()
2081 u64 num_devices = fs_info->fs_devices->num_devices; in btrfs_num_devices()
2083 down_read(&fs_info->dev_replace.rwsem); in btrfs_num_devices()
2084 if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) { in btrfs_num_devices()
2086 num_devices--; in btrfs_num_devices()
2088 up_read(&fs_info->dev_replace.rwsem); in btrfs_num_devices()
2111 memset(&disk_super->magic, 0, sizeof(disk_super->magic)); in btrfs_scratch_superblocks()
2129 /* Update ctime/mtime for device path for libblkid */ in btrfs_scratch_superblocks()
2138 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_rm_device()
2149 ret = btrfs_check_raid_min_devices(fs_info, num_devices - 1); in btrfs_rm_device()
2156 if (PTR_ERR(device) == -ENOENT && in btrfs_rm_device()
2167 rcu_str_deref(device->name), device->devid); in btrfs_rm_device()
2168 ret = -ETXTBSY; in btrfs_rm_device()
2172 if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in btrfs_rm_device()
2177 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_rm_device()
2178 fs_info->fs_devices->rw_devices == 1) { in btrfs_rm_device()
2183 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_rm_device()
2184 mutex_lock(&fs_info->chunk_mutex); in btrfs_rm_device()
2185 list_del_init(&device->dev_alloc_list); in btrfs_rm_device()
2186 device->fs_devices->rw_devices--; in btrfs_rm_device()
2187 mutex_unlock(&fs_info->chunk_mutex); in btrfs_rm_device()
2205 clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_rm_device()
2221 * its own fs_devices listed under the fs_devices->seed. in btrfs_rm_device()
2223 cur_devices = device->fs_devices; in btrfs_rm_device()
2224 mutex_lock(&fs_devices->device_list_mutex); in btrfs_rm_device()
2225 list_del_rcu(&device->dev_list); in btrfs_rm_device()
2227 cur_devices->num_devices--; in btrfs_rm_device()
2228 cur_devices->total_devices--; in btrfs_rm_device()
2231 fs_devices->total_devices--; in btrfs_rm_device()
2233 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) in btrfs_rm_device()
2234 cur_devices->missing_devices--; in btrfs_rm_device()
2238 if (device->bdev) { in btrfs_rm_device()
2239 cur_devices->open_devices--; in btrfs_rm_device()
2244 num_devices = btrfs_super_num_devices(fs_info->super_copy) - 1; in btrfs_rm_device()
2245 btrfs_set_super_num_devices(fs_info->super_copy, num_devices); in btrfs_rm_device()
2246 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_rm_device()
2253 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) in btrfs_rm_device()
2254 btrfs_scratch_superblocks(fs_info, device->bdev, in btrfs_rm_device()
2255 device->name->str); in btrfs_rm_device()
2261 if (cur_devices->open_devices == 0) { in btrfs_rm_device()
2262 list_del_init(&cur_devices->seed_list); in btrfs_rm_device()
2272 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_rm_device()
2273 mutex_lock(&fs_info->chunk_mutex); in btrfs_rm_device()
2274 list_add(&device->dev_alloc_list, in btrfs_rm_device()
2275 &fs_devices->alloc_list); in btrfs_rm_device()
2276 device->fs_devices->rw_devices++; in btrfs_rm_device()
2277 mutex_unlock(&fs_info->chunk_mutex); in btrfs_rm_device()
2286 lockdep_assert_held(&srcdev->fs_info->fs_devices->device_list_mutex); in btrfs_rm_dev_replace_remove_srcdev()
2289 * in case of fs with no seed, srcdev->fs_devices will point in btrfs_rm_dev_replace_remove_srcdev()
2294 fs_devices = srcdev->fs_devices; in btrfs_rm_dev_replace_remove_srcdev()
2296 list_del_rcu(&srcdev->dev_list); in btrfs_rm_dev_replace_remove_srcdev()
2297 list_del(&srcdev->dev_alloc_list); in btrfs_rm_dev_replace_remove_srcdev()
2298 fs_devices->num_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2299 if (test_bit(BTRFS_DEV_STATE_MISSING, &srcdev->dev_state)) in btrfs_rm_dev_replace_remove_srcdev()
2300 fs_devices->missing_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2302 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &srcdev->dev_state)) in btrfs_rm_dev_replace_remove_srcdev()
2303 fs_devices->rw_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2305 if (srcdev->bdev) in btrfs_rm_dev_replace_remove_srcdev()
2306 fs_devices->open_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2311 struct btrfs_fs_devices *fs_devices = srcdev->fs_devices; in btrfs_rm_dev_replace_free_srcdev()
2320 if (!fs_devices->num_devices) { in btrfs_rm_dev_replace_free_srcdev()
2327 ASSERT(fs_devices->seeding); in btrfs_rm_dev_replace_free_srcdev()
2329 list_del_init(&fs_devices->seed_list); in btrfs_rm_dev_replace_free_srcdev()
2338 struct btrfs_fs_devices *fs_devices = tgtdev->fs_info->fs_devices; in btrfs_destroy_dev_replace_tgtdev()
2340 mutex_lock(&fs_devices->device_list_mutex); in btrfs_destroy_dev_replace_tgtdev()
2344 if (tgtdev->bdev) in btrfs_destroy_dev_replace_tgtdev()
2345 fs_devices->open_devices--; in btrfs_destroy_dev_replace_tgtdev()
2347 fs_devices->num_devices--; in btrfs_destroy_dev_replace_tgtdev()
2351 list_del_rcu(&tgtdev->dev_list); in btrfs_destroy_dev_replace_tgtdev()
2353 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_destroy_dev_replace_tgtdev()
2362 btrfs_scratch_superblocks(tgtdev->fs_info, tgtdev->bdev, in btrfs_destroy_dev_replace_tgtdev()
2363 tgtdev->name->str); in btrfs_destroy_dev_replace_tgtdev()
2381 fs_info->bdev_holder, 0, &bdev, &disk_super); in btrfs_find_device_by_path()
2385 devid = btrfs_stack_device_id(&disk_super->dev_item); in btrfs_find_device_by_path()
2386 dev_uuid = disk_super->dev_item.uuid; in btrfs_find_device_by_path()
2388 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid, in btrfs_find_device_by_path()
2389 disk_super->metadata_uuid, true); in btrfs_find_device_by_path()
2391 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid, in btrfs_find_device_by_path()
2392 disk_super->fsid, true); in btrfs_find_device_by_path()
2396 device = ERR_PTR(-ENOENT); in btrfs_find_device_by_path()
2402 * Lookup a device given by device id, or the path if the id is 0.
2411 device = btrfs_find_device(fs_info->fs_devices, devid, NULL, in btrfs_find_device_by_devspec()
2414 return ERR_PTR(-ENOENT); in btrfs_find_device_by_devspec()
2419 return ERR_PTR(-EINVAL); in btrfs_find_device_by_devspec()
2423 list_for_each_entry(device, &fs_info->fs_devices->devices, in btrfs_find_device_by_devspec()
2426 &device->dev_state) && !device->bdev) in btrfs_find_device_by_devspec()
2429 return ERR_PTR(-ENOENT); in btrfs_find_device_by_devspec()
2440 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_prepare_sprout()
2443 struct btrfs_super_block *disk_super = fs_info->super_copy; in btrfs_prepare_sprout()
2448 if (!fs_devices->seeding) in btrfs_prepare_sprout()
2449 return -EINVAL; in btrfs_prepare_sprout()
2453 * fs_info->fs_devices->seed_list in btrfs_prepare_sprout()
2471 list_add(&old_devices->fs_list, &fs_uuids); in btrfs_prepare_sprout()
2474 seed_devices->opened = 1; in btrfs_prepare_sprout()
2475 INIT_LIST_HEAD(&seed_devices->devices); in btrfs_prepare_sprout()
2476 INIT_LIST_HEAD(&seed_devices->alloc_list); in btrfs_prepare_sprout()
2477 mutex_init(&seed_devices->device_list_mutex); in btrfs_prepare_sprout()
2479 mutex_lock(&fs_devices->device_list_mutex); in btrfs_prepare_sprout()
2480 list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices, in btrfs_prepare_sprout()
2482 list_for_each_entry(device, &seed_devices->devices, dev_list) in btrfs_prepare_sprout()
2483 device->fs_devices = seed_devices; in btrfs_prepare_sprout()
2485 fs_devices->seeding = false; in btrfs_prepare_sprout()
2486 fs_devices->num_devices = 0; in btrfs_prepare_sprout()
2487 fs_devices->open_devices = 0; in btrfs_prepare_sprout()
2488 fs_devices->missing_devices = 0; in btrfs_prepare_sprout()
2489 fs_devices->rotating = false; in btrfs_prepare_sprout()
2490 list_add(&seed_devices->seed_list, &fs_devices->seed_list); in btrfs_prepare_sprout()
2492 generate_random_uuid(fs_devices->fsid); in btrfs_prepare_sprout()
2493 memcpy(fs_devices->metadata_uuid, fs_devices->fsid, BTRFS_FSID_SIZE); in btrfs_prepare_sprout()
2494 memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE); in btrfs_prepare_sprout()
2495 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_prepare_sprout()
2509 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_finish_sprout()
2510 struct btrfs_root *root = fs_info->chunk_root; in btrfs_finish_sprout()
2511 struct btrfs_path *path; in btrfs_finish_sprout() local
2521 path = btrfs_alloc_path(); in btrfs_finish_sprout()
2522 if (!path) in btrfs_finish_sprout()
2523 return -ENOMEM; in btrfs_finish_sprout()
2530 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); in btrfs_finish_sprout()
2534 leaf = path->nodes[0]; in btrfs_finish_sprout()
2536 if (path->slots[0] >= btrfs_header_nritems(leaf)) { in btrfs_finish_sprout()
2537 ret = btrfs_next_leaf(root, path); in btrfs_finish_sprout()
2542 leaf = path->nodes[0]; in btrfs_finish_sprout()
2543 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_finish_sprout()
2544 btrfs_release_path(path); in btrfs_finish_sprout()
2548 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_finish_sprout()
2553 dev_item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_finish_sprout()
2560 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid, in btrfs_finish_sprout()
2564 if (device->fs_devices->seeding) { in btrfs_finish_sprout()
2566 device->generation); in btrfs_finish_sprout()
2570 path->slots[0]++; in btrfs_finish_sprout()
2575 btrfs_free_path(path); in btrfs_finish_sprout()
2581 struct btrfs_root *root = fs_info->dev_root; in btrfs_init_new_device()
2586 struct super_block *sb = fs_info->sb; in btrfs_init_new_device()
2588 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_init_new_device()
2595 if (sb_rdonly(sb) && !fs_devices->seeding) in btrfs_init_new_device()
2596 return -EROFS; in btrfs_init_new_device()
2599 fs_info->bdev_holder); in btrfs_init_new_device()
2603 if (fs_devices->seeding) { in btrfs_init_new_device()
2605 down_write(&sb->s_umount); in btrfs_init_new_device()
2613 list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) { in btrfs_init_new_device()
2614 if (device->bdev == bdev) { in btrfs_init_new_device()
2615 ret = -EEXIST; in btrfs_init_new_device()
2631 ret = -ENOMEM; in btrfs_init_new_device()
2634 rcu_assign_pointer(device->name, name); in btrfs_init_new_device()
2643 set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_init_new_device()
2644 device->generation = trans->transid; in btrfs_init_new_device()
2645 device->io_width = fs_info->sectorsize; in btrfs_init_new_device()
2646 device->io_align = fs_info->sectorsize; in btrfs_init_new_device()
2647 device->sector_size = fs_info->sectorsize; in btrfs_init_new_device()
2648 device->total_bytes = round_down(i_size_read(bdev->bd_inode), in btrfs_init_new_device()
2649 fs_info->sectorsize); in btrfs_init_new_device()
2650 device->disk_total_bytes = device->total_bytes; in btrfs_init_new_device()
2651 device->commit_total_bytes = device->total_bytes; in btrfs_init_new_device()
2652 device->fs_info = fs_info; in btrfs_init_new_device()
2653 device->bdev = bdev; in btrfs_init_new_device()
2654 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_init_new_device()
2655 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in btrfs_init_new_device()
2656 device->mode = FMODE_EXCL; in btrfs_init_new_device()
2657 device->dev_stats_valid = 1; in btrfs_init_new_device()
2658 set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE); in btrfs_init_new_device()
2661 sb->s_flags &= ~SB_RDONLY; in btrfs_init_new_device()
2669 device->fs_devices = fs_devices; in btrfs_init_new_device()
2671 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_new_device()
2672 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2673 list_add_rcu(&device->dev_list, &fs_devices->devices); in btrfs_init_new_device()
2674 list_add(&device->dev_alloc_list, &fs_devices->alloc_list); in btrfs_init_new_device()
2675 fs_devices->num_devices++; in btrfs_init_new_device()
2676 fs_devices->open_devices++; in btrfs_init_new_device()
2677 fs_devices->rw_devices++; in btrfs_init_new_device()
2678 fs_devices->total_devices++; in btrfs_init_new_device()
2679 fs_devices->total_rw_bytes += device->total_bytes; in btrfs_init_new_device()
2681 atomic64_add(device->total_bytes, &fs_info->free_chunk_space); in btrfs_init_new_device()
2684 fs_devices->rotating = true; in btrfs_init_new_device()
2686 orig_super_total_bytes = btrfs_super_total_bytes(fs_info->super_copy); in btrfs_init_new_device()
2687 btrfs_set_super_total_bytes(fs_info->super_copy, in btrfs_init_new_device()
2688 round_down(orig_super_total_bytes + device->total_bytes, in btrfs_init_new_device()
2689 fs_info->sectorsize)); in btrfs_init_new_device()
2691 orig_super_num_devices = btrfs_super_num_devices(fs_info->super_copy); in btrfs_init_new_device()
2692 btrfs_set_super_num_devices(fs_info->super_copy, in btrfs_init_new_device()
2701 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2706 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_new_device()
2709 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2711 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2742 up_write(&sb->s_umount); in btrfs_init_new_device()
2754 if (PTR_ERR(trans) == -ENOENT) in btrfs_init_new_device()
2767 * We can ignore the return value as it typically returns -EINVAL and in btrfs_init_new_device()
2779 mutex_lock(&fs_info->fs_devices->device_list_mutex); in btrfs_init_new_device()
2780 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2781 list_del_rcu(&device->dev_list); in btrfs_init_new_device()
2782 list_del(&device->dev_alloc_list); in btrfs_init_new_device()
2783 fs_info->fs_devices->num_devices--; in btrfs_init_new_device()
2784 fs_info->fs_devices->open_devices--; in btrfs_init_new_device()
2785 fs_info->fs_devices->rw_devices--; in btrfs_init_new_device()
2786 fs_info->fs_devices->total_devices--; in btrfs_init_new_device()
2787 fs_info->fs_devices->total_rw_bytes -= device->total_bytes; in btrfs_init_new_device()
2788 atomic64_sub(device->total_bytes, &fs_info->free_chunk_space); in btrfs_init_new_device()
2789 btrfs_set_super_total_bytes(fs_info->super_copy, in btrfs_init_new_device()
2791 btrfs_set_super_num_devices(fs_info->super_copy, in btrfs_init_new_device()
2793 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2794 mutex_unlock(&fs_info->fs_devices->device_list_mutex); in btrfs_init_new_device()
2797 sb->s_flags |= SB_RDONLY; in btrfs_init_new_device()
2806 up_write(&sb->s_umount); in btrfs_init_new_device()
2815 struct btrfs_path *path; in btrfs_update_device() local
2816 struct btrfs_root *root = device->fs_info->chunk_root; in btrfs_update_device()
2821 path = btrfs_alloc_path(); in btrfs_update_device()
2822 if (!path) in btrfs_update_device()
2823 return -ENOMEM; in btrfs_update_device()
2827 key.offset = device->devid; in btrfs_update_device()
2829 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); in btrfs_update_device()
2834 ret = -ENOENT; in btrfs_update_device()
2838 leaf = path->nodes[0]; in btrfs_update_device()
2839 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); in btrfs_update_device()
2841 btrfs_set_device_id(leaf, dev_item, device->devid); in btrfs_update_device()
2842 btrfs_set_device_type(leaf, dev_item, device->type); in btrfs_update_device()
2843 btrfs_set_device_io_align(leaf, dev_item, device->io_align); in btrfs_update_device()
2844 btrfs_set_device_io_width(leaf, dev_item, device->io_width); in btrfs_update_device()
2845 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size); in btrfs_update_device()
2853 btrfs_free_path(path); in btrfs_update_device()
2860 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_grow_device()
2861 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_grow_device()
2865 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) in btrfs_grow_device()
2866 return -EACCES; in btrfs_grow_device()
2868 new_size = round_down(new_size, fs_info->sectorsize); in btrfs_grow_device()
2870 mutex_lock(&fs_info->chunk_mutex); in btrfs_grow_device()
2872 diff = round_down(new_size - device->total_bytes, fs_info->sectorsize); in btrfs_grow_device()
2874 if (new_size <= device->total_bytes || in btrfs_grow_device()
2875 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in btrfs_grow_device()
2876 mutex_unlock(&fs_info->chunk_mutex); in btrfs_grow_device()
2877 return -EINVAL; in btrfs_grow_device()
2881 round_down(old_total + diff, fs_info->sectorsize)); in btrfs_grow_device()
2882 device->fs_devices->total_rw_bytes += diff; in btrfs_grow_device()
2886 btrfs_clear_space_info_full(device->fs_info); in btrfs_grow_device()
2887 if (list_empty(&device->post_commit_list)) in btrfs_grow_device()
2888 list_add_tail(&device->post_commit_list, in btrfs_grow_device()
2889 &trans->transaction->dev_update_list); in btrfs_grow_device()
2890 mutex_unlock(&fs_info->chunk_mutex); in btrfs_grow_device()
2897 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_free_chunk()
2898 struct btrfs_root *root = fs_info->chunk_root; in btrfs_free_chunk()
2900 struct btrfs_path *path; in btrfs_free_chunk() local
2903 path = btrfs_alloc_path(); in btrfs_free_chunk()
2904 if (!path) in btrfs_free_chunk()
2905 return -ENOMEM; in btrfs_free_chunk()
2911 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_free_chunk()
2915 btrfs_handle_fs_error(fs_info, -ENOENT, in btrfs_free_chunk()
2917 ret = -ENOENT; in btrfs_free_chunk()
2921 ret = btrfs_del_item(trans, root, path); in btrfs_free_chunk()
2926 btrfs_free_path(path); in btrfs_free_chunk()
2932 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_del_sys_chunk()
2943 mutex_lock(&fs_info->chunk_mutex); in btrfs_del_sys_chunk()
2946 ptr = super_copy->sys_chunk_array; in btrfs_del_sys_chunk()
2960 ret = -EIO; in btrfs_del_sys_chunk()
2965 memmove(ptr, ptr + len, array_size - (cur + len)); in btrfs_del_sys_chunk()
2966 array_size -= len; in btrfs_del_sys_chunk()
2973 mutex_unlock(&fs_info->chunk_mutex); in btrfs_del_sys_chunk()
2978 * btrfs_get_chunk_map() - Find the mapping containing the given logical extent.
2990 em_tree = &fs_info->mapping_tree; in btrfs_get_chunk_map()
2991 read_lock(&em_tree->lock); in btrfs_get_chunk_map()
2993 read_unlock(&em_tree->lock); in btrfs_get_chunk_map()
2997 "unable to find chunk map for logical %llu length %llu", in btrfs_get_chunk_map()
2999 return ERR_PTR(-EINVAL); in btrfs_get_chunk_map()
3002 if (em->start > logical || em->start + em->len <= logical) { in btrfs_get_chunk_map()
3004 "found a bad chunk map, wanted %llu-%llu, found %llu-%llu", in btrfs_get_chunk_map()
3005 logical, logical + length, em->start, em->start + em->len); in btrfs_get_chunk_map()
3007 return ERR_PTR(-EINVAL); in btrfs_get_chunk_map()
3016 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_remove_chunk()
3018 struct map_lookup *map; in btrfs_remove_chunk() local
3021 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_remove_chunk()
3033 map = em->map_lookup; in btrfs_remove_chunk()
3034 mutex_lock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3035 check_system_chunk(trans, map->type); in btrfs_remove_chunk()
3036 mutex_unlock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3041 * with map stripes (dev-replace.c:btrfs_dev_replace_finishing()). in btrfs_remove_chunk()
3043 mutex_lock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3044 for (i = 0; i < map->num_stripes; i++) { in btrfs_remove_chunk()
3045 struct btrfs_device *device = map->stripes[i].dev; in btrfs_remove_chunk()
3047 map->stripes[i].physical, in btrfs_remove_chunk()
3050 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3055 if (device->bytes_used > 0) { in btrfs_remove_chunk()
3056 mutex_lock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3058 device->bytes_used - dev_extent_len); in btrfs_remove_chunk()
3059 atomic64_add(dev_extent_len, &fs_info->free_chunk_space); in btrfs_remove_chunk()
3061 mutex_unlock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3066 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3071 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3079 trace_btrfs_chunk_free(fs_info, map, chunk_offset, em->len); in btrfs_remove_chunk()
3081 if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) { in btrfs_remove_chunk()
3103 struct btrfs_root *root = fs_info->chunk_root; in btrfs_relocate_chunk()
3117 * we release the path used to search the chunk/dev tree and before in btrfs_relocate_chunk()
3120 lockdep_assert_held(&fs_info->delete_unused_bgs_mutex); in btrfs_relocate_chunk()
3131 return -ENOENT; in btrfs_relocate_chunk()
3132 btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group); in btrfs_relocate_chunk()
3135 trans = btrfs_start_trans_remove_block_group(root->fs_info, in btrfs_relocate_chunk()
3139 btrfs_handle_fs_error(root->fs_info, ret, NULL); in btrfs_relocate_chunk()
3154 struct btrfs_root *chunk_root = fs_info->chunk_root; in btrfs_relocate_sys_chunks()
3155 struct btrfs_path *path; in btrfs_relocate_sys_chunks() local
3165 path = btrfs_alloc_path(); in btrfs_relocate_sys_chunks()
3166 if (!path) in btrfs_relocate_sys_chunks()
3167 return -ENOMEM; in btrfs_relocate_sys_chunks()
3171 key.offset = (u64)-1; in btrfs_relocate_sys_chunks()
3175 mutex_lock(&fs_info->delete_unused_bgs_mutex); in btrfs_relocate_sys_chunks()
3176 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0); in btrfs_relocate_sys_chunks()
3178 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_relocate_sys_chunks()
3183 ret = btrfs_previous_item(chunk_root, path, key.objectid, in btrfs_relocate_sys_chunks()
3186 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_relocate_sys_chunks()
3192 leaf = path->nodes[0]; in btrfs_relocate_sys_chunks()
3193 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_relocate_sys_chunks()
3195 chunk = btrfs_item_ptr(leaf, path->slots[0], in btrfs_relocate_sys_chunks()
3198 btrfs_release_path(path); in btrfs_relocate_sys_chunks()
3202 if (ret == -ENOSPC) in btrfs_relocate_sys_chunks()
3207 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_relocate_sys_chunks()
3211 key.offset = found_key.offset - 1; in btrfs_relocate_sys_chunks()
3219 ret = -ENOSPC; in btrfs_relocate_sys_chunks()
3222 btrfs_free_path(path); in btrfs_relocate_sys_chunks()
3240 chunk_type = cache->flags; in btrfs_may_alloc_data_chunk()
3246 spin_lock(&fs_info->data_sinfo->lock); in btrfs_may_alloc_data_chunk()
3247 bytes_used = fs_info->data_sinfo->bytes_used; in btrfs_may_alloc_data_chunk()
3248 spin_unlock(&fs_info->data_sinfo->lock); in btrfs_may_alloc_data_chunk()
3254 trans = btrfs_join_transaction(fs_info->tree_root); in btrfs_may_alloc_data_chunk()
3271 struct btrfs_root *root = fs_info->tree_root; in insert_balance_item()
3275 struct btrfs_path *path; in insert_balance_item() local
3280 path = btrfs_alloc_path(); in insert_balance_item()
3281 if (!path) in insert_balance_item()
3282 return -ENOMEM; in insert_balance_item()
3286 btrfs_free_path(path); in insert_balance_item()
3294 ret = btrfs_insert_empty_item(trans, root, path, &key, in insert_balance_item()
3299 leaf = path->nodes[0]; in insert_balance_item()
3300 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item); in insert_balance_item()
3304 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->data); in insert_balance_item()
3306 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->meta); in insert_balance_item()
3308 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->sys); in insert_balance_item()
3311 btrfs_set_balance_flags(leaf, item, bctl->flags); in insert_balance_item()
3315 btrfs_free_path(path); in insert_balance_item()
3324 struct btrfs_root *root = fs_info->tree_root; in del_balance_item()
3326 struct btrfs_path *path; in del_balance_item() local
3330 path = btrfs_alloc_path(); in del_balance_item()
3331 if (!path) in del_balance_item()
3332 return -ENOMEM; in del_balance_item()
3336 btrfs_free_path(path); in del_balance_item()
3344 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in del_balance_item()
3348 ret = -ENOENT; in del_balance_item()
3352 ret = btrfs_del_item(trans, root, path); in del_balance_item()
3354 btrfs_free_path(path); in del_balance_item()
3370 if (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3371 bctl->data.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3372 if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3373 bctl->sys.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3374 if (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3375 bctl->meta.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3381 * converted - that will keep us from relocating unconverted in update_balance_args()
3384 if (!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3385 !(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3386 !(bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3387 bctl->data.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3388 bctl->data.usage = 90; in update_balance_args()
3390 if (!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3391 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3392 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3393 bctl->sys.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3394 bctl->sys.usage = 90; in update_balance_args()
3396 if (!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3397 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3398 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3399 bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3400 bctl->meta.usage = 90; in update_balance_args()
3409 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in reset_balance_state()
3412 BUG_ON(!fs_info->balance_ctl); in reset_balance_state()
3414 spin_lock(&fs_info->balance_lock); in reset_balance_state()
3415 fs_info->balance_ctl = NULL; in reset_balance_state()
3416 spin_unlock(&fs_info->balance_lock); in reset_balance_state()
3434 if (bargs->profiles & chunk_type) in chunk_profiles_filter()
3450 chunk_used = cache->used; in chunk_usage_range_filter()
3452 if (bargs->usage_min == 0) in chunk_usage_range_filter()
3455 user_thresh_min = div_factor_fine(cache->length, in chunk_usage_range_filter()
3456 bargs->usage_min); in chunk_usage_range_filter()
3458 if (bargs->usage_max == 0) in chunk_usage_range_filter()
3460 else if (bargs->usage_max > 100) in chunk_usage_range_filter()
3461 user_thresh_max = cache->length; in chunk_usage_range_filter()
3463 user_thresh_max = div_factor_fine(cache->length, in chunk_usage_range_filter()
3464 bargs->usage_max); in chunk_usage_range_filter()
3481 chunk_used = cache->used; in chunk_usage_filter()
3483 if (bargs->usage_min == 0) in chunk_usage_filter()
3485 else if (bargs->usage > 100) in chunk_usage_filter()
3486 user_thresh = cache->length; in chunk_usage_filter()
3488 user_thresh = div_factor_fine(cache->length, bargs->usage); in chunk_usage_filter()
3507 if (btrfs_stripe_devid(leaf, stripe) == bargs->devid) in chunk_devid_filter()
3521 return num_stripes - nparity; in calc_data_stripes()
3539 if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID)) in chunk_drange_filter()
3547 if (btrfs_stripe_devid(leaf, stripe) != bargs->devid) in chunk_drange_filter()
3554 if (stripe_offset < bargs->pend && in chunk_drange_filter()
3555 stripe_offset + stripe_length > bargs->pstart) in chunk_drange_filter()
3568 if (chunk_offset < bargs->vend && in chunk_vrange_filter()
3569 chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart) in chunk_vrange_filter()
3582 if (bargs->stripes_min <= num_stripes in chunk_stripes_range_filter()
3583 && num_stripes <= bargs->stripes_max) in chunk_stripes_range_filter()
3592 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT)) in chunk_soft_convert_filter()
3598 if (bargs->target == chunk_type) in chunk_soft_convert_filter()
3607 struct btrfs_fs_info *fs_info = leaf->fs_info; in should_balance_chunk()
3608 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in should_balance_chunk()
3614 (bctl->flags & BTRFS_BALANCE_TYPE_MASK))) { in should_balance_chunk()
3619 bargs = &bctl->data; in should_balance_chunk()
3621 bargs = &bctl->sys; in should_balance_chunk()
3623 bargs = &bctl->meta; in should_balance_chunk()
3626 if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) && in should_balance_chunk()
3632 if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) && in should_balance_chunk()
3635 } else if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in should_balance_chunk()
3641 if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) && in should_balance_chunk()
3647 if ((bargs->flags & BTRFS_BALANCE_ARGS_DRANGE) && in should_balance_chunk()
3653 if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) && in should_balance_chunk()
3659 if ((bargs->flags & BTRFS_BALANCE_ARGS_STRIPES_RANGE) && in should_balance_chunk()
3665 if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) && in should_balance_chunk()
3673 if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT)) { in should_balance_chunk()
3674 if (bargs->limit == 0) in should_balance_chunk()
3677 bargs->limit--; in should_balance_chunk()
3678 } else if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT_RANGE)) { in should_balance_chunk()
3684 if (bargs->limit_max == 0) in should_balance_chunk()
3687 bargs->limit_max--; in should_balance_chunk()
3695 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in __btrfs_balance()
3696 struct btrfs_root *chunk_root = fs_info->chunk_root; in __btrfs_balance()
3699 struct btrfs_path *path = NULL; in __btrfs_balance() local
3708 u64 limit_data = bctl->data.limit; in __btrfs_balance()
3709 u64 limit_meta = bctl->meta.limit; in __btrfs_balance()
3710 u64 limit_sys = bctl->sys.limit; in __btrfs_balance()
3716 path = btrfs_alloc_path(); in __btrfs_balance()
3717 if (!path) { in __btrfs_balance()
3718 ret = -ENOMEM; in __btrfs_balance()
3723 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3724 memset(&bctl->stat, 0, sizeof(bctl->stat)); in __btrfs_balance()
3725 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3732 bctl->data.limit = limit_data; in __btrfs_balance()
3733 bctl->meta.limit = limit_meta; in __btrfs_balance()
3734 bctl->sys.limit = limit_sys; in __btrfs_balance()
3737 key.offset = (u64)-1; in __btrfs_balance()
3741 if ((!counting && atomic_read(&fs_info->balance_pause_req)) || in __btrfs_balance()
3742 atomic_read(&fs_info->balance_cancel_req)) { in __btrfs_balance()
3743 ret = -ECANCELED; in __btrfs_balance()
3747 mutex_lock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3748 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0); in __btrfs_balance()
3750 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3761 ret = btrfs_previous_item(chunk_root, path, 0, in __btrfs_balance()
3764 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3769 leaf = path->nodes[0]; in __btrfs_balance()
3770 slot = path->slots[0]; in __btrfs_balance()
3774 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3782 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3783 bctl->stat.considered++; in __btrfs_balance()
3784 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3789 btrfs_release_path(path); in __btrfs_balance()
3791 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3796 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3797 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3798 bctl->stat.expected++; in __btrfs_balance()
3799 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3816 count_data < bctl->data.limit_min) in __btrfs_balance()
3818 count_meta < bctl->meta.limit_min) in __btrfs_balance()
3820 count_sys < bctl->sys.limit_min)) { in __btrfs_balance()
3821 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3835 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3843 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3844 if (ret == -ENOSPC) { in __btrfs_balance()
3846 } else if (ret == -ETXTBSY) { in __btrfs_balance()
3854 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3855 bctl->stat.completed++; in __btrfs_balance()
3856 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3861 key.offset = found_key.offset - 1; in __btrfs_balance()
3865 btrfs_release_path(path); in __btrfs_balance()
3870 btrfs_free_path(path); in __btrfs_balance()
3875 ret = -ENOSPC; in __btrfs_balance()
3882 * alloc_profile_is_valid - see if a given profile is valid and reduced
3906 /* cancel requested || normal exit path */ in balance_need_close()
3907 return atomic_read(&fs_info->balance_cancel_req) || in balance_need_close()
3908 (atomic_read(&fs_info->balance_pause_req) == 0 && in balance_need_close()
3909 atomic_read(&fs_info->balance_cancel_req) == 0); in balance_need_close()
3920 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT)) in validate_convert_profile()
3924 if (alloc_profile_is_valid(bargs->target, 1) && in validate_convert_profile()
3925 (bargs->target & ~allowed) == 0) in validate_convert_profile()
3929 type, btrfs_bg_type_to_raid_name(bargs->target)); in validate_convert_profile()
3944 u64 flags = bargs->flags; in describe_balance_args()
3955 size_bp -= ret; \ in describe_balance_args()
3964 size_bp -= ret; \ in describe_balance_args()
3973 size_bp -= ret; \ in describe_balance_args()
3979 btrfs_bg_type_to_raid_name(bargs->target)); in describe_balance_args()
3985 btrfs_describe_block_groups(bargs->profiles, tmp_buf, in describe_balance_args()
3991 CHECK_APPEND_1ARG("usage=%llu,", bargs->usage); in describe_balance_args()
3995 bargs->usage_min, bargs->usage_max); in describe_balance_args()
3998 CHECK_APPEND_1ARG("devid=%llu,", bargs->devid); in describe_balance_args()
4002 bargs->pstart, bargs->pend); in describe_balance_args()
4006 bargs->vstart, bargs->vend); in describe_balance_args()
4009 CHECK_APPEND_1ARG("limit=%llu,", bargs->limit); in describe_balance_args()
4013 bargs->limit_min, bargs->limit_max); in describe_balance_args()
4017 bargs->stripes_min, bargs->stripes_max); in describe_balance_args()
4026 buf[size_buf - size_bp - 1] = '\0'; /* remove last , */ in describe_balance_args()
4039 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in describe_balance_start_or_resume()
4052 size_bp -= ret; \ in describe_balance_start_or_resume()
4056 if (bctl->flags & BTRFS_BALANCE_FORCE) in describe_balance_start_or_resume()
4057 CHECK_APPEND_1ARG("%s", "-f "); in describe_balance_start_or_resume()
4059 if (bctl->flags & BTRFS_BALANCE_DATA) { in describe_balance_start_or_resume()
4060 describe_balance_args(&bctl->data, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4061 CHECK_APPEND_1ARG("-d%s ", tmp_buf); in describe_balance_start_or_resume()
4064 if (bctl->flags & BTRFS_BALANCE_METADATA) { in describe_balance_start_or_resume()
4065 describe_balance_args(&bctl->meta, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4066 CHECK_APPEND_1ARG("-m%s ", tmp_buf); in describe_balance_start_or_resume()
4069 if (bctl->flags & BTRFS_BALANCE_SYSTEM) { in describe_balance_start_or_resume()
4070 describe_balance_args(&bctl->sys, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4071 CHECK_APPEND_1ARG("-s%s ", tmp_buf); in describe_balance_start_or_resume()
4079 buf[size_buf - size_bp - 1] = '\0'; /* remove last " " */ in describe_balance_start_or_resume()
4081 (bctl->flags & BTRFS_BALANCE_RESUME) ? in describe_balance_start_or_resume()
4104 atomic_read(&fs_info->balance_pause_req) || in btrfs_balance()
4106 ret = -EINVAL; in btrfs_balance()
4110 allowed = btrfs_super_incompat_flags(fs_info->super_copy); in btrfs_balance()
4119 if (mixed && (bctl->flags & allowed)) { in btrfs_balance()
4120 if (!(bctl->flags & BTRFS_BALANCE_DATA) || in btrfs_balance()
4121 !(bctl->flags & BTRFS_BALANCE_METADATA) || in btrfs_balance()
4122 memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) { in btrfs_balance()
4125 ret = -EINVAL; in btrfs_balance()
4134 num_devices = fs_info->fs_devices->rw_devices; in btrfs_balance()
4137 * SINGLE profile on-disk has no profile bit, but in-memory we have a in btrfs_balance()
4146 if (!validate_convert_profile(fs_info, &bctl->data, allowed, "data") || in btrfs_balance()
4147 !validate_convert_profile(fs_info, &bctl->meta, allowed, "metadata") || in btrfs_balance()
4148 !validate_convert_profile(fs_info, &bctl->sys, allowed, "system")) { in btrfs_balance()
4149 ret = -EINVAL; in btrfs_balance()
4164 seq = read_seqbegin(&fs_info->profiles_lock); in btrfs_balance()
4166 if (((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) && in btrfs_balance()
4167 (fs_info->avail_system_alloc_bits & allowed) && in btrfs_balance()
4168 !(bctl->sys.target & allowed)) || in btrfs_balance()
4169 ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) && in btrfs_balance()
4170 (fs_info->avail_metadata_alloc_bits & allowed) && in btrfs_balance()
4171 !(bctl->meta.target & allowed))) in btrfs_balance()
4177 meta_target = (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) ? in btrfs_balance()
4178 bctl->meta.target : fs_info->avail_metadata_alloc_bits; in btrfs_balance()
4179 data_target = (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) ? in btrfs_balance()
4180 bctl->data.target : fs_info->avail_data_alloc_bits; in btrfs_balance()
4181 } while (read_seqretry(&fs_info->profiles_lock, seq)); in btrfs_balance()
4184 if (bctl->flags & BTRFS_BALANCE_FORCE) { in btrfs_balance()
4189 "balance: reduces metadata redundancy, use --force if you want this"); in btrfs_balance()
4190 ret = -EINVAL; in btrfs_balance()
4203 if (fs_info->send_in_progress) { in btrfs_balance()
4206 fs_info->send_in_progress); in btrfs_balance()
4207 ret = -EAGAIN; in btrfs_balance()
4212 if (ret && ret != -EEXIST) in btrfs_balance()
4215 if (!(bctl->flags & BTRFS_BALANCE_RESUME)) { in btrfs_balance()
4216 BUG_ON(ret == -EEXIST); in btrfs_balance()
4217 BUG_ON(fs_info->balance_ctl); in btrfs_balance()
4218 spin_lock(&fs_info->balance_lock); in btrfs_balance()
4219 fs_info->balance_ctl = bctl; in btrfs_balance()
4220 spin_unlock(&fs_info->balance_lock); in btrfs_balance()
4222 BUG_ON(ret != -EEXIST); in btrfs_balance()
4223 spin_lock(&fs_info->balance_lock); in btrfs_balance()
4225 spin_unlock(&fs_info->balance_lock); in btrfs_balance()
4228 ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_balance()
4229 set_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags); in btrfs_balance()
4231 mutex_unlock(&fs_info->balance_mutex); in btrfs_balance()
4235 mutex_lock(&fs_info->balance_mutex); in btrfs_balance()
4236 if (ret == -ECANCELED && atomic_read(&fs_info->balance_pause_req)) in btrfs_balance()
4241 * - Regular cancel request in btrfs_balance()
4242 * Then ret == -ECANCELED and balance_cancel_req > 0 in btrfs_balance()
4244 * - Fatal signal to "btrfs" process in btrfs_balance()
4246 * got -EINTR, or caught by btrfs_should_cancel_balance() and in btrfs_balance()
4247 * got -ECANCELED. in btrfs_balance()
4249 * ret == -EINTR or ret == -ECANCELED. in btrfs_balance()
4253 else if (ret == -ECANCELED || ret == -EINTR) in btrfs_balance()
4258 clear_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags); in btrfs_balance()
4265 if ((ret && ret != -ECANCELED && ret != -ENOSPC) || in btrfs_balance()
4271 wake_up(&fs_info->balance_wait_q); in btrfs_balance()
4275 if (bctl->flags & BTRFS_BALANCE_RESUME) in btrfs_balance()
4289 sb_start_write(fs_info->sb); in balance_kthread()
4290 mutex_lock(&fs_info->balance_mutex); in balance_kthread()
4291 if (fs_info->balance_ctl) in balance_kthread()
4292 ret = btrfs_balance(fs_info, fs_info->balance_ctl, NULL); in balance_kthread()
4293 mutex_unlock(&fs_info->balance_mutex); in balance_kthread()
4294 sb_end_write(fs_info->sb); in balance_kthread()
4303 mutex_lock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4304 if (!fs_info->balance_ctl) { in btrfs_resume_balance_async()
4305 mutex_unlock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4308 mutex_unlock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4316 * A ro->rw remount sequence should continue with the paused balance in btrfs_resume_balance_async()
4320 spin_lock(&fs_info->balance_lock); in btrfs_resume_balance_async()
4321 fs_info->balance_ctl->flags |= BTRFS_BALANCE_RESUME; in btrfs_resume_balance_async()
4322 spin_unlock(&fs_info->balance_lock); in btrfs_resume_balance_async()
4324 tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance"); in btrfs_resume_balance_async()
4333 struct btrfs_path *path; in btrfs_recover_balance() local
4338 path = btrfs_alloc_path(); in btrfs_recover_balance()
4339 if (!path) in btrfs_recover_balance()
4340 return -ENOMEM; in btrfs_recover_balance()
4346 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); in btrfs_recover_balance()
4349 if (ret > 0) { /* ret = -ENOENT; */ in btrfs_recover_balance()
4356 ret = -ENOMEM; in btrfs_recover_balance()
4360 leaf = path->nodes[0]; in btrfs_recover_balance()
4361 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item); in btrfs_recover_balance()
4363 bctl->flags = btrfs_balance_flags(leaf, item); in btrfs_recover_balance()
4364 bctl->flags |= BTRFS_BALANCE_RESUME; in btrfs_recover_balance()
4367 btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs); in btrfs_recover_balance()
4369 btrfs_disk_balance_args_to_cpu(&bctl->meta, &disk_bargs); in btrfs_recover_balance()
4371 btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs); in btrfs_recover_balance()
4387 btrfs_release_path(path); in btrfs_recover_balance()
4389 mutex_lock(&fs_info->balance_mutex); in btrfs_recover_balance()
4390 BUG_ON(fs_info->balance_ctl); in btrfs_recover_balance()
4391 spin_lock(&fs_info->balance_lock); in btrfs_recover_balance()
4392 fs_info->balance_ctl = bctl; in btrfs_recover_balance()
4393 spin_unlock(&fs_info->balance_lock); in btrfs_recover_balance()
4394 mutex_unlock(&fs_info->balance_mutex); in btrfs_recover_balance()
4396 btrfs_free_path(path); in btrfs_recover_balance()
4404 mutex_lock(&fs_info->balance_mutex); in btrfs_pause_balance()
4405 if (!fs_info->balance_ctl) { in btrfs_pause_balance()
4406 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4407 return -ENOTCONN; in btrfs_pause_balance()
4410 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { in btrfs_pause_balance()
4411 atomic_inc(&fs_info->balance_pause_req); in btrfs_pause_balance()
4412 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4414 wait_event(fs_info->balance_wait_q, in btrfs_pause_balance()
4415 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_pause_balance()
4417 mutex_lock(&fs_info->balance_mutex); in btrfs_pause_balance()
4419 BUG_ON(test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_pause_balance()
4420 atomic_dec(&fs_info->balance_pause_req); in btrfs_pause_balance()
4422 ret = -ENOTCONN; in btrfs_pause_balance()
4425 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4431 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4432 if (!fs_info->balance_ctl) { in btrfs_cancel_balance()
4433 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4434 return -ENOTCONN; in btrfs_cancel_balance()
4439 * mount time if the mount is read-write. Otherwise it's still paused in btrfs_cancel_balance()
4442 if (sb_rdonly(fs_info->sb)) { in btrfs_cancel_balance()
4443 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4444 return -EROFS; in btrfs_cancel_balance()
4447 atomic_inc(&fs_info->balance_cancel_req); in btrfs_cancel_balance()
4452 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { in btrfs_cancel_balance()
4453 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4454 wait_event(fs_info->balance_wait_q, in btrfs_cancel_balance()
4455 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_cancel_balance()
4456 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4458 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4463 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4465 if (fs_info->balance_ctl) { in btrfs_cancel_balance()
4472 ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_cancel_balance()
4473 atomic_dec(&fs_info->balance_cancel_req); in btrfs_cancel_balance()
4474 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4481 struct btrfs_root *root = fs_info->tree_root; in btrfs_uuid_scan_kthread()
4483 struct btrfs_path *path = NULL; in btrfs_uuid_scan_kthread() local
4492 path = btrfs_alloc_path(); in btrfs_uuid_scan_kthread()
4493 if (!path) { in btrfs_uuid_scan_kthread()
4494 ret = -ENOMEM; in btrfs_uuid_scan_kthread()
4507 ret = btrfs_search_forward(root, &key, path, in btrfs_uuid_scan_kthread()
4521 eb = path->nodes[0]; in btrfs_uuid_scan_kthread()
4522 slot = path->slots[0]; in btrfs_uuid_scan_kthread()
4538 btrfs_release_path(path); in btrfs_uuid_scan_kthread()
4540 * 1 - subvol uuid item in btrfs_uuid_scan_kthread()
4541 * 1 - received_subvol uuid item in btrfs_uuid_scan_kthread()
4543 trans = btrfs_start_transaction(fs_info->uuid_root, 2); in btrfs_uuid_scan_kthread()
4553 btrfs_release_path(path); in btrfs_uuid_scan_kthread()
4578 btrfs_release_path(path); in btrfs_uuid_scan_kthread()
4586 if (key.offset < (u64)-1) { in btrfs_uuid_scan_kthread()
4591 } else if (key.objectid < (u64)-1) { in btrfs_uuid_scan_kthread()
4602 btrfs_free_path(path); in btrfs_uuid_scan_kthread()
4608 set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags); in btrfs_uuid_scan_kthread()
4609 up(&fs_info->uuid_tree_rescan_sem); in btrfs_uuid_scan_kthread()
4616 struct btrfs_root *tree_root = fs_info->tree_root; in btrfs_create_uuid_tree()
4622 * 1 - root node in btrfs_create_uuid_tree()
4623 * 1 - root item in btrfs_create_uuid_tree()
4637 fs_info->uuid_root = uuid_root; in btrfs_create_uuid_tree()
4643 down(&fs_info->uuid_tree_rescan_sem); in btrfs_create_uuid_tree()
4644 task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid"); in btrfs_create_uuid_tree()
4646 /* fs_info->update_uuid_tree_gen remains 0 in all error case */ in btrfs_create_uuid_tree()
4648 up(&fs_info->uuid_tree_rescan_sem); in btrfs_create_uuid_tree()
4662 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_shrink_device()
4663 struct btrfs_root *root = fs_info->dev_root; in btrfs_shrink_device()
4666 struct btrfs_path *path; in btrfs_shrink_device() local
4675 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_shrink_device()
4681 new_size = round_down(new_size, fs_info->sectorsize); in btrfs_shrink_device()
4683 diff = round_down(old_size - new_size, fs_info->sectorsize); in btrfs_shrink_device()
4685 if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) in btrfs_shrink_device()
4686 return -EINVAL; in btrfs_shrink_device()
4688 path = btrfs_alloc_path(); in btrfs_shrink_device()
4689 if (!path) in btrfs_shrink_device()
4690 return -ENOMEM; in btrfs_shrink_device()
4692 path->reada = READA_BACK; in btrfs_shrink_device()
4696 btrfs_free_path(path); in btrfs_shrink_device()
4700 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4703 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_shrink_device()
4704 device->fs_devices->total_rw_bytes -= diff; in btrfs_shrink_device()
4705 atomic64_sub(diff, &fs_info->free_chunk_space); in btrfs_shrink_device()
4710 * in-memory chunks are synced to disk so that the loop below sees them in btrfs_shrink_device()
4714 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4719 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4724 key.objectid = device->devid; in btrfs_shrink_device()
4725 key.offset = (u64)-1; in btrfs_shrink_device()
4729 mutex_lock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4730 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); in btrfs_shrink_device()
4732 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4736 ret = btrfs_previous_item(root, path, 0, key.type); in btrfs_shrink_device()
4738 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4743 btrfs_release_path(path); in btrfs_shrink_device()
4747 l = path->nodes[0]; in btrfs_shrink_device()
4748 slot = path->slots[0]; in btrfs_shrink_device()
4749 btrfs_item_key_to_cpu(l, &key, path->slots[0]); in btrfs_shrink_device()
4751 if (key.objectid != device->devid) { in btrfs_shrink_device()
4752 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4753 btrfs_release_path(path); in btrfs_shrink_device()
4761 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4762 btrfs_release_path(path); in btrfs_shrink_device()
4767 btrfs_release_path(path); in btrfs_shrink_device()
4777 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4782 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4783 if (ret == -ENOSPC) { in btrfs_shrink_device()
4786 if (ret == -ETXTBSY) { in btrfs_shrink_device()
4793 } while (key.offset-- > 0); in btrfs_shrink_device()
4800 ret = -ENOSPC; in btrfs_shrink_device()
4811 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4813 clear_extent_bits(&device->alloc_state, new_size, (u64)-1, in btrfs_shrink_device()
4817 if (list_empty(&device->post_commit_list)) in btrfs_shrink_device()
4818 list_add_tail(&device->post_commit_list, in btrfs_shrink_device()
4819 &trans->transaction->dev_update_list); in btrfs_shrink_device()
4823 round_down(old_total - diff, fs_info->sectorsize)); in btrfs_shrink_device()
4824 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4826 /* Now btrfs_update_device() will change the on-disk size. */ in btrfs_shrink_device()
4835 btrfs_free_path(path); in btrfs_shrink_device()
4837 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4839 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) in btrfs_shrink_device()
4840 device->fs_devices->total_rw_bytes += diff; in btrfs_shrink_device()
4841 atomic64_add(diff, &fs_info->free_chunk_space); in btrfs_shrink_device()
4842 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4851 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_add_system_chunk()
4856 mutex_lock(&fs_info->chunk_mutex); in btrfs_add_system_chunk()
4860 mutex_unlock(&fs_info->chunk_mutex); in btrfs_add_system_chunk()
4861 return -EFBIG; in btrfs_add_system_chunk()
4864 ptr = super_copy->sys_chunk_array + array_size; in btrfs_add_system_chunk()
4871 mutex_unlock(&fs_info->chunk_mutex); in btrfs_add_system_chunk()
4884 if (di_a->max_avail > di_b->max_avail) in btrfs_cmp_device_info()
4885 return -1; in btrfs_cmp_device_info()
4886 if (di_a->max_avail < di_b->max_avail) in btrfs_cmp_device_info()
4888 if (di_a->total_avail > di_b->total_avail) in btrfs_cmp_device_info()
4889 return -1; in btrfs_cmp_device_info()
4890 if (di_a->total_avail < di_b->total_avail) in btrfs_cmp_device_info()
4920 /* sub_stripes info for map */
4946 u64 type = ctl->type; in init_alloc_chunk_ctl_policy_regular()
4949 ctl->max_stripe_size = SZ_1G; in init_alloc_chunk_ctl_policy_regular()
4950 ctl->max_chunk_size = BTRFS_MAX_DATA_CHUNK_SIZE; in init_alloc_chunk_ctl_policy_regular()
4953 if (fs_devices->total_rw_bytes > 50ULL * SZ_1G) in init_alloc_chunk_ctl_policy_regular()
4954 ctl->max_stripe_size = SZ_1G; in init_alloc_chunk_ctl_policy_regular()
4956 ctl->max_stripe_size = SZ_256M; in init_alloc_chunk_ctl_policy_regular()
4957 ctl->max_chunk_size = ctl->max_stripe_size; in init_alloc_chunk_ctl_policy_regular()
4959 ctl->max_stripe_size = SZ_32M; in init_alloc_chunk_ctl_policy_regular()
4960 ctl->max_chunk_size = 2 * ctl->max_stripe_size; in init_alloc_chunk_ctl_policy_regular()
4961 ctl->devs_max = min_t(int, ctl->devs_max, in init_alloc_chunk_ctl_policy_regular()
4968 ctl->max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1), in init_alloc_chunk_ctl_policy_regular()
4969 ctl->max_chunk_size); in init_alloc_chunk_ctl_policy_regular()
4970 ctl->dev_extent_min = BTRFS_STRIPE_LEN * ctl->dev_stripes; in init_alloc_chunk_ctl_policy_regular()
4976 int index = btrfs_bg_flags_to_raid_index(ctl->type); in init_alloc_chunk_ctl()
4978 ctl->sub_stripes = btrfs_raid_array[index].sub_stripes; in init_alloc_chunk_ctl()
4979 ctl->dev_stripes = btrfs_raid_array[index].dev_stripes; in init_alloc_chunk_ctl()
4980 ctl->devs_max = btrfs_raid_array[index].devs_max; in init_alloc_chunk_ctl()
4981 if (!ctl->devs_max) in init_alloc_chunk_ctl()
4982 ctl->devs_max = BTRFS_MAX_DEVS(fs_devices->fs_info); in init_alloc_chunk_ctl()
4983 ctl->devs_min = btrfs_raid_array[index].devs_min; in init_alloc_chunk_ctl()
4984 ctl->devs_increment = btrfs_raid_array[index].devs_increment; in init_alloc_chunk_ctl()
4985 ctl->ncopies = btrfs_raid_array[index].ncopies; in init_alloc_chunk_ctl()
4986 ctl->nparity = btrfs_raid_array[index].nparity; in init_alloc_chunk_ctl()
4987 ctl->ndevs = 0; in init_alloc_chunk_ctl()
4989 switch (fs_devices->chunk_alloc_policy) { in init_alloc_chunk_ctl()
5002 struct btrfs_fs_info *info = fs_devices->fs_info; in gather_device_info()
5005 u64 dev_extent_want = ctl->max_stripe_size * ctl->dev_stripes; in gather_device_info()
5015 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) { in gather_device_info()
5016 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in gather_device_info()
5018 "BTRFS: read-only device in alloc_list\n"); in gather_device_info()
5023 &device->dev_state) || in gather_device_info()
5024 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) in gather_device_info()
5027 if (device->total_bytes > device->bytes_used) in gather_device_info()
5028 total_avail = device->total_bytes - device->bytes_used; in gather_device_info()
5033 if (total_avail < ctl->dev_extent_min) in gather_device_info()
5038 if (ret && ret != -ENOSPC) in gather_device_info()
5044 if (max_avail < ctl->dev_extent_min) { in gather_device_info()
5048 __func__, device->devid, max_avail, in gather_device_info()
5049 ctl->dev_extent_min); in gather_device_info()
5053 if (ndevs == fs_devices->rw_devices) { in gather_device_info()
5055 __func__, fs_devices->rw_devices); in gather_device_info()
5064 ctl->ndevs = ndevs; in gather_device_info()
5088 ctl->stripe_size = div_u64(devices_info[ctl->ndevs - 1].max_avail, in decide_stripe_size_regular()
5089 ctl->dev_stripes); in decide_stripe_size_regular()
5090 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; in decide_stripe_size_regular()
5093 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; in decide_stripe_size_regular()
5101 if (ctl->stripe_size * data_stripes > ctl->max_chunk_size) { in decide_stripe_size_regular()
5107 ctl->stripe_size = min(round_up(div_u64(ctl->max_chunk_size, in decide_stripe_size_regular()
5109 ctl->stripe_size); in decide_stripe_size_regular()
5113 ctl->stripe_size = round_down(ctl->stripe_size, BTRFS_STRIPE_LEN); in decide_stripe_size_regular()
5114 ctl->chunk_size = ctl->stripe_size * data_stripes; in decide_stripe_size_regular()
5123 struct btrfs_fs_info *info = fs_devices->fs_info; in decide_stripe_size()
5130 ctl->ndevs = rounddown(ctl->ndevs, ctl->devs_increment); in decide_stripe_size()
5132 if (ctl->ndevs < ctl->devs_min) { in decide_stripe_size()
5136 __func__, ctl->ndevs, ctl->devs_min); in decide_stripe_size()
5138 return -ENOSPC; in decide_stripe_size()
5141 ctl->ndevs = min(ctl->ndevs, ctl->devs_max); in decide_stripe_size()
5143 switch (fs_devices->chunk_alloc_policy) { in decide_stripe_size()
5155 struct btrfs_fs_info *info = trans->fs_info; in create_chunk()
5156 struct map_lookup *map = NULL; in create_chunk() local
5159 u64 start = ctl->start; in create_chunk()
5160 u64 type = ctl->type; in create_chunk()
5165 map = kmalloc(map_lookup_size(ctl->num_stripes), GFP_NOFS); in create_chunk()
5166 if (!map) in create_chunk()
5167 return -ENOMEM; in create_chunk()
5168 map->num_stripes = ctl->num_stripes; in create_chunk()
5170 for (i = 0; i < ctl->ndevs; ++i) { in create_chunk()
5171 for (j = 0; j < ctl->dev_stripes; ++j) { in create_chunk()
5172 int s = i * ctl->dev_stripes + j; in create_chunk()
5173 map->stripes[s].dev = devices_info[i].dev; in create_chunk()
5174 map->stripes[s].physical = devices_info[i].dev_offset + in create_chunk()
5175 j * ctl->stripe_size; in create_chunk()
5178 map->stripe_len = BTRFS_STRIPE_LEN; in create_chunk()
5179 map->io_align = BTRFS_STRIPE_LEN; in create_chunk()
5180 map->io_width = BTRFS_STRIPE_LEN; in create_chunk()
5181 map->type = type; in create_chunk()
5182 map->sub_stripes = ctl->sub_stripes; in create_chunk()
5184 trace_btrfs_chunk_alloc(info, map, start, ctl->chunk_size); in create_chunk()
5188 kfree(map); in create_chunk()
5189 return -ENOMEM; in create_chunk()
5191 set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); in create_chunk()
5192 em->map_lookup = map; in create_chunk()
5193 em->start = start; in create_chunk()
5194 em->len = ctl->chunk_size; in create_chunk()
5195 em->block_start = 0; in create_chunk()
5196 em->block_len = em->len; in create_chunk()
5197 em->orig_block_len = ctl->stripe_size; in create_chunk()
5199 em_tree = &info->mapping_tree; in create_chunk()
5200 write_lock(&em_tree->lock); in create_chunk()
5203 write_unlock(&em_tree->lock); in create_chunk()
5207 write_unlock(&em_tree->lock); in create_chunk()
5209 ret = btrfs_make_block_group(trans, 0, type, start, ctl->chunk_size); in create_chunk()
5213 for (i = 0; i < map->num_stripes; i++) { in create_chunk()
5214 struct btrfs_device *dev = map->stripes[i].dev; in create_chunk()
5217 dev->bytes_used + ctl->stripe_size); in create_chunk()
5218 if (list_empty(&dev->post_commit_list)) in create_chunk()
5219 list_add_tail(&dev->post_commit_list, in create_chunk()
5220 &trans->transaction->dev_update_list); in create_chunk()
5223 atomic64_sub(ctl->stripe_size * map->num_stripes, in create_chunk()
5224 &info->free_chunk_space); in create_chunk()
5233 write_lock(&em_tree->lock); in create_chunk()
5235 write_unlock(&em_tree->lock); in create_chunk()
5247 struct btrfs_fs_info *info = trans->fs_info; in btrfs_alloc_chunk()
5248 struct btrfs_fs_devices *fs_devices = info->fs_devices; in btrfs_alloc_chunk()
5253 lockdep_assert_held(&info->chunk_mutex); in btrfs_alloc_chunk()
5257 return -EINVAL; in btrfs_alloc_chunk()
5260 if (list_empty(&fs_devices->alloc_list)) { in btrfs_alloc_chunk()
5263 return -ENOSPC; in btrfs_alloc_chunk()
5269 return -EINVAL; in btrfs_alloc_chunk()
5276 devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info), in btrfs_alloc_chunk()
5279 return -ENOMEM; in btrfs_alloc_chunk()
5306 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_finish_chunk_alloc()
5307 struct btrfs_root *extent_root = fs_info->extent_root; in btrfs_finish_chunk_alloc()
5308 struct btrfs_root *chunk_root = fs_info->chunk_root; in btrfs_finish_chunk_alloc()
5314 struct map_lookup *map; in btrfs_finish_chunk_alloc() local
5325 map = em->map_lookup; in btrfs_finish_chunk_alloc()
5326 item_size = btrfs_chunk_item_size(map->num_stripes); in btrfs_finish_chunk_alloc()
5327 stripe_size = em->orig_block_len; in btrfs_finish_chunk_alloc()
5331 ret = -ENOMEM; in btrfs_finish_chunk_alloc()
5338 * with the map's stripes, because the device object's id can change in btrfs_finish_chunk_alloc()
5340 * (dev-replace.c:btrfs_dev_replace_finishing()). in btrfs_finish_chunk_alloc()
5342 mutex_lock(&fs_info->fs_devices->device_list_mutex); in btrfs_finish_chunk_alloc()
5343 for (i = 0; i < map->num_stripes; i++) { in btrfs_finish_chunk_alloc()
5344 device = map->stripes[i].dev; in btrfs_finish_chunk_alloc()
5345 dev_offset = map->stripes[i].physical; in btrfs_finish_chunk_alloc()
5356 mutex_unlock(&fs_info->fs_devices->device_list_mutex); in btrfs_finish_chunk_alloc()
5360 stripe = &chunk->stripe; in btrfs_finish_chunk_alloc()
5361 for (i = 0; i < map->num_stripes; i++) { in btrfs_finish_chunk_alloc()
5362 device = map->stripes[i].dev; in btrfs_finish_chunk_alloc()
5363 dev_offset = map->stripes[i].physical; in btrfs_finish_chunk_alloc()
5365 btrfs_set_stack_stripe_devid(stripe, device->devid); in btrfs_finish_chunk_alloc()
5367 memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE); in btrfs_finish_chunk_alloc()
5370 mutex_unlock(&fs_info->fs_devices->device_list_mutex); in btrfs_finish_chunk_alloc()
5373 btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid); in btrfs_finish_chunk_alloc()
5374 btrfs_set_stack_chunk_stripe_len(chunk, map->stripe_len); in btrfs_finish_chunk_alloc()
5375 btrfs_set_stack_chunk_type(chunk, map->type); in btrfs_finish_chunk_alloc()
5376 btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes); in btrfs_finish_chunk_alloc()
5377 btrfs_set_stack_chunk_io_align(chunk, map->stripe_len); in btrfs_finish_chunk_alloc()
5378 btrfs_set_stack_chunk_io_width(chunk, map->stripe_len); in btrfs_finish_chunk_alloc()
5379 btrfs_set_stack_chunk_sector_size(chunk, fs_info->sectorsize); in btrfs_finish_chunk_alloc()
5380 btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes); in btrfs_finish_chunk_alloc()
5387 if (ret == 0 && map->type & BTRFS_BLOCK_GROUP_SYSTEM) { in btrfs_finish_chunk_alloc()
5403 struct btrfs_fs_info *fs_info = trans->fs_info; in init_first_rw_device()
5417 static inline int btrfs_chunk_max_errors(struct map_lookup *map) in btrfs_chunk_max_errors() argument
5419 const int index = btrfs_bg_flags_to_raid_index(map->type); in btrfs_chunk_max_errors()
5427 struct map_lookup *map; in btrfs_chunk_readonly() local
5436 map = em->map_lookup; in btrfs_chunk_readonly()
5437 for (i = 0; i < map->num_stripes; i++) { in btrfs_chunk_readonly()
5439 &map->stripes[i].dev->dev_state)) { in btrfs_chunk_readonly()
5444 &map->stripes[i].dev->dev_state)) { in btrfs_chunk_readonly()
5455 if (miss_ndevs > btrfs_chunk_max_errors(map)) in btrfs_chunk_readonly()
5467 write_lock(&tree->lock); in btrfs_mapping_tree_free()
5468 em = lookup_extent_mapping(tree, 0, (u64)-1); in btrfs_mapping_tree_free()
5471 write_unlock(&tree->lock); in btrfs_mapping_tree_free()
5484 struct map_lookup *map; in btrfs_num_copies() local
5497 map = em->map_lookup; in btrfs_num_copies()
5498 if (map->type & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1_MASK)) in btrfs_num_copies()
5499 ret = map->num_stripes; in btrfs_num_copies()
5500 else if (map->type & BTRFS_BLOCK_GROUP_RAID10) in btrfs_num_copies()
5501 ret = map->sub_stripes; in btrfs_num_copies()
5502 else if (map->type & BTRFS_BLOCK_GROUP_RAID5) in btrfs_num_copies()
5504 else if (map->type & BTRFS_BLOCK_GROUP_RAID6) in btrfs_num_copies()
5512 ret = map->num_stripes; in btrfs_num_copies()
5517 down_read(&fs_info->dev_replace.rwsem); in btrfs_num_copies()
5518 if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace) && in btrfs_num_copies()
5519 fs_info->dev_replace.tgtdev) in btrfs_num_copies()
5521 up_read(&fs_info->dev_replace.rwsem); in btrfs_num_copies()
5530 struct map_lookup *map; in btrfs_full_stripe_len() local
5531 unsigned long len = fs_info->sectorsize; in btrfs_full_stripe_len()
5536 map = em->map_lookup; in btrfs_full_stripe_len()
5537 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) in btrfs_full_stripe_len()
5538 len = map->stripe_len * nr_data_stripes(map); in btrfs_full_stripe_len()
5547 struct map_lookup *map; in btrfs_is_parity_mirror() local
5553 map = em->map_lookup; in btrfs_is_parity_mirror()
5554 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) in btrfs_is_parity_mirror()
5562 struct map_lookup *map, int first, in find_live_mirror() argument
5571 ASSERT((map->type & in find_live_mirror()
5574 if (map->type & BTRFS_BLOCK_GROUP_RAID10) in find_live_mirror()
5575 num_stripes = map->sub_stripes; in find_live_mirror()
5577 num_stripes = map->num_stripes; in find_live_mirror()
5579 preferred_mirror = first + current->pid % num_stripes; in find_live_mirror()
5582 fs_info->dev_replace.cont_reading_from_srcdev_mode == in find_live_mirror()
5584 srcdev = fs_info->dev_replace.srcdev; in find_live_mirror()
5590 * dev-replace procedure, only choose it if no other non-missing in find_live_mirror()
5594 if (map->stripes[preferred_mirror].dev->bdev && in find_live_mirror()
5595 (tolerance || map->stripes[preferred_mirror].dev != srcdev)) in find_live_mirror()
5598 if (map->stripes[i].dev->bdev && in find_live_mirror()
5599 (tolerance || map->stripes[i].dev != srcdev)) in find_live_mirror()
5610 /* Bubble-sort the stripe set to put the parity/syndrome stripes last */
5618 for (i = 0; i < num_stripes - 1; i++) { in sort_parity_stripes()
5620 if (bbio->raid_map[i] > bbio->raid_map[i + 1]) { in sort_parity_stripes()
5621 swap(bbio->stripes[i], bbio->stripes[i + 1]); in sort_parity_stripes()
5622 swap(bbio->raid_map[i], bbio->raid_map[i + 1]); in sort_parity_stripes()
5645 atomic_set(&bbio->error, 0); in alloc_btrfs_bio()
5646 refcount_set(&bbio->refs, 1); in alloc_btrfs_bio()
5648 bbio->tgtdev_map = (int *)(bbio->stripes + total_stripes); in alloc_btrfs_bio()
5649 bbio->raid_map = (u64 *)(bbio->tgtdev_map + real_stripes); in alloc_btrfs_bio()
5656 WARN_ON(!refcount_read(&bbio->refs)); in btrfs_get_bbio()
5657 refcount_inc(&bbio->refs); in btrfs_get_bbio()
5664 if (refcount_dec_and_test(&bbio->refs)) in btrfs_put_bbio()
5678 struct map_lookup *map; in __btrfs_map_block_for_discard() local
5705 map = em->map_lookup; in __btrfs_map_block_for_discard()
5707 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in __btrfs_map_block_for_discard()
5708 ret = -EOPNOTSUPP; in __btrfs_map_block_for_discard()
5712 offset = logical - em->start; in __btrfs_map_block_for_discard()
5713 length = min_t(u64, em->start + em->len - logical, length); in __btrfs_map_block_for_discard()
5716 stripe_len = map->stripe_len; in __btrfs_map_block_for_discard()
5724 stripe_offset = offset - stripe_nr * stripe_len; in __btrfs_map_block_for_discard()
5726 stripe_nr_end = round_up(offset + length, map->stripe_len); in __btrfs_map_block_for_discard()
5727 stripe_nr_end = div64_u64(stripe_nr_end, map->stripe_len); in __btrfs_map_block_for_discard()
5728 stripe_cnt = stripe_nr_end - stripe_nr; in __btrfs_map_block_for_discard()
5729 stripe_end_offset = stripe_nr_end * map->stripe_len - in __btrfs_map_block_for_discard()
5738 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | in __btrfs_map_block_for_discard()
5740 if (map->type & BTRFS_BLOCK_GROUP_RAID0) in __btrfs_map_block_for_discard()
5743 sub_stripes = map->sub_stripes; in __btrfs_map_block_for_discard()
5745 factor = map->num_stripes / sub_stripes; in __btrfs_map_block_for_discard()
5746 num_stripes = min_t(u64, map->num_stripes, in __btrfs_map_block_for_discard()
5752 div_u64_rem(stripe_nr_end - 1, factor, &last_stripe); in __btrfs_map_block_for_discard()
5754 } else if (map->type & (BTRFS_BLOCK_GROUP_RAID1_MASK | in __btrfs_map_block_for_discard()
5756 num_stripes = map->num_stripes; in __btrfs_map_block_for_discard()
5758 stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, in __btrfs_map_block_for_discard()
5764 ret = -ENOMEM; in __btrfs_map_block_for_discard()
5769 bbio->stripes[i].physical = in __btrfs_map_block_for_discard()
5770 map->stripes[stripe_index].physical + in __btrfs_map_block_for_discard()
5771 stripe_offset + stripe_nr * map->stripe_len; in __btrfs_map_block_for_discard()
5772 bbio->stripes[i].dev = map->stripes[stripe_index].dev; in __btrfs_map_block_for_discard()
5774 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | in __btrfs_map_block_for_discard()
5776 bbio->stripes[i].length = stripes_per_dev * in __btrfs_map_block_for_discard()
5777 map->stripe_len; in __btrfs_map_block_for_discard()
5780 bbio->stripes[i].length += in __btrfs_map_block_for_discard()
5781 map->stripe_len; in __btrfs_map_block_for_discard()
5787 * |-------|...|-------| in __btrfs_map_block_for_discard()
5788 * |----------| in __btrfs_map_block_for_discard()
5792 bbio->stripes[i].length -= in __btrfs_map_block_for_discard()
5797 sub_stripes - 1)) in __btrfs_map_block_for_discard()
5798 bbio->stripes[i].length -= in __btrfs_map_block_for_discard()
5801 if (i == sub_stripes - 1) in __btrfs_map_block_for_discard()
5804 bbio->stripes[i].length = length; in __btrfs_map_block_for_discard()
5808 if (stripe_index == map->num_stripes) { in __btrfs_map_block_for_discard()
5815 bbio->map_type = map->type; in __btrfs_map_block_for_discard()
5816 bbio->num_stripes = num_stripes; in __btrfs_map_block_for_discard()
5823 * In dev-replace case, for repair case (that's the only case where the mirror
5832 * can happen because btrfs_num_copies() returns one more in the dev-replace
5855 num_stripes = bbio->num_stripes; in get_extra_mirror_from_replace()
5863 return -EIO; in get_extra_mirror_from_replace()
5872 if (bbio->stripes[i].dev->devid != srcdev_devid) in get_extra_mirror_from_replace()
5880 physical_of_found <= bbio->stripes[i].physical) in get_extra_mirror_from_replace()
5885 physical_of_found = bbio->stripes[i].physical; in get_extra_mirror_from_replace()
5892 return -EIO; in get_extra_mirror_from_replace()
5905 u64 srcdev_devid = dev_replace->srcdev->devid; in handle_ops_on_dev_replace()
5921 * Note that device->missing is handled by the caller, and that in handle_ops_on_dev_replace()
5927 if (bbio->stripes[i].dev->devid == srcdev_devid) { in handle_ops_on_dev_replace()
5930 bbio->stripes + index_where_to_add; in handle_ops_on_dev_replace()
5932 bbio->stripes + i; in handle_ops_on_dev_replace()
5934 new->physical = old->physical; in handle_ops_on_dev_replace()
5935 new->length = old->length; in handle_ops_on_dev_replace()
5936 new->dev = dev_replace->tgtdev; in handle_ops_on_dev_replace()
5937 bbio->tgtdev_map[i] = index_where_to_add; in handle_ops_on_dev_replace()
5950 * During the dev-replace procedure, the target drive can also in handle_ops_on_dev_replace()
5957 if (bbio->stripes[i].dev->devid == srcdev_devid) { in handle_ops_on_dev_replace()
5965 bbio->stripes[i].physical) in handle_ops_on_dev_replace()
5969 physical_of_found = bbio->stripes[i].physical; in handle_ops_on_dev_replace()
5974 bbio->stripes + num_stripes; in handle_ops_on_dev_replace()
5976 tgtdev_stripe->physical = physical_of_found; in handle_ops_on_dev_replace()
5977 tgtdev_stripe->length = in handle_ops_on_dev_replace()
5978 bbio->stripes[index_srcdev].length; in handle_ops_on_dev_replace()
5979 tgtdev_stripe->dev = dev_replace->tgtdev; in handle_ops_on_dev_replace()
5980 bbio->tgtdev_map[index_srcdev] = num_stripes; in handle_ops_on_dev_replace()
5989 bbio->num_tgtdevs = tgtdev_indexes; in handle_ops_on_dev_replace()
5999 * btrfs_get_io_geometry - calculates the geomery of a particular (address, len)
6003 * @fs_info - the filesystem
6004 * @logical - address that we want to figure out the geometry of
6005 * @len - the length of IO we are going to perform, starting at @logical
6006 * @op - type of operation - write or read
6007 * @io_geom - pointer used to return values
6016 struct map_lookup *map; in btrfs_get_io_geometry() local
6021 u64 raid56_full_stripe_start = (u64)-1; in btrfs_get_io_geometry()
6031 map = em->map_lookup; in btrfs_get_io_geometry()
6033 offset = logical - em->start; in btrfs_get_io_geometry()
6035 stripe_len = map->stripe_len; in btrfs_get_io_geometry()
6043 stripe_offset, offset, em->start, logical, stripe_len); in btrfs_get_io_geometry()
6044 ret = -EINVAL; in btrfs_get_io_geometry()
6049 stripe_offset = offset - stripe_offset; in btrfs_get_io_geometry()
6050 data_stripes = nr_data_stripes(map); in btrfs_get_io_geometry()
6052 if (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) { in btrfs_get_io_geometry()
6053 u64 max_len = stripe_len - stripe_offset; in btrfs_get_io_geometry()
6058 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in btrfs_get_io_geometry()
6076 max_len = stripe_len * data_stripes - in btrfs_get_io_geometry()
6077 (offset - raid56_full_stripe_start); in btrfs_get_io_geometry()
6080 len = min_t(u64, em->len - offset, max_len); in btrfs_get_io_geometry()
6082 len = em->len - offset; in btrfs_get_io_geometry()
6085 io_geom->len = len; in btrfs_get_io_geometry()
6086 io_geom->offset = offset; in btrfs_get_io_geometry()
6087 io_geom->stripe_len = stripe_len; in btrfs_get_io_geometry()
6088 io_geom->stripe_nr = stripe_nr; in btrfs_get_io_geometry()
6089 io_geom->stripe_offset = stripe_offset; in btrfs_get_io_geometry()
6090 io_geom->raid56_stripe_offset = raid56_full_stripe_start; in btrfs_get_io_geometry()
6105 struct map_lookup *map; in __btrfs_map_block() local
6117 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace; in __btrfs_map_block()
6122 u64 raid56_full_stripe_start = (u64)-1; in __btrfs_map_block()
6134 map = em->map_lookup; in __btrfs_map_block()
6141 data_stripes = nr_data_stripes(map); in __btrfs_map_block()
6143 down_read(&dev_replace->rwsem); in __btrfs_map_block()
6150 up_read(&dev_replace->rwsem); in __btrfs_map_block()
6152 if (dev_replace_is_ongoing && mirror_num == map->num_stripes + 1 && in __btrfs_map_block()
6153 !need_full_stripe(op) && dev_replace->tgtdev != NULL) { in __btrfs_map_block()
6155 dev_replace->srcdev->devid, in __btrfs_map_block()
6162 } else if (mirror_num > map->num_stripes) { in __btrfs_map_block()
6168 if (map->type & BTRFS_BLOCK_GROUP_RAID0) { in __btrfs_map_block()
6169 stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, in __btrfs_map_block()
6173 } else if (map->type & BTRFS_BLOCK_GROUP_RAID1_MASK) { in __btrfs_map_block()
6175 num_stripes = map->num_stripes; in __btrfs_map_block()
6177 stripe_index = mirror_num - 1; in __btrfs_map_block()
6179 stripe_index = find_live_mirror(fs_info, map, 0, in __btrfs_map_block()
6184 } else if (map->type & BTRFS_BLOCK_GROUP_DUP) { in __btrfs_map_block()
6186 num_stripes = map->num_stripes; in __btrfs_map_block()
6188 stripe_index = mirror_num - 1; in __btrfs_map_block()
6193 } else if (map->type & BTRFS_BLOCK_GROUP_RAID10) { in __btrfs_map_block()
6194 u32 factor = map->num_stripes / map->sub_stripes; in __btrfs_map_block()
6197 stripe_index *= map->sub_stripes; in __btrfs_map_block()
6200 num_stripes = map->sub_stripes; in __btrfs_map_block()
6202 stripe_index += mirror_num - 1; in __btrfs_map_block()
6205 stripe_index = find_live_mirror(fs_info, map, in __btrfs_map_block()
6208 mirror_num = stripe_index - old_stripe_index + 1; in __btrfs_map_block()
6211 } else if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in __btrfs_map_block()
6218 num_stripes = map->num_stripes; in __btrfs_map_block()
6219 max_errors = nr_parity_stripes(map); in __btrfs_map_block()
6221 *length = map->stripe_len; in __btrfs_map_block()
6233 stripe_index = data_stripes + mirror_num - 2; in __btrfs_map_block()
6236 div_u64_rem(stripe_nr + stripe_index, map->num_stripes, in __btrfs_map_block()
6247 stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, in __btrfs_map_block()
6251 if (stripe_index >= map->num_stripes) { in __btrfs_map_block()
6254 stripe_index, map->num_stripes); in __btrfs_map_block()
6255 ret = -EINVAL; in __btrfs_map_block()
6260 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL) { in __btrfs_map_block()
6270 ret = -ENOMEM; in __btrfs_map_block()
6275 bbio->stripes[i].physical = map->stripes[stripe_index].physical + in __btrfs_map_block()
6276 stripe_offset + stripe_nr * map->stripe_len; in __btrfs_map_block()
6277 bbio->stripes[i].dev = map->stripes[stripe_index].dev; in __btrfs_map_block()
6282 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK && need_raid_map && in __btrfs_map_block()
6287 /* Work out the disk rotation on this stripe-set */ in __btrfs_map_block()
6293 bbio->raid_map[(i+rot) % num_stripes] = in __btrfs_map_block()
6294 em->start + (tmp + i) * map->stripe_len; in __btrfs_map_block()
6296 bbio->raid_map[(i+rot) % map->num_stripes] = RAID5_P_STRIPE; in __btrfs_map_block()
6297 if (map->type & BTRFS_BLOCK_GROUP_RAID6) in __btrfs_map_block()
6298 bbio->raid_map[(i+rot+1) % num_stripes] = in __btrfs_map_block()
6305 max_errors = btrfs_chunk_max_errors(map); in __btrfs_map_block()
6307 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL && in __btrfs_map_block()
6314 bbio->map_type = map->type; in __btrfs_map_block()
6315 bbio->num_stripes = num_stripes; in __btrfs_map_block()
6316 bbio->max_errors = max_errors; in __btrfs_map_block()
6317 bbio->mirror_num = mirror_num; in __btrfs_map_block()
6326 bbio->stripes[0].dev = dev_replace->tgtdev; in __btrfs_map_block()
6327 bbio->stripes[0].physical = physical_to_patch_in_first_stripe; in __btrfs_map_block()
6328 bbio->mirror_num = map->num_stripes + 1; in __btrfs_map_block()
6332 lockdep_assert_held(&dev_replace->rwsem); in __btrfs_map_block()
6334 up_read(&dev_replace->rwsem); in __btrfs_map_block()
6362 bio->bi_private = bbio->private; in btrfs_end_bbio()
6363 bio->bi_end_io = bbio->end_io; in btrfs_end_bbio()
6371 struct btrfs_bio *bbio = bio->bi_private; in btrfs_end_bio()
6374 if (bio->bi_status) { in btrfs_end_bio()
6375 atomic_inc(&bbio->error); in btrfs_end_bio()
6376 if (bio->bi_status == BLK_STS_IOERR || in btrfs_end_bio()
6377 bio->bi_status == BLK_STS_TARGET) { in btrfs_end_bio()
6378 struct btrfs_device *dev = btrfs_io_bio(bio)->device; in btrfs_end_bio()
6380 ASSERT(dev->bdev); in btrfs_end_bio()
6384 else if (!(bio->bi_opf & REQ_RAHEAD)) in btrfs_end_bio()
6387 if (bio->bi_opf & REQ_PREFLUSH) in btrfs_end_bio()
6393 if (bio == bbio->orig_bio) in btrfs_end_bio()
6396 btrfs_bio_counter_dec(bbio->fs_info); in btrfs_end_bio()
6398 if (atomic_dec_and_test(&bbio->stripes_pending)) { in btrfs_end_bio()
6401 bio = bbio->orig_bio; in btrfs_end_bio()
6404 btrfs_io_bio(bio)->mirror_num = bbio->mirror_num; in btrfs_end_bio()
6408 if (atomic_read(&bbio->error) > bbio->max_errors) { in btrfs_end_bio()
6409 bio->bi_status = BLK_STS_IOERR; in btrfs_end_bio()
6415 bio->bi_status = BLK_STS_OK; in btrfs_end_bio()
6427 struct btrfs_fs_info *fs_info = bbio->fs_info; in submit_stripe_bio()
6429 bio->bi_private = bbio; in submit_stripe_bio()
6430 btrfs_io_bio(bio)->device = dev; in submit_stripe_bio()
6431 bio->bi_end_io = btrfs_end_bio; in submit_stripe_bio()
6432 bio->bi_iter.bi_sector = physical >> 9; in submit_stripe_bio()
6435 bio_op(bio), bio->bi_opf, (u64)bio->bi_iter.bi_sector, in submit_stripe_bio()
6436 (unsigned long)dev->bdev->bd_dev, rcu_str_deref(dev->name), in submit_stripe_bio()
6437 dev->devid, bio->bi_iter.bi_size); in submit_stripe_bio()
6438 bio_set_dev(bio, dev->bdev); in submit_stripe_bio()
6447 atomic_inc(&bbio->error); in bbio_error()
6448 if (atomic_dec_and_test(&bbio->stripes_pending)) { in bbio_error()
6450 WARN_ON(bio != bbio->orig_bio); in bbio_error()
6452 btrfs_io_bio(bio)->mirror_num = bbio->mirror_num; in bbio_error()
6453 bio->bi_iter.bi_sector = logical >> 9; in bbio_error()
6454 if (atomic_read(&bbio->error) > bbio->max_errors) in bbio_error()
6455 bio->bi_status = BLK_STS_IOERR; in bbio_error()
6457 bio->bi_status = BLK_STS_OK; in bbio_error()
6467 u64 logical = (u64)bio->bi_iter.bi_sector << 9; in btrfs_map_bio()
6475 length = bio->bi_iter.bi_size; in btrfs_map_bio()
6486 total_devs = bbio->num_stripes; in btrfs_map_bio()
6487 bbio->orig_bio = first_bio; in btrfs_map_bio()
6488 bbio->private = first_bio->bi_private; in btrfs_map_bio()
6489 bbio->end_io = first_bio->bi_end_io; in btrfs_map_bio()
6490 bbio->fs_info = fs_info; in btrfs_map_bio()
6491 atomic_set(&bbio->stripes_pending, bbio->num_stripes); in btrfs_map_bio()
6493 if ((bbio->map_type & BTRFS_BLOCK_GROUP_RAID56_MASK) && in btrfs_map_bio()
6517 dev = bbio->stripes[dev_nr].dev; in btrfs_map_bio()
6518 if (!dev || !dev->bdev || test_bit(BTRFS_DEV_STATE_MISSING, in btrfs_map_bio()
6519 &dev->dev_state) || in btrfs_map_bio()
6521 !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))) { in btrfs_map_bio()
6526 if (dev_nr < total_devs - 1) in btrfs_map_bio()
6531 submit_stripe_bio(bbio, bio, bbio->stripes[dev_nr].physical, dev); in btrfs_map_bio()
6553 if (!fsid || !memcmp(fs_devices->metadata_uuid, fsid, BTRFS_FSID_SIZE)) { in btrfs_find_device()
6554 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_find_device()
6555 if (device->devid == devid && in btrfs_find_device()
6556 (!uuid || memcmp(device->uuid, uuid, in btrfs_find_device()
6562 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_find_device()
6564 !memcmp(seed_devs->metadata_uuid, fsid, BTRFS_FSID_SIZE)) { in btrfs_find_device()
6565 list_for_each_entry(device, &seed_devs->devices, in btrfs_find_device()
6567 if (device->devid == devid && in btrfs_find_device()
6568 (!uuid || memcmp(device->uuid, uuid, in btrfs_find_device()
6596 list_add(&device->dev_list, &fs_devices->devices); in add_missing_dev()
6597 device->fs_devices = fs_devices; in add_missing_dev()
6598 fs_devices->num_devices++; in add_missing_dev()
6600 set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in add_missing_dev()
6601 fs_devices->missing_devices++; in add_missing_dev()
6607 * btrfs_alloc_device - allocate struct btrfs_device
6627 return ERR_PTR(-EINVAL); in btrfs_alloc_device()
6644 dev->devid = tmp; in btrfs_alloc_device()
6647 memcpy(dev->uuid, uuid, BTRFS_UUID_SIZE); in btrfs_alloc_device()
6649 generate_random_uuid(dev->uuid); in btrfs_alloc_device()
6673 data_stripes = num_stripes - nparity; in calc_stripe_length()
6683 struct btrfs_fs_info *fs_info = leaf->fs_info; in read_one_chunk()
6684 struct extent_map_tree *map_tree = &fs_info->mapping_tree; in read_one_chunk()
6685 struct map_lookup *map; in read_one_chunk() local
6695 logical = key->offset; in read_one_chunk()
6701 * as chunk item in tree block is already verified by tree-checker. in read_one_chunk()
6703 if (leaf->start == BTRFS_SUPER_INFO_OFFSET) { in read_one_chunk()
6709 read_lock(&map_tree->lock); in read_one_chunk()
6711 read_unlock(&map_tree->lock); in read_one_chunk()
6714 if (em && em->start <= logical && em->start + em->len > logical) { in read_one_chunk()
6723 return -ENOMEM; in read_one_chunk()
6724 map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS); in read_one_chunk()
6725 if (!map) { in read_one_chunk()
6727 return -ENOMEM; in read_one_chunk()
6730 set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); in read_one_chunk()
6731 em->map_lookup = map; in read_one_chunk()
6732 em->start = logical; in read_one_chunk()
6733 em->len = length; in read_one_chunk()
6734 em->orig_start = 0; in read_one_chunk()
6735 em->block_start = 0; in read_one_chunk()
6736 em->block_len = em->len; in read_one_chunk()
6738 map->num_stripes = num_stripes; in read_one_chunk()
6739 map->io_width = btrfs_chunk_io_width(leaf, chunk); in read_one_chunk()
6740 map->io_align = btrfs_chunk_io_align(leaf, chunk); in read_one_chunk()
6741 map->stripe_len = btrfs_chunk_stripe_len(leaf, chunk); in read_one_chunk()
6742 map->type = btrfs_chunk_type(leaf, chunk); in read_one_chunk()
6743 map->sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk); in read_one_chunk()
6744 map->verified_stripes = 0; in read_one_chunk()
6745 em->orig_block_len = calc_stripe_length(map->type, em->len, in read_one_chunk()
6746 map->num_stripes); in read_one_chunk()
6748 map->stripes[i].physical = in read_one_chunk()
6754 map->stripes[i].dev = btrfs_find_device(fs_info->fs_devices, in read_one_chunk()
6756 if (!map->stripes[i].dev && in read_one_chunk()
6760 return -ENOENT; in read_one_chunk()
6762 if (!map->stripes[i].dev) { in read_one_chunk()
6763 map->stripes[i].dev = in read_one_chunk()
6764 add_missing_dev(fs_info->fs_devices, devid, in read_one_chunk()
6766 if (IS_ERR(map->stripes[i].dev)) { in read_one_chunk()
6770 devid, PTR_ERR(map->stripes[i].dev)); in read_one_chunk()
6771 return PTR_ERR(map->stripes[i].dev); in read_one_chunk()
6776 &(map->stripes[i].dev->dev_state)); in read_one_chunk()
6780 write_lock(&map_tree->lock); in read_one_chunk()
6782 write_unlock(&map_tree->lock); in read_one_chunk()
6785 "failed to add chunk map, start=%llu len=%llu: %d", in read_one_chunk()
6786 em->start, em->len, ret); in read_one_chunk()
6799 device->devid = btrfs_device_id(leaf, dev_item); in fill_device_from_item()
6800 device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item); in fill_device_from_item()
6801 device->total_bytes = device->disk_total_bytes; in fill_device_from_item()
6802 device->commit_total_bytes = device->disk_total_bytes; in fill_device_from_item()
6803 device->bytes_used = btrfs_device_bytes_used(leaf, dev_item); in fill_device_from_item()
6804 device->commit_bytes_used = device->bytes_used; in fill_device_from_item()
6805 device->type = btrfs_device_type(leaf, dev_item); in fill_device_from_item()
6806 device->io_align = btrfs_device_io_align(leaf, dev_item); in fill_device_from_item()
6807 device->io_width = btrfs_device_io_width(leaf, dev_item); in fill_device_from_item()
6808 device->sector_size = btrfs_device_sector_size(leaf, dev_item); in fill_device_from_item()
6809 WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID); in fill_device_from_item()
6810 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in fill_device_from_item()
6813 read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); in fill_device_from_item()
6825 /* This will match only for multi-device seed fs */ in open_seed_devices()
6826 list_for_each_entry(fs_devices, &fs_info->fs_devices->seed_list, seed_list) in open_seed_devices()
6827 if (!memcmp(fs_devices->fsid, fsid, BTRFS_FSID_SIZE)) in open_seed_devices()
6834 return ERR_PTR(-ENOENT); in open_seed_devices()
6840 fs_devices->seeding = true; in open_seed_devices()
6841 fs_devices->opened = 1; in open_seed_devices()
6847 * respective fs_devices and anchor it at fs_info->fs_devices->seed_list in open_seed_devices()
6853 ret = open_fs_devices(fs_devices, FMODE_READ, fs_info->bdev_holder); in open_seed_devices()
6859 if (!fs_devices->seeding) { in open_seed_devices()
6862 return ERR_PTR(-EINVAL); in open_seed_devices()
6865 list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list); in open_seed_devices()
6873 struct btrfs_fs_info *fs_info = leaf->fs_info; in read_one_dev()
6874 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in read_one_dev()
6887 if (memcmp(fs_uuid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE)) { in read_one_dev()
6893 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid, in read_one_dev()
6899 return -ENOENT; in read_one_dev()
6911 if (!device->bdev) { in read_one_dev()
6915 return -ENOENT; in read_one_dev()
6921 if (!device->bdev && in read_one_dev()
6922 !test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in read_one_dev()
6926 * device->bdev is NULL, and so we have to set in read_one_dev()
6927 * device->missing to one here in read_one_dev()
6929 device->fs_devices->missing_devices++; in read_one_dev()
6930 set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in read_one_dev()
6934 if (device->fs_devices != fs_devices) { in read_one_dev()
6936 &device->dev_state)); in read_one_dev()
6938 list_move(&device->dev_list, &fs_devices->devices); in read_one_dev()
6939 device->fs_devices->num_devices--; in read_one_dev()
6940 fs_devices->num_devices++; in read_one_dev()
6942 device->fs_devices->missing_devices--; in read_one_dev()
6943 fs_devices->missing_devices++; in read_one_dev()
6945 device->fs_devices = fs_devices; in read_one_dev()
6949 if (device->fs_devices != fs_info->fs_devices) { in read_one_dev()
6950 BUG_ON(test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)); in read_one_dev()
6951 if (device->generation != in read_one_dev()
6953 return -EINVAL; in read_one_dev()
6957 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in read_one_dev()
6958 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in read_one_dev()
6959 !test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in read_one_dev()
6960 device->fs_devices->total_rw_bytes += device->total_bytes; in read_one_dev()
6961 atomic64_add(device->total_bytes - device->bytes_used, in read_one_dev()
6962 &fs_info->free_chunk_space); in read_one_dev()
6970 struct btrfs_root *root = fs_info->tree_root; in btrfs_read_sys_array()
6971 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_read_sys_array()
6985 ASSERT(BTRFS_SUPER_INFO_SIZE <= fs_info->nodesize); in btrfs_read_sys_array()
6989 * overallocate but we can keep it as-is, only the first page is used. in btrfs_read_sys_array()
6995 btrfs_set_buffer_lockdep_class(root->root_key.objectid, sb, 0); in btrfs_read_sys_array()
6999 * pages up-to-date when the page is larger: extent does not cover the in btrfs_read_sys_array()
7001 * the page's extents up-to-date (the hole beyond sb), in btrfs_read_sys_array()
7009 SetPageUptodate(sb->pages[0]); in btrfs_read_sys_array()
7014 array_ptr = super_copy->sys_chunk_array; in btrfs_read_sys_array()
7034 ret = -EIO; in btrfs_read_sys_array()
7052 ret = -EIO; in btrfs_read_sys_array()
7061 ret = -EIO; in btrfs_read_sys_array()
7086 return -EIO; in btrfs_read_sys_array()
7090 * Check if all chunks in the fs are OK for read-write degraded mount
7100 struct extent_map_tree *map_tree = &fs_info->mapping_tree; in btrfs_check_rw_degradable()
7105 read_lock(&map_tree->lock); in btrfs_check_rw_degradable()
7106 em = lookup_extent_mapping(map_tree, 0, (u64)-1); in btrfs_check_rw_degradable()
7107 read_unlock(&map_tree->lock); in btrfs_check_rw_degradable()
7114 struct map_lookup *map; in btrfs_check_rw_degradable() local
7119 map = em->map_lookup; in btrfs_check_rw_degradable()
7122 map->type); in btrfs_check_rw_degradable()
7123 for (i = 0; i < map->num_stripes; i++) { in btrfs_check_rw_degradable()
7124 struct btrfs_device *dev = map->stripes[i].dev; in btrfs_check_rw_degradable()
7126 if (!dev || !dev->bdev || in btrfs_check_rw_degradable()
7127 test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state) || in btrfs_check_rw_degradable()
7128 dev->last_flush_error) in btrfs_check_rw_degradable()
7137 em->start, missing, max_tolerated); in btrfs_check_rw_degradable()
7145 read_lock(&map_tree->lock); in btrfs_check_rw_degradable()
7147 (u64)(-1) - next_start); in btrfs_check_rw_degradable()
7148 read_unlock(&map_tree->lock); in btrfs_check_rw_degradable()
7163 readahead_tree_block(node->fs_info, start); in readahead_tree_node_children()
7169 struct btrfs_root *root = fs_info->chunk_root; in btrfs_read_chunk_tree()
7170 struct btrfs_path *path; in btrfs_read_chunk_tree() local
7179 path = btrfs_alloc_path(); in btrfs_read_chunk_tree()
7180 if (!path) in btrfs_read_chunk_tree()
7181 return -ENOMEM; in btrfs_read_chunk_tree()
7191 * we execute this code path, but open_fs_devices failed to clear in btrfs_read_chunk_tree()
7195 fs_info->fs_devices->total_rw_bytes = 0; in btrfs_read_chunk_tree()
7201 * item - BTRFS_FIRST_CHUNK_TREE_OBJECTID). in btrfs_read_chunk_tree()
7206 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); in btrfs_read_chunk_tree()
7212 leaf = path->nodes[0]; in btrfs_read_chunk_tree()
7213 slot = path->slots[0]; in btrfs_read_chunk_tree()
7215 ret = btrfs_next_leaf(root, path); in btrfs_read_chunk_tree()
7226 node = path->nodes[1]; in btrfs_read_chunk_tree()
7228 if (last_ra_node != node->start) { in btrfs_read_chunk_tree()
7230 last_ra_node = node->start; in btrfs_read_chunk_tree()
7245 mutex_lock(&fs_info->chunk_mutex); in btrfs_read_chunk_tree()
7247 mutex_unlock(&fs_info->chunk_mutex); in btrfs_read_chunk_tree()
7251 path->slots[0]++; in btrfs_read_chunk_tree()
7258 if (total_dev != fs_info->fs_devices->total_devices) { in btrfs_read_chunk_tree()
7261 btrfs_super_num_devices(fs_info->super_copy), in btrfs_read_chunk_tree()
7263 fs_info->fs_devices->total_devices = total_dev; in btrfs_read_chunk_tree()
7264 btrfs_set_super_num_devices(fs_info->super_copy, total_dev); in btrfs_read_chunk_tree()
7266 if (btrfs_super_total_bytes(fs_info->super_copy) < in btrfs_read_chunk_tree()
7267 fs_info->fs_devices->total_rw_bytes) { in btrfs_read_chunk_tree()
7270 btrfs_super_total_bytes(fs_info->super_copy), in btrfs_read_chunk_tree()
7271 fs_info->fs_devices->total_rw_bytes); in btrfs_read_chunk_tree()
7272 ret = -EINVAL; in btrfs_read_chunk_tree()
7279 btrfs_free_path(path); in btrfs_read_chunk_tree()
7285 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs; in btrfs_init_devices_late()
7288 fs_devices->fs_info = fs_info; in btrfs_init_devices_late()
7290 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_devices_late()
7291 list_for_each_entry(device, &fs_devices->devices, dev_list) in btrfs_init_devices_late()
7292 device->fs_info = fs_info; in btrfs_init_devices_late()
7294 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_init_devices_late()
7295 list_for_each_entry(device, &seed_devs->devices, dev_list) in btrfs_init_devices_late()
7296 device->fs_info = fs_info; in btrfs_init_devices_late()
7298 seed_devs->fs_info = fs_info; in btrfs_init_devices_late()
7300 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_devices_late()
7327 struct btrfs_path *path) in btrfs_device_init_dev_stats() argument
7337 key.offset = device->devid; in btrfs_device_init_dev_stats()
7338 ret = btrfs_search_slot(NULL, device->fs_info->dev_root, &key, path, 0, 0); in btrfs_device_init_dev_stats()
7342 device->dev_stats_valid = 1; in btrfs_device_init_dev_stats()
7343 btrfs_release_path(path); in btrfs_device_init_dev_stats()
7346 slot = path->slots[0]; in btrfs_device_init_dev_stats()
7347 eb = path->nodes[0]; in btrfs_device_init_dev_stats()
7360 device->dev_stats_valid = 1; in btrfs_device_init_dev_stats()
7362 btrfs_release_path(path); in btrfs_device_init_dev_stats()
7369 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs; in btrfs_init_dev_stats()
7371 struct btrfs_path *path = NULL; in btrfs_init_dev_stats() local
7374 path = btrfs_alloc_path(); in btrfs_init_dev_stats()
7375 if (!path) in btrfs_init_dev_stats()
7376 return -ENOMEM; in btrfs_init_dev_stats()
7378 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_dev_stats()
7379 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_init_dev_stats()
7380 ret = btrfs_device_init_dev_stats(device, path); in btrfs_init_dev_stats()
7384 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_init_dev_stats()
7385 list_for_each_entry(device, &seed_devs->devices, dev_list) { in btrfs_init_dev_stats()
7386 ret = btrfs_device_init_dev_stats(device, path); in btrfs_init_dev_stats()
7392 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_dev_stats()
7394 btrfs_free_path(path); in btrfs_init_dev_stats()
7401 struct btrfs_fs_info *fs_info = trans->fs_info; in update_dev_stat_item()
7402 struct btrfs_root *dev_root = fs_info->dev_root; in update_dev_stat_item()
7403 struct btrfs_path *path; in update_dev_stat_item() local
7412 key.offset = device->devid; in update_dev_stat_item()
7414 path = btrfs_alloc_path(); in update_dev_stat_item()
7415 if (!path) in update_dev_stat_item()
7416 return -ENOMEM; in update_dev_stat_item()
7417 ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1); in update_dev_stat_item()
7421 ret, rcu_str_deref(device->name)); in update_dev_stat_item()
7426 btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) { in update_dev_stat_item()
7428 ret = btrfs_del_item(trans, dev_root, path); in update_dev_stat_item()
7432 rcu_str_deref(device->name), ret); in update_dev_stat_item()
7440 btrfs_release_path(path); in update_dev_stat_item()
7441 ret = btrfs_insert_empty_item(trans, dev_root, path, in update_dev_stat_item()
7446 rcu_str_deref(device->name), ret); in update_dev_stat_item()
7451 eb = path->nodes[0]; in update_dev_stat_item()
7452 ptr = btrfs_item_ptr(eb, path->slots[0], struct btrfs_dev_stats_item); in update_dev_stat_item()
7459 btrfs_free_path(path); in update_dev_stat_item()
7468 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_run_dev_stats()
7469 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_run_dev_stats()
7474 mutex_lock(&fs_devices->device_list_mutex); in btrfs_run_dev_stats()
7475 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_run_dev_stats()
7476 stats_cnt = atomic_read(&device->dev_stats_ccnt); in btrfs_run_dev_stats()
7477 if (!device->dev_stats_valid || stats_cnt == 0) in btrfs_run_dev_stats()
7482 * There is a LOAD-LOAD control dependency between the value of in btrfs_run_dev_stats()
7483 * dev_stats_ccnt and updating the on-disk values which requires in btrfs_run_dev_stats()
7484 * reading the in-memory counters. Such control dependencies in btrfs_run_dev_stats()
7496 atomic_sub(stats_cnt, &device->dev_stats_ccnt); in btrfs_run_dev_stats()
7498 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_run_dev_stats()
7511 if (!dev->dev_stats_valid) in btrfs_dev_stat_print_on_error()
7513 btrfs_err_rl_in_rcu(dev->fs_info, in btrfs_dev_stat_print_on_error()
7515 rcu_str_deref(dev->name), in btrfs_dev_stat_print_on_error()
7533 btrfs_info_in_rcu(dev->fs_info, in btrfs_dev_stat_print_on_load()
7535 rcu_str_deref(dev->name), in btrfs_dev_stat_print_on_load()
7547 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_get_dev_stats()
7550 mutex_lock(&fs_devices->device_list_mutex); in btrfs_get_dev_stats()
7551 dev = btrfs_find_device(fs_info->fs_devices, stats->devid, NULL, NULL, in btrfs_get_dev_stats()
7553 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_get_dev_stats()
7557 return -ENODEV; in btrfs_get_dev_stats()
7558 } else if (!dev->dev_stats_valid) { in btrfs_get_dev_stats()
7560 return -ENODEV; in btrfs_get_dev_stats()
7561 } else if (stats->flags & BTRFS_DEV_STATS_RESET) { in btrfs_get_dev_stats()
7563 if (stats->nr_items > i) in btrfs_get_dev_stats()
7564 stats->values[i] = in btrfs_get_dev_stats()
7570 current->comm, task_pid_nr(current)); in btrfs_get_dev_stats()
7573 if (stats->nr_items > i) in btrfs_get_dev_stats()
7574 stats->values[i] = btrfs_dev_stat_read(dev, i); in btrfs_get_dev_stats()
7576 if (stats->nr_items > BTRFS_DEV_STAT_VALUES_MAX) in btrfs_get_dev_stats()
7577 stats->nr_items = BTRFS_DEV_STAT_VALUES_MAX; in btrfs_get_dev_stats()
7592 ASSERT(trans->state == TRANS_STATE_COMMIT_DOING); in btrfs_commit_device_sizes()
7594 if (list_empty(&trans->dev_update_list)) in btrfs_commit_device_sizes()
7602 mutex_lock(&trans->fs_info->chunk_mutex); in btrfs_commit_device_sizes()
7603 list_for_each_entry_safe(curr, next, &trans->dev_update_list, in btrfs_commit_device_sizes()
7605 list_del_init(&curr->post_commit_list); in btrfs_commit_device_sizes()
7606 curr->commit_total_bytes = curr->disk_total_bytes; in btrfs_commit_device_sizes()
7607 curr->commit_bytes_used = curr->bytes_used; in btrfs_commit_device_sizes()
7609 mutex_unlock(&trans->fs_info->chunk_mutex); in btrfs_commit_device_sizes()
7613 * Multiplicity factor for simple profiles: DUP, RAID1-like and RAID10.
7628 struct extent_map_tree *em_tree = &fs_info->mapping_tree; in verify_one_dev_extent()
7630 struct map_lookup *map; in verify_one_dev_extent() local
7637 read_lock(&em_tree->lock); in verify_one_dev_extent()
7639 read_unlock(&em_tree->lock); in verify_one_dev_extent()
7645 ret = -EUCLEAN; in verify_one_dev_extent()
7649 map = em->map_lookup; in verify_one_dev_extent()
7650 stripe_len = calc_stripe_length(map->type, em->len, map->num_stripes); in verify_one_dev_extent()
7654 physical_offset, devid, em->start, physical_len, in verify_one_dev_extent()
7656 ret = -EUCLEAN; in verify_one_dev_extent()
7660 for (i = 0; i < map->num_stripes; i++) { in verify_one_dev_extent()
7661 if (map->stripes[i].dev->devid == devid && in verify_one_dev_extent()
7662 map->stripes[i].physical == physical_offset) { in verify_one_dev_extent()
7664 if (map->verified_stripes >= map->num_stripes) { in verify_one_dev_extent()
7667 em->start); in verify_one_dev_extent()
7668 ret = -EUCLEAN; in verify_one_dev_extent()
7671 map->verified_stripes++; in verify_one_dev_extent()
7679 ret = -EUCLEAN; in verify_one_dev_extent()
7683 dev = btrfs_find_device(fs_info->fs_devices, devid, NULL, NULL, true); in verify_one_dev_extent()
7686 ret = -EUCLEAN; in verify_one_dev_extent()
7691 if (dev->disk_total_bytes == 0) { in verify_one_dev_extent()
7694 devs = list_first_entry(&fs_info->fs_devices->seed_list, in verify_one_dev_extent()
7700 ret = -EUCLEAN; in verify_one_dev_extent()
7705 if (physical_offset + physical_len > dev->disk_total_bytes) { in verify_one_dev_extent()
7709 dev->disk_total_bytes); in verify_one_dev_extent()
7710 ret = -EUCLEAN; in verify_one_dev_extent()
7720 struct extent_map_tree *em_tree = &fs_info->mapping_tree; in verify_chunk_dev_extent_mapping()
7725 read_lock(&em_tree->lock); in verify_chunk_dev_extent_mapping()
7726 for (node = rb_first_cached(&em_tree->map); node; node = rb_next(node)) { in verify_chunk_dev_extent_mapping()
7728 if (em->map_lookup->num_stripes != in verify_chunk_dev_extent_mapping()
7729 em->map_lookup->verified_stripes) { in verify_chunk_dev_extent_mapping()
7732 em->start, em->map_lookup->verified_stripes, in verify_chunk_dev_extent_mapping()
7733 em->map_lookup->num_stripes); in verify_chunk_dev_extent_mapping()
7734 ret = -EUCLEAN; in verify_chunk_dev_extent_mapping()
7739 read_unlock(&em_tree->lock); in verify_chunk_dev_extent_mapping()
7752 struct btrfs_path *path; in btrfs_verify_dev_extents() local
7753 struct btrfs_root *root = fs_info->dev_root; in btrfs_verify_dev_extents()
7763 path = btrfs_alloc_path(); in btrfs_verify_dev_extents()
7764 if (!path) in btrfs_verify_dev_extents()
7765 return -ENOMEM; in btrfs_verify_dev_extents()
7767 path->reada = READA_FORWARD; in btrfs_verify_dev_extents()
7768 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); in btrfs_verify_dev_extents()
7772 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) { in btrfs_verify_dev_extents()
7773 ret = btrfs_next_item(root, path); in btrfs_verify_dev_extents()
7778 ret = -EUCLEAN; in btrfs_verify_dev_extents()
7783 struct extent_buffer *leaf = path->nodes[0]; in btrfs_verify_dev_extents()
7785 int slot = path->slots[0]; in btrfs_verify_dev_extents()
7806 ret = -EUCLEAN; in btrfs_verify_dev_extents()
7817 ret = btrfs_next_item(root, path); in btrfs_verify_dev_extents()
7829 btrfs_free_path(path); in btrfs_verify_dev_extents()
7842 spin_lock(&fs_info->swapfile_pins_lock); in btrfs_pinned_by_swapfile()
7843 node = fs_info->swapfile_pins.rb_node; in btrfs_pinned_by_swapfile()
7846 if (ptr < sp->ptr) in btrfs_pinned_by_swapfile()
7847 node = node->rb_left; in btrfs_pinned_by_swapfile()
7848 else if (ptr > sp->ptr) in btrfs_pinned_by_swapfile()
7849 node = node->rb_right; in btrfs_pinned_by_swapfile()
7853 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_pinned_by_swapfile()