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()
384 WARN_ON(fs_devices->opened); in free_fs_devices()
385 while (!list_empty(&fs_devices->devices)) { in free_fs_devices()
386 device = list_entry(fs_devices->devices.next, in free_fs_devices()
388 list_del(&device->dev_list); in free_fs_devices()
401 list_del(&fs_devices->fs_list); in btrfs_cleanup_fs_uuids()
417 return ERR_PTR(-ENOMEM); in __alloc_device()
423 dev->flush_bio = bio_alloc_bioset(GFP_KERNEL, 0, NULL); in __alloc_device()
424 if (!dev->flush_bio) { in __alloc_device()
426 return ERR_PTR(-ENOMEM); in __alloc_device()
429 INIT_LIST_HEAD(&dev->dev_list); in __alloc_device()
430 INIT_LIST_HEAD(&dev->dev_alloc_list); in __alloc_device()
431 INIT_LIST_HEAD(&dev->post_commit_list); in __alloc_device()
433 atomic_set(&dev->reada_in_flight, 0); in __alloc_device()
434 atomic_set(&dev->dev_stats_ccnt, 0); in __alloc_device()
436 INIT_RADIX_TREE(&dev->reada_zones, GFP_NOFS & ~__GFP_DIRECT_RECLAIM); in __alloc_device()
437 INIT_RADIX_TREE(&dev->reada_extents, GFP_NOFS & ~__GFP_DIRECT_RECLAIM); in __alloc_device()
438 extent_io_tree_init(fs_info, &dev->alloc_state, in __alloc_device()
451 /* Handle non-split brain cases */ in find_fsid()
454 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0 in find_fsid()
455 && memcmp(metadata_fsid, fs_devices->metadata_uuid, in find_fsid()
459 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0) in find_fsid()
479 if (fs_devices->fsid_change && in find_fsid_with_metadata_uuid()
480 memcmp(disk_super->metadata_uuid, fs_devices->fsid, in find_fsid_with_metadata_uuid()
482 memcmp(fs_devices->fsid, fs_devices->metadata_uuid, in find_fsid_with_metadata_uuid()
494 if (fs_devices->fsid_change && in find_fsid_with_metadata_uuid()
495 memcmp(fs_devices->metadata_uuid, in find_fsid_with_metadata_uuid()
496 fs_devices->fsid, BTRFS_FSID_SIZE) != 0 && in find_fsid_with_metadata_uuid()
497 memcmp(disk_super->metadata_uuid, fs_devices->metadata_uuid, in find_fsid_with_metadata_uuid()
503 return find_fsid(disk_super->fsid, disk_super->metadata_uuid); in find_fsid_with_metadata_uuid()
522 filemap_write_and_wait((*bdev)->bd_inode->i_mapping); in btrfs_get_bdev_and_sb()
544 * Check if the device in the path matches the device in the given struct device.
550 static bool device_matched(const struct btrfs_device *device, const char *path) in device_matched() argument
560 if (!device->name) in device_matched()
568 scnprintf(device_name, BTRFS_PATH_NAME_MAX, "%s", rcu_str_deref(device->name)); in device_matched()
576 bdev_new = lookup_bdev(path); in device_matched()
589 * path: Optional. When provided will it release all unmounted devices
590 * matching this path only.
593 * Return: 0 for success or if @path is NULL.
594 * -EBUSY if @path is a mounted device.
595 * -ENOENT if @path does not match any device in the list.
597 static int btrfs_free_stale_devices(const char *path, in btrfs_free_stale_devices() argument
606 if (path) in btrfs_free_stale_devices()
607 ret = -ENOENT; in btrfs_free_stale_devices()
611 mutex_lock(&fs_devices->device_list_mutex); in btrfs_free_stale_devices()
613 &fs_devices->devices, dev_list) { in btrfs_free_stale_devices()
616 if (path && !device_matched(device, path)) in btrfs_free_stale_devices()
618 if (fs_devices->opened) { in btrfs_free_stale_devices()
620 if (path && ret != 0) in btrfs_free_stale_devices()
621 ret = -EBUSY; in btrfs_free_stale_devices()
626 fs_devices->num_devices--; in btrfs_free_stale_devices()
627 list_del(&device->dev_list); in btrfs_free_stale_devices()
632 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_free_stale_devices()
634 if (fs_devices->num_devices == 0) { in btrfs_free_stale_devices()
636 list_del(&fs_devices->fs_list); in btrfs_free_stale_devices()
647 * fs_devices->device_list_mutex here.
659 if (device->bdev) in btrfs_open_one_device()
660 return -EINVAL; in btrfs_open_one_device()
661 if (!device->name) in btrfs_open_one_device()
662 return -EINVAL; in btrfs_open_one_device()
664 ret = btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1, in btrfs_open_one_device()
669 devid = btrfs_stack_device_id(&disk_super->dev_item); in btrfs_open_one_device()
670 if (devid != device->devid) in btrfs_open_one_device()
673 if (memcmp(device->uuid, disk_super->dev_item.uuid, BTRFS_UUID_SIZE)) in btrfs_open_one_device()
676 device->generation = btrfs_super_generation(disk_super); in btrfs_open_one_device()
682 "BTRFS: Invalid seeding and uuid-changed device detected\n"); in btrfs_open_one_device()
686 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_open_one_device()
687 fs_devices->seeding = true; in btrfs_open_one_device()
690 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_open_one_device()
692 set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_open_one_device()
697 fs_devices->rotating = true; in btrfs_open_one_device()
699 device->bdev = bdev; in btrfs_open_one_device()
700 clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_open_one_device()
701 device->mode = flags; in btrfs_open_one_device()
703 fs_devices->open_devices++; in btrfs_open_one_device()
704 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_open_one_device()
705 device->devid != BTRFS_DEV_REPLACE_DEVID) { in btrfs_open_one_device()
706 fs_devices->rw_devices++; in btrfs_open_one_device()
707 list_add_tail(&device->dev_alloc_list, &fs_devices->alloc_list); in btrfs_open_one_device()
717 return -EINVAL; in btrfs_open_one_device()
732 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, in find_fsid_inprogress()
734 memcmp(fs_devices->metadata_uuid, disk_super->fsid, in find_fsid_inprogress()
735 BTRFS_FSID_SIZE) == 0 && !fs_devices->fsid_change) { in find_fsid_inprogress()
740 return find_fsid(disk_super->fsid, NULL); in find_fsid_inprogress()
754 * 1 - The fs still continues to have different METADATA/FSID uuids. in find_fsid_changed()
755 * 2 - The fs is switched back to its original FSID (METADATA/FSID in find_fsid_changed()
760 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, in find_fsid_changed()
762 memcmp(fs_devices->metadata_uuid, disk_super->metadata_uuid, in find_fsid_changed()
764 memcmp(fs_devices->fsid, disk_super->fsid, in find_fsid_changed()
769 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid, in find_fsid_changed()
771 memcmp(fs_devices->fsid, disk_super->metadata_uuid, in find_fsid_changed()
794 if (memcmp(fs_devices->fsid, fs_devices->metadata_uuid, in find_fsid_reverted_metadata()
796 memcmp(fs_devices->metadata_uuid, disk_super->fsid, in find_fsid_reverted_metadata()
798 fs_devices->fsid_change) in find_fsid_reverted_metadata()
811 static noinline struct btrfs_device *device_list_add(const char *path, in device_list_add() argument
819 u64 devid = btrfs_stack_device_id(&disk_super->dev_item); in device_list_add()
835 fs_devices = find_fsid(disk_super->fsid, NULL); in device_list_add()
841 fs_devices = alloc_fs_devices(disk_super->fsid, in device_list_add()
842 disk_super->metadata_uuid); in device_list_add()
844 fs_devices = alloc_fs_devices(disk_super->fsid, NULL); in device_list_add()
849 fs_devices->fsid_change = fsid_change_in_progress; in device_list_add()
851 mutex_lock(&fs_devices->device_list_mutex); in device_list_add()
852 list_add(&fs_devices->fs_list, &fs_uuids); in device_list_add()
856 mutex_lock(&fs_devices->device_list_mutex); in device_list_add()
858 disk_super->dev_item.uuid, NULL, false); in device_list_add()
865 if (fs_devices->fsid_change && in device_list_add()
866 found_transid > fs_devices->latest_generation) { in device_list_add()
867 memcpy(fs_devices->fsid, disk_super->fsid, in device_list_add()
871 memcpy(fs_devices->metadata_uuid, in device_list_add()
872 disk_super->metadata_uuid, in device_list_add()
875 memcpy(fs_devices->metadata_uuid, in device_list_add()
876 disk_super->fsid, BTRFS_FSID_SIZE); in device_list_add()
878 fs_devices->fsid_change = false; in device_list_add()
883 if (fs_devices->opened) { in device_list_add()
884 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
885 return ERR_PTR(-EBUSY); in device_list_add()
889 disk_super->dev_item.uuid); in device_list_add()
891 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
896 name = rcu_string_strdup(path, GFP_NOFS); in device_list_add()
899 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
900 return ERR_PTR(-ENOMEM); in device_list_add()
902 rcu_assign_pointer(device->name, name); in device_list_add()
904 list_add_rcu(&device->dev_list, &fs_devices->devices); in device_list_add()
905 fs_devices->num_devices++; in device_list_add()
907 device->fs_devices = fs_devices; in device_list_add()
910 if (disk_super->label[0]) in device_list_add()
913 disk_super->label, devid, found_transid, path, in device_list_add()
914 current->comm, task_pid_nr(current)); in device_list_add()
918 disk_super->fsid, devid, found_transid, path, in device_list_add()
919 current->comm, task_pid_nr(current)); in device_list_add()
921 } else if (!device->name || strcmp(device->name->str, path)) { in device_list_add()
924 * 1. If you are here and if the device->name is NULL that in device_list_add()
926 * 2. If you are here and if the device->name is different in device_list_add()
927 * from 'path' that means either in device_list_add()
930 * b. The missing-disk-which-was-replaced, has in device_list_add()
936 * Further in case of 1 and 2a above, the disk at 'path' in device_list_add()
948 if (!fs_devices->opened && found_transid < device->generation) { in device_list_add()
953 * with larger generation number or the last-in if in device_list_add()
956 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
957 return ERR_PTR(-EEXIST); in device_list_add()
961 * We are going to replace the device path for a given devid, in device_list_add()
964 if (device->bdev) { in device_list_add()
967 path_bdev = lookup_bdev(path); in device_list_add()
969 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
973 if (device->bdev != path_bdev) { in device_list_add()
975 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
977 * device->fs_info may not be reliable here, so in device_list_add()
979 * possible use-after-free when the fs_info and in device_list_add()
980 * fs_info->sb are already torn down. in device_list_add()
984 path, devid, found_transid, in device_list_add()
985 current->comm, in device_list_add()
987 return ERR_PTR(-EEXIST); in device_list_add()
990 btrfs_info_in_rcu(device->fs_info, in device_list_add()
991 "devid %llu device path %s changed to %s scanned by %s (%d)", in device_list_add()
992 devid, rcu_str_deref(device->name), in device_list_add()
993 path, current->comm, in device_list_add()
997 name = rcu_string_strdup(path, GFP_NOFS); in device_list_add()
999 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
1000 return ERR_PTR(-ENOMEM); in device_list_add()
1002 rcu_string_free(device->name); in device_list_add()
1003 rcu_assign_pointer(device->name, name); in device_list_add()
1004 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in device_list_add()
1005 fs_devices->missing_devices--; in device_list_add()
1006 clear_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in device_list_add()
1016 if (!fs_devices->opened) { in device_list_add()
1017 device->generation = found_transid; in device_list_add()
1018 fs_devices->latest_generation = max_t(u64, found_transid, in device_list_add()
1019 fs_devices->latest_generation); in device_list_add()
1022 fs_devices->total_devices = btrfs_super_num_devices(disk_super); in device_list_add()
1024 mutex_unlock(&fs_devices->device_list_mutex); in device_list_add()
1037 fs_devices = alloc_fs_devices(orig->fsid, NULL); in clone_fs_devices()
1041 fs_devices->total_devices = orig->total_devices; in clone_fs_devices()
1043 list_for_each_entry(orig_dev, &orig->devices, dev_list) { in clone_fs_devices()
1046 device = btrfs_alloc_device(NULL, &orig_dev->devid, in clone_fs_devices()
1047 orig_dev->uuid); in clone_fs_devices()
1057 if (orig_dev->name) { in clone_fs_devices()
1058 name = rcu_string_strdup(orig_dev->name->str, in clone_fs_devices()
1062 ret = -ENOMEM; in clone_fs_devices()
1065 rcu_assign_pointer(device->name, name); in clone_fs_devices()
1068 list_add(&device->dev_list, &fs_devices->devices); in clone_fs_devices()
1069 device->fs_devices = fs_devices; in clone_fs_devices()
1070 fs_devices->num_devices++; in clone_fs_devices()
1083 /* This is the initialized path, it is safe to release the devices. */ in __btrfs_free_extra_devids()
1084 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) { in __btrfs_free_extra_devids()
1085 if (test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state)) { in __btrfs_free_extra_devids()
1087 &device->dev_state) && in __btrfs_free_extra_devids()
1089 &device->dev_state) && in __btrfs_free_extra_devids()
1091 device->generation > (*latest_dev)->generation)) { in __btrfs_free_extra_devids()
1101 if (device->devid == BTRFS_DEV_REPLACE_DEVID) in __btrfs_free_extra_devids()
1104 if (device->bdev) { in __btrfs_free_extra_devids()
1105 blkdev_put(device->bdev, device->mode); in __btrfs_free_extra_devids()
1106 device->bdev = NULL; in __btrfs_free_extra_devids()
1107 fs_devices->open_devices--; in __btrfs_free_extra_devids()
1109 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in __btrfs_free_extra_devids()
1110 list_del_init(&device->dev_alloc_list); in __btrfs_free_extra_devids()
1111 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in __btrfs_free_extra_devids()
1112 fs_devices->rw_devices--; in __btrfs_free_extra_devids()
1114 list_del_init(&device->dev_list); in __btrfs_free_extra_devids()
1115 fs_devices->num_devices--; in __btrfs_free_extra_devids()
1133 list_for_each_entry(seed_dev, &fs_devices->seed_list, seed_list) in btrfs_free_extra_devids()
1136 fs_devices->latest_bdev = latest_dev->bdev; in btrfs_free_extra_devids()
1143 if (!device->bdev) in btrfs_close_bdev()
1146 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_close_bdev()
1147 sync_blockdev(device->bdev); in btrfs_close_bdev()
1148 invalidate_bdev(device->bdev); in btrfs_close_bdev()
1151 blkdev_put(device->bdev, device->mode); in btrfs_close_bdev()
1156 struct btrfs_fs_devices *fs_devices = device->fs_devices; in btrfs_close_one_device()
1158 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_close_one_device()
1159 device->devid != BTRFS_DEV_REPLACE_DEVID) { in btrfs_close_one_device()
1160 list_del_init(&device->dev_alloc_list); in btrfs_close_one_device()
1161 fs_devices->rw_devices--; in btrfs_close_one_device()
1164 if (device->devid == BTRFS_DEV_REPLACE_DEVID) in btrfs_close_one_device()
1165 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in btrfs_close_one_device()
1167 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in btrfs_close_one_device()
1168 clear_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in btrfs_close_one_device()
1169 fs_devices->missing_devices--; in btrfs_close_one_device()
1173 if (device->bdev) { in btrfs_close_one_device()
1174 fs_devices->open_devices--; in btrfs_close_one_device()
1175 device->bdev = NULL; in btrfs_close_one_device()
1177 clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_close_one_device()
1179 device->fs_info = NULL; in btrfs_close_one_device()
1180 atomic_set(&device->dev_stats_ccnt, 0); in btrfs_close_one_device()
1181 extent_io_tree_release(&device->alloc_state); in btrfs_close_one_device()
1189 * (btrfs_check_rw_degradable() should not fail) - if after mounting the in btrfs_close_one_device()
1194 device->last_flush_error = 0; in btrfs_close_one_device()
1197 ASSERT(!test_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state)); in btrfs_close_one_device()
1198 ASSERT(!test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)); in btrfs_close_one_device()
1199 ASSERT(list_empty(&device->dev_alloc_list)); in btrfs_close_one_device()
1200 ASSERT(list_empty(&device->post_commit_list)); in btrfs_close_one_device()
1201 ASSERT(atomic_read(&device->reada_in_flight) == 0); in btrfs_close_one_device()
1210 if (--fs_devices->opened > 0) in close_fs_devices()
1213 list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list) in close_fs_devices()
1216 WARN_ON(fs_devices->open_devices); in close_fs_devices()
1217 WARN_ON(fs_devices->rw_devices); in close_fs_devices()
1218 fs_devices->opened = 0; in close_fs_devices()
1219 fs_devices->seeding = false; in close_fs_devices()
1220 fs_devices->fs_info = NULL; in close_fs_devices()
1230 if (!fs_devices->opened) in btrfs_close_devices()
1231 list_splice_init(&fs_devices->seed_list, &list); in btrfs_close_devices()
1235 list_del(&fs_devices->seed_list); in btrfs_close_devices()
1250 list_for_each_entry_safe(device, tmp_device, &fs_devices->devices, in open_fs_devices()
1256 (!latest_dev || device->generation > latest_dev->generation)) { in open_fs_devices()
1258 } else if (ret == -ENODATA) { in open_fs_devices()
1259 fs_devices->num_devices--; in open_fs_devices()
1260 list_del(&device->dev_list); in open_fs_devices()
1264 if (fs_devices->open_devices == 0) in open_fs_devices()
1265 return -EINVAL; in open_fs_devices()
1267 fs_devices->opened = 1; in open_fs_devices()
1268 fs_devices->latest_bdev = latest_dev->bdev; in open_fs_devices()
1269 fs_devices->total_rw_bytes = 0; in open_fs_devices()
1270 fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_REGULAR; in open_fs_devices()
1282 if (dev1->devid < dev2->devid) in devid_cmp()
1283 return -1; in devid_cmp()
1284 else if (dev1->devid > dev2->devid) in devid_cmp()
1303 if (fs_devices->opened) { in btrfs_open_devices()
1304 fs_devices->opened++; in btrfs_open_devices()
1307 list_sort(NULL, &fs_devices->devices, devid_cmp); in btrfs_open_devices()
1330 if (bytenr + PAGE_SIZE >= i_size_read(bdev->bd_inode)) in btrfs_read_disk_super()
1331 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1335 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1339 if ((bytenr + sizeof(*disk_super) - 1) >> PAGE_SHIFT != index) in btrfs_read_disk_super()
1340 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1343 page = read_cache_page_gfp(bdev->bd_inode->i_mapping, index, GFP_KERNEL); in btrfs_read_disk_super()
1356 return ERR_PTR(-EINVAL); in btrfs_read_disk_super()
1359 if (disk_super->label[0] && disk_super->label[BTRFS_LABEL_SIZE - 1]) in btrfs_read_disk_super()
1360 disk_super->label[BTRFS_LABEL_SIZE - 1] = 0; in btrfs_read_disk_super()
1365 int btrfs_forget_devices(const char *path) in btrfs_forget_devices() argument
1370 ret = btrfs_free_stale_devices(strlen(path) ? path : NULL, NULL); in btrfs_forget_devices()
1377 * Look for a btrfs signature on a device. This may be called out of the mount path
1381 struct btrfs_device *btrfs_scan_one_device(const char *path, fmode_t flags, in btrfs_scan_one_device() argument
1401 bdev = blkdev_get_by_path(path, flags, holder); in btrfs_scan_one_device()
1411 device = device_list_add(path, disk_super, &new_device_added); in btrfs_scan_one_device()
1414 btrfs_free_stale_devices(path, device); in btrfs_scan_one_device()
1434 lockdep_assert_held(&device->fs_info->chunk_mutex); in contains_pending_extent()
1436 if (!find_first_extent_bit(&device->alloc_state, *start, in contains_pending_extent()
1442 physical_end - physical_start)) { in contains_pending_extent()
1452 switch (device->fs_devices->chunk_alloc_policy) { in dev_extent_search_start()
1466 * dev_extent_hole_check - check if specified hole is suitable for allocation
1487 *hole_size = hole_end - *hole_start; in dev_extent_hole_check()
1493 switch (device->fs_devices->chunk_alloc_policy) { in dev_extent_hole_check()
1505 * find_free_dev_extent_start - find free space in the specified device
1535 struct btrfs_fs_info *fs_info = device->fs_info; in find_free_dev_extent_start()
1536 struct btrfs_root *root = fs_info->dev_root; in find_free_dev_extent_start()
1539 struct btrfs_path *path; in find_free_dev_extent_start() local
1544 u64 search_end = device->total_bytes; in find_free_dev_extent_start()
1551 path = btrfs_alloc_path(); in find_free_dev_extent_start()
1552 if (!path) in find_free_dev_extent_start()
1553 return -ENOMEM; in find_free_dev_extent_start()
1560 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in find_free_dev_extent_start()
1561 ret = -ENOSPC; in find_free_dev_extent_start()
1565 path->reada = READA_FORWARD; in find_free_dev_extent_start()
1566 path->search_commit_root = 1; in find_free_dev_extent_start()
1567 path->skip_locking = 1; in find_free_dev_extent_start()
1569 key.objectid = device->devid; in find_free_dev_extent_start()
1573 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); in find_free_dev_extent_start()
1577 ret = btrfs_previous_item(root, path, key.objectid, key.type); in find_free_dev_extent_start()
1583 l = path->nodes[0]; in find_free_dev_extent_start()
1584 slot = path->slots[0]; in find_free_dev_extent_start()
1586 ret = btrfs_next_leaf(root, path); in find_free_dev_extent_start()
1596 if (key.objectid < device->devid) in find_free_dev_extent_start()
1599 if (key.objectid > device->devid) in find_free_dev_extent_start()
1606 hole_size = key.offset - search_start; in find_free_dev_extent_start()
1636 path->slots[0]++; in find_free_dev_extent_start()
1646 hole_size = search_end - search_start; in find_free_dev_extent_start()
1649 btrfs_release_path(path); in find_free_dev_extent_start()
1661 ret = -ENOSPC; in find_free_dev_extent_start()
1666 btrfs_free_path(path); in find_free_dev_extent_start()
1684 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_free_dev_extent()
1685 struct btrfs_root *root = fs_info->dev_root; in btrfs_free_dev_extent()
1687 struct btrfs_path *path; in btrfs_free_dev_extent() local
1693 path = btrfs_alloc_path(); in btrfs_free_dev_extent()
1694 if (!path) in btrfs_free_dev_extent()
1695 return -ENOMEM; in btrfs_free_dev_extent()
1697 key.objectid = device->devid; in btrfs_free_dev_extent()
1701 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_free_dev_extent()
1703 ret = btrfs_previous_item(root, path, key.objectid, in btrfs_free_dev_extent()
1707 leaf = path->nodes[0]; in btrfs_free_dev_extent()
1708 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_free_dev_extent()
1709 extent = btrfs_item_ptr(leaf, path->slots[0], in btrfs_free_dev_extent()
1714 btrfs_release_path(path); in btrfs_free_dev_extent()
1717 leaf = path->nodes[0]; in btrfs_free_dev_extent()
1718 extent = btrfs_item_ptr(leaf, path->slots[0], in btrfs_free_dev_extent()
1727 ret = btrfs_del_item(trans, root, path); in btrfs_free_dev_extent()
1732 set_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags); in btrfs_free_dev_extent()
1735 btrfs_free_path(path); in btrfs_free_dev_extent()
1744 struct btrfs_path *path; in btrfs_alloc_dev_extent() local
1745 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_alloc_dev_extent()
1746 struct btrfs_root *root = fs_info->dev_root; in btrfs_alloc_dev_extent()
1751 WARN_ON(!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state)); in btrfs_alloc_dev_extent()
1752 WARN_ON(test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)); in btrfs_alloc_dev_extent()
1753 path = btrfs_alloc_path(); in btrfs_alloc_dev_extent()
1754 if (!path) in btrfs_alloc_dev_extent()
1755 return -ENOMEM; in btrfs_alloc_dev_extent()
1757 key.objectid = device->devid; in btrfs_alloc_dev_extent()
1760 ret = btrfs_insert_empty_item(trans, root, path, &key, in btrfs_alloc_dev_extent()
1765 leaf = path->nodes[0]; in btrfs_alloc_dev_extent()
1766 extent = btrfs_item_ptr(leaf, path->slots[0], in btrfs_alloc_dev_extent()
1777 btrfs_free_path(path); in btrfs_alloc_dev_extent()
1788 em_tree = &fs_info->mapping_tree; in find_next_chunk()
1789 read_lock(&em_tree->lock); in find_next_chunk()
1790 n = rb_last(&em_tree->map.rb_root); in find_next_chunk()
1793 ret = em->start + em->len; in find_next_chunk()
1795 read_unlock(&em_tree->lock); in find_next_chunk()
1806 struct btrfs_path *path; in find_next_devid() local
1808 path = btrfs_alloc_path(); in find_next_devid()
1809 if (!path) in find_next_devid()
1810 return -ENOMEM; in find_next_devid()
1814 key.offset = (u64)-1; in find_next_devid()
1816 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0); in find_next_devid()
1822 btrfs_err(fs_info, "corrupted chunk tree devid -1 matched"); in find_next_devid()
1823 ret = -EUCLEAN; in find_next_devid()
1827 ret = btrfs_previous_item(fs_info->chunk_root, path, in find_next_devid()
1833 btrfs_item_key_to_cpu(path->nodes[0], &found_key, in find_next_devid()
1834 path->slots[0]); in find_next_devid()
1839 btrfs_free_path(path); in find_next_devid()
1851 struct btrfs_path *path; in btrfs_add_dev_item() local
1857 path = btrfs_alloc_path(); in btrfs_add_dev_item()
1858 if (!path) in btrfs_add_dev_item()
1859 return -ENOMEM; in btrfs_add_dev_item()
1863 key.offset = device->devid; in btrfs_add_dev_item()
1865 ret = btrfs_insert_empty_item(trans, trans->fs_info->chunk_root, path, in btrfs_add_dev_item()
1870 leaf = path->nodes[0]; in btrfs_add_dev_item()
1871 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); in btrfs_add_dev_item()
1873 btrfs_set_device_id(leaf, dev_item, device->devid); in btrfs_add_dev_item()
1875 btrfs_set_device_type(leaf, dev_item, device->type); in btrfs_add_dev_item()
1876 btrfs_set_device_io_align(leaf, dev_item, device->io_align); in btrfs_add_dev_item()
1877 btrfs_set_device_io_width(leaf, dev_item, device->io_width); in btrfs_add_dev_item()
1878 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size); in btrfs_add_dev_item()
1889 write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); in btrfs_add_dev_item()
1891 write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid, in btrfs_add_dev_item()
1897 btrfs_free_path(path); in btrfs_add_dev_item()
1902 * Function to update ctime/mtime for a given device path.
1909 struct path path; in update_dev_time() local
1913 ret = kern_path(device_path, LOOKUP_FOLLOW, &path); in update_dev_time()
1917 now = current_time(d_inode(path.dentry)); in update_dev_time()
1918 inode_update_time(d_inode(path.dentry), &now, S_MTIME | S_CTIME); in update_dev_time()
1919 path_put(&path); in update_dev_time()
1924 struct btrfs_root *root = device->fs_info->chunk_root; in btrfs_rm_dev_item()
1926 struct btrfs_path *path; in btrfs_rm_dev_item() local
1930 path = btrfs_alloc_path(); in btrfs_rm_dev_item()
1931 if (!path) in btrfs_rm_dev_item()
1932 return -ENOMEM; in btrfs_rm_dev_item()
1936 btrfs_free_path(path); in btrfs_rm_dev_item()
1941 key.offset = device->devid; in btrfs_rm_dev_item()
1943 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_rm_dev_item()
1946 ret = -ENOENT; in btrfs_rm_dev_item()
1952 ret = btrfs_del_item(trans, root, path); in btrfs_rm_dev_item()
1959 btrfs_free_path(path); in btrfs_rm_dev_item()
1978 seq = read_seqbegin(&fs_info->profiles_lock); in btrfs_check_raid_min_devices()
1980 all_avail = fs_info->avail_data_alloc_bits | in btrfs_check_raid_min_devices()
1981 fs_info->avail_system_alloc_bits | in btrfs_check_raid_min_devices()
1982 fs_info->avail_metadata_alloc_bits; in btrfs_check_raid_min_devices()
1983 } while (read_seqretry(&fs_info->profiles_lock, seq)); in btrfs_check_raid_min_devices()
2005 list_for_each_entry(next_device, &fs_devs->devices, dev_list) { in btrfs_find_next_active_device()
2007 !test_bit(BTRFS_DEV_STATE_MISSING, &next_device->dev_state) in btrfs_find_next_active_device()
2008 && next_device->bdev) in btrfs_find_next_active_device()
2024 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_assign_next_active_device()
2027 next_device = btrfs_find_next_active_device(fs_info->fs_devices, in btrfs_assign_next_active_device()
2031 if (fs_info->sb->s_bdev && in btrfs_assign_next_active_device()
2032 (fs_info->sb->s_bdev == device->bdev)) in btrfs_assign_next_active_device()
2033 fs_info->sb->s_bdev = next_device->bdev; in btrfs_assign_next_active_device()
2035 if (fs_info->fs_devices->latest_bdev == device->bdev) in btrfs_assign_next_active_device()
2036 fs_info->fs_devices->latest_bdev = next_device->bdev; in btrfs_assign_next_active_device()
2045 u64 num_devices = fs_info->fs_devices->num_devices; in btrfs_num_devices()
2047 down_read(&fs_info->dev_replace.rwsem); in btrfs_num_devices()
2048 if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) { in btrfs_num_devices()
2050 num_devices--; in btrfs_num_devices()
2052 up_read(&fs_info->dev_replace.rwsem); in btrfs_num_devices()
2075 memset(&disk_super->magic, 0, sizeof(disk_super->magic)); in btrfs_scratch_superblocks()
2093 /* Update ctime/mtime for device path for libblkid */ in btrfs_scratch_superblocks()
2102 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_rm_device()
2113 ret = btrfs_check_raid_min_devices(fs_info, num_devices - 1); in btrfs_rm_device()
2120 if (PTR_ERR(device) == -ENOENT && in btrfs_rm_device()
2131 rcu_str_deref(device->name), device->devid); in btrfs_rm_device()
2132 ret = -ETXTBSY; in btrfs_rm_device()
2136 if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in btrfs_rm_device()
2141 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in btrfs_rm_device()
2142 fs_info->fs_devices->rw_devices == 1) { in btrfs_rm_device()
2147 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_rm_device()
2148 mutex_lock(&fs_info->chunk_mutex); in btrfs_rm_device()
2149 list_del_init(&device->dev_alloc_list); in btrfs_rm_device()
2150 device->fs_devices->rw_devices--; in btrfs_rm_device()
2151 mutex_unlock(&fs_info->chunk_mutex); in btrfs_rm_device()
2169 clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_rm_device()
2185 * its own fs_devices listed under the fs_devices->seed. in btrfs_rm_device()
2187 cur_devices = device->fs_devices; in btrfs_rm_device()
2188 mutex_lock(&fs_devices->device_list_mutex); in btrfs_rm_device()
2189 list_del_rcu(&device->dev_list); in btrfs_rm_device()
2191 cur_devices->num_devices--; in btrfs_rm_device()
2192 cur_devices->total_devices--; in btrfs_rm_device()
2195 fs_devices->total_devices--; in btrfs_rm_device()
2197 if (test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) in btrfs_rm_device()
2198 cur_devices->missing_devices--; in btrfs_rm_device()
2202 if (device->bdev) { in btrfs_rm_device()
2203 cur_devices->open_devices--; in btrfs_rm_device()
2208 num_devices = btrfs_super_num_devices(fs_info->super_copy) - 1; in btrfs_rm_device()
2209 btrfs_set_super_num_devices(fs_info->super_copy, num_devices); in btrfs_rm_device()
2210 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_rm_device()
2217 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) in btrfs_rm_device()
2218 btrfs_scratch_superblocks(fs_info, device->bdev, in btrfs_rm_device()
2219 device->name->str); in btrfs_rm_device()
2225 if (cur_devices->open_devices == 0) { in btrfs_rm_device()
2226 list_del_init(&cur_devices->seed_list); in btrfs_rm_device()
2236 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_rm_device()
2237 mutex_lock(&fs_info->chunk_mutex); in btrfs_rm_device()
2238 list_add(&device->dev_alloc_list, in btrfs_rm_device()
2239 &fs_devices->alloc_list); in btrfs_rm_device()
2240 device->fs_devices->rw_devices++; in btrfs_rm_device()
2241 mutex_unlock(&fs_info->chunk_mutex); in btrfs_rm_device()
2250 lockdep_assert_held(&srcdev->fs_info->fs_devices->device_list_mutex); in btrfs_rm_dev_replace_remove_srcdev()
2253 * in case of fs with no seed, srcdev->fs_devices will point in btrfs_rm_dev_replace_remove_srcdev()
2258 fs_devices = srcdev->fs_devices; in btrfs_rm_dev_replace_remove_srcdev()
2260 list_del_rcu(&srcdev->dev_list); in btrfs_rm_dev_replace_remove_srcdev()
2261 list_del(&srcdev->dev_alloc_list); in btrfs_rm_dev_replace_remove_srcdev()
2262 fs_devices->num_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2263 if (test_bit(BTRFS_DEV_STATE_MISSING, &srcdev->dev_state)) in btrfs_rm_dev_replace_remove_srcdev()
2264 fs_devices->missing_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2266 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &srcdev->dev_state)) in btrfs_rm_dev_replace_remove_srcdev()
2267 fs_devices->rw_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2269 if (srcdev->bdev) in btrfs_rm_dev_replace_remove_srcdev()
2270 fs_devices->open_devices--; in btrfs_rm_dev_replace_remove_srcdev()
2275 struct btrfs_fs_devices *fs_devices = srcdev->fs_devices; in btrfs_rm_dev_replace_free_srcdev()
2284 if (!fs_devices->num_devices) { in btrfs_rm_dev_replace_free_srcdev()
2291 ASSERT(fs_devices->seeding); in btrfs_rm_dev_replace_free_srcdev()
2293 list_del_init(&fs_devices->seed_list); in btrfs_rm_dev_replace_free_srcdev()
2302 struct btrfs_fs_devices *fs_devices = tgtdev->fs_info->fs_devices; in btrfs_destroy_dev_replace_tgtdev()
2304 mutex_lock(&fs_devices->device_list_mutex); in btrfs_destroy_dev_replace_tgtdev()
2308 if (tgtdev->bdev) in btrfs_destroy_dev_replace_tgtdev()
2309 fs_devices->open_devices--; in btrfs_destroy_dev_replace_tgtdev()
2311 fs_devices->num_devices--; in btrfs_destroy_dev_replace_tgtdev()
2315 list_del_rcu(&tgtdev->dev_list); in btrfs_destroy_dev_replace_tgtdev()
2317 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_destroy_dev_replace_tgtdev()
2326 btrfs_scratch_superblocks(tgtdev->fs_info, tgtdev->bdev, in btrfs_destroy_dev_replace_tgtdev()
2327 tgtdev->name->str); in btrfs_destroy_dev_replace_tgtdev()
2345 fs_info->bdev_holder, 0, &bdev, &disk_super); in btrfs_find_device_by_path()
2349 devid = btrfs_stack_device_id(&disk_super->dev_item); in btrfs_find_device_by_path()
2350 dev_uuid = disk_super->dev_item.uuid; in btrfs_find_device_by_path()
2352 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid, in btrfs_find_device_by_path()
2353 disk_super->metadata_uuid, true); in btrfs_find_device_by_path()
2355 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid, in btrfs_find_device_by_path()
2356 disk_super->fsid, true); in btrfs_find_device_by_path()
2360 device = ERR_PTR(-ENOENT); in btrfs_find_device_by_path()
2366 * Lookup a device given by device id, or the path if the id is 0.
2375 device = btrfs_find_device(fs_info->fs_devices, devid, NULL, in btrfs_find_device_by_devspec()
2378 return ERR_PTR(-ENOENT); in btrfs_find_device_by_devspec()
2383 return ERR_PTR(-EINVAL); in btrfs_find_device_by_devspec()
2387 list_for_each_entry(device, &fs_info->fs_devices->devices, in btrfs_find_device_by_devspec()
2390 &device->dev_state) && !device->bdev) in btrfs_find_device_by_devspec()
2393 return ERR_PTR(-ENOENT); in btrfs_find_device_by_devspec()
2404 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_prepare_sprout()
2407 struct btrfs_super_block *disk_super = fs_info->super_copy; in btrfs_prepare_sprout()
2412 if (!fs_devices->seeding) in btrfs_prepare_sprout()
2413 return -EINVAL; in btrfs_prepare_sprout()
2417 * fs_info->fs_devices->seed_list in btrfs_prepare_sprout()
2435 list_add(&old_devices->fs_list, &fs_uuids); in btrfs_prepare_sprout()
2438 seed_devices->opened = 1; in btrfs_prepare_sprout()
2439 INIT_LIST_HEAD(&seed_devices->devices); in btrfs_prepare_sprout()
2440 INIT_LIST_HEAD(&seed_devices->alloc_list); in btrfs_prepare_sprout()
2441 mutex_init(&seed_devices->device_list_mutex); in btrfs_prepare_sprout()
2443 mutex_lock(&fs_devices->device_list_mutex); in btrfs_prepare_sprout()
2444 list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices, in btrfs_prepare_sprout()
2446 list_for_each_entry(device, &seed_devices->devices, dev_list) in btrfs_prepare_sprout()
2447 device->fs_devices = seed_devices; in btrfs_prepare_sprout()
2449 fs_devices->seeding = false; in btrfs_prepare_sprout()
2450 fs_devices->num_devices = 0; in btrfs_prepare_sprout()
2451 fs_devices->open_devices = 0; in btrfs_prepare_sprout()
2452 fs_devices->missing_devices = 0; in btrfs_prepare_sprout()
2453 fs_devices->rotating = false; in btrfs_prepare_sprout()
2454 list_add(&seed_devices->seed_list, &fs_devices->seed_list); in btrfs_prepare_sprout()
2456 generate_random_uuid(fs_devices->fsid); in btrfs_prepare_sprout()
2457 memcpy(fs_devices->metadata_uuid, fs_devices->fsid, BTRFS_FSID_SIZE); in btrfs_prepare_sprout()
2458 memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE); in btrfs_prepare_sprout()
2459 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_prepare_sprout()
2473 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_finish_sprout()
2474 struct btrfs_root *root = fs_info->chunk_root; in btrfs_finish_sprout()
2475 struct btrfs_path *path; in btrfs_finish_sprout() local
2485 path = btrfs_alloc_path(); in btrfs_finish_sprout()
2486 if (!path) in btrfs_finish_sprout()
2487 return -ENOMEM; in btrfs_finish_sprout()
2494 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); in btrfs_finish_sprout()
2498 leaf = path->nodes[0]; in btrfs_finish_sprout()
2500 if (path->slots[0] >= btrfs_header_nritems(leaf)) { in btrfs_finish_sprout()
2501 ret = btrfs_next_leaf(root, path); in btrfs_finish_sprout()
2506 leaf = path->nodes[0]; in btrfs_finish_sprout()
2507 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_finish_sprout()
2508 btrfs_release_path(path); in btrfs_finish_sprout()
2512 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in btrfs_finish_sprout()
2517 dev_item = btrfs_item_ptr(leaf, path->slots[0], in btrfs_finish_sprout()
2524 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid, in btrfs_finish_sprout()
2528 if (device->fs_devices->seeding) { in btrfs_finish_sprout()
2530 device->generation); in btrfs_finish_sprout()
2534 path->slots[0]++; in btrfs_finish_sprout()
2539 btrfs_free_path(path); in btrfs_finish_sprout()
2545 struct btrfs_root *root = fs_info->dev_root; in btrfs_init_new_device()
2550 struct super_block *sb = fs_info->sb; in btrfs_init_new_device()
2552 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_init_new_device()
2559 if (sb_rdonly(sb) && !fs_devices->seeding) in btrfs_init_new_device()
2560 return -EROFS; in btrfs_init_new_device()
2563 fs_info->bdev_holder); in btrfs_init_new_device()
2567 if (fs_devices->seeding) { in btrfs_init_new_device()
2569 down_write(&sb->s_umount); in btrfs_init_new_device()
2577 list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) { in btrfs_init_new_device()
2578 if (device->bdev == bdev) { in btrfs_init_new_device()
2579 ret = -EEXIST; in btrfs_init_new_device()
2595 ret = -ENOMEM; in btrfs_init_new_device()
2598 rcu_assign_pointer(device->name, name); in btrfs_init_new_device()
2607 set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); in btrfs_init_new_device()
2608 device->generation = trans->transid; in btrfs_init_new_device()
2609 device->io_width = fs_info->sectorsize; in btrfs_init_new_device()
2610 device->io_align = fs_info->sectorsize; in btrfs_init_new_device()
2611 device->sector_size = fs_info->sectorsize; in btrfs_init_new_device()
2612 device->total_bytes = round_down(i_size_read(bdev->bd_inode), in btrfs_init_new_device()
2613 fs_info->sectorsize); in btrfs_init_new_device()
2614 device->disk_total_bytes = device->total_bytes; in btrfs_init_new_device()
2615 device->commit_total_bytes = device->total_bytes; in btrfs_init_new_device()
2616 device->fs_info = fs_info; in btrfs_init_new_device()
2617 device->bdev = bdev; in btrfs_init_new_device()
2618 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in btrfs_init_new_device()
2619 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in btrfs_init_new_device()
2620 device->mode = FMODE_EXCL; in btrfs_init_new_device()
2621 device->dev_stats_valid = 1; in btrfs_init_new_device()
2622 set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE); in btrfs_init_new_device()
2625 sb->s_flags &= ~SB_RDONLY; in btrfs_init_new_device()
2633 device->fs_devices = fs_devices; in btrfs_init_new_device()
2635 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_new_device()
2636 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2637 list_add_rcu(&device->dev_list, &fs_devices->devices); in btrfs_init_new_device()
2638 list_add(&device->dev_alloc_list, &fs_devices->alloc_list); in btrfs_init_new_device()
2639 fs_devices->num_devices++; in btrfs_init_new_device()
2640 fs_devices->open_devices++; in btrfs_init_new_device()
2641 fs_devices->rw_devices++; in btrfs_init_new_device()
2642 fs_devices->total_devices++; in btrfs_init_new_device()
2643 fs_devices->total_rw_bytes += device->total_bytes; in btrfs_init_new_device()
2645 atomic64_add(device->total_bytes, &fs_info->free_chunk_space); in btrfs_init_new_device()
2648 fs_devices->rotating = true; in btrfs_init_new_device()
2650 orig_super_total_bytes = btrfs_super_total_bytes(fs_info->super_copy); in btrfs_init_new_device()
2651 btrfs_set_super_total_bytes(fs_info->super_copy, in btrfs_init_new_device()
2652 round_down(orig_super_total_bytes + device->total_bytes, in btrfs_init_new_device()
2653 fs_info->sectorsize)); in btrfs_init_new_device()
2655 orig_super_num_devices = btrfs_super_num_devices(fs_info->super_copy); in btrfs_init_new_device()
2656 btrfs_set_super_num_devices(fs_info->super_copy, in btrfs_init_new_device()
2665 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2670 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_new_device()
2673 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2675 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2706 up_write(&sb->s_umount); in btrfs_init_new_device()
2718 if (PTR_ERR(trans) == -ENOENT) in btrfs_init_new_device()
2731 * We can ignore the return value as it typically returns -EINVAL and in btrfs_init_new_device()
2743 mutex_lock(&fs_info->fs_devices->device_list_mutex); in btrfs_init_new_device()
2744 mutex_lock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2745 list_del_rcu(&device->dev_list); in btrfs_init_new_device()
2746 list_del(&device->dev_alloc_list); in btrfs_init_new_device()
2747 fs_info->fs_devices->num_devices--; in btrfs_init_new_device()
2748 fs_info->fs_devices->open_devices--; in btrfs_init_new_device()
2749 fs_info->fs_devices->rw_devices--; in btrfs_init_new_device()
2750 fs_info->fs_devices->total_devices--; in btrfs_init_new_device()
2751 fs_info->fs_devices->total_rw_bytes -= device->total_bytes; in btrfs_init_new_device()
2752 atomic64_sub(device->total_bytes, &fs_info->free_chunk_space); in btrfs_init_new_device()
2753 btrfs_set_super_total_bytes(fs_info->super_copy, in btrfs_init_new_device()
2755 btrfs_set_super_num_devices(fs_info->super_copy, in btrfs_init_new_device()
2757 mutex_unlock(&fs_info->chunk_mutex); in btrfs_init_new_device()
2758 mutex_unlock(&fs_info->fs_devices->device_list_mutex); in btrfs_init_new_device()
2761 sb->s_flags |= SB_RDONLY; in btrfs_init_new_device()
2770 up_write(&sb->s_umount); in btrfs_init_new_device()
2779 struct btrfs_path *path; in btrfs_update_device() local
2780 struct btrfs_root *root = device->fs_info->chunk_root; in btrfs_update_device()
2785 path = btrfs_alloc_path(); in btrfs_update_device()
2786 if (!path) in btrfs_update_device()
2787 return -ENOMEM; in btrfs_update_device()
2791 key.offset = device->devid; in btrfs_update_device()
2793 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); in btrfs_update_device()
2798 ret = -ENOENT; in btrfs_update_device()
2802 leaf = path->nodes[0]; in btrfs_update_device()
2803 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item); in btrfs_update_device()
2805 btrfs_set_device_id(leaf, dev_item, device->devid); in btrfs_update_device()
2806 btrfs_set_device_type(leaf, dev_item, device->type); in btrfs_update_device()
2807 btrfs_set_device_io_align(leaf, dev_item, device->io_align); in btrfs_update_device()
2808 btrfs_set_device_io_width(leaf, dev_item, device->io_width); in btrfs_update_device()
2809 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size); in btrfs_update_device()
2817 btrfs_free_path(path); in btrfs_update_device()
2824 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_grow_device()
2825 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_grow_device()
2829 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) in btrfs_grow_device()
2830 return -EACCES; in btrfs_grow_device()
2832 new_size = round_down(new_size, fs_info->sectorsize); in btrfs_grow_device()
2834 mutex_lock(&fs_info->chunk_mutex); in btrfs_grow_device()
2836 diff = round_down(new_size - device->total_bytes, fs_info->sectorsize); in btrfs_grow_device()
2838 if (new_size <= device->total_bytes || in btrfs_grow_device()
2839 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in btrfs_grow_device()
2840 mutex_unlock(&fs_info->chunk_mutex); in btrfs_grow_device()
2841 return -EINVAL; in btrfs_grow_device()
2845 round_down(old_total + diff, fs_info->sectorsize)); in btrfs_grow_device()
2846 device->fs_devices->total_rw_bytes += diff; in btrfs_grow_device()
2850 btrfs_clear_space_info_full(device->fs_info); in btrfs_grow_device()
2851 if (list_empty(&device->post_commit_list)) in btrfs_grow_device()
2852 list_add_tail(&device->post_commit_list, in btrfs_grow_device()
2853 &trans->transaction->dev_update_list); in btrfs_grow_device()
2854 mutex_unlock(&fs_info->chunk_mutex); in btrfs_grow_device()
2861 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_free_chunk()
2862 struct btrfs_root *root = fs_info->chunk_root; in btrfs_free_chunk()
2864 struct btrfs_path *path; in btrfs_free_chunk() local
2867 path = btrfs_alloc_path(); in btrfs_free_chunk()
2868 if (!path) in btrfs_free_chunk()
2869 return -ENOMEM; in btrfs_free_chunk()
2875 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in btrfs_free_chunk()
2879 btrfs_handle_fs_error(fs_info, -ENOENT, in btrfs_free_chunk()
2881 ret = -ENOENT; in btrfs_free_chunk()
2885 ret = btrfs_del_item(trans, root, path); in btrfs_free_chunk()
2890 btrfs_free_path(path); in btrfs_free_chunk()
2896 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_del_sys_chunk()
2907 mutex_lock(&fs_info->chunk_mutex); in btrfs_del_sys_chunk()
2910 ptr = super_copy->sys_chunk_array; in btrfs_del_sys_chunk()
2924 ret = -EIO; in btrfs_del_sys_chunk()
2929 memmove(ptr, ptr + len, array_size - (cur + len)); in btrfs_del_sys_chunk()
2930 array_size -= len; in btrfs_del_sys_chunk()
2937 mutex_unlock(&fs_info->chunk_mutex); in btrfs_del_sys_chunk()
2942 * btrfs_get_chunk_map() - Find the mapping containing the given logical extent.
2954 em_tree = &fs_info->mapping_tree; in btrfs_get_chunk_map()
2955 read_lock(&em_tree->lock); in btrfs_get_chunk_map()
2957 read_unlock(&em_tree->lock); in btrfs_get_chunk_map()
2962 return ERR_PTR(-EINVAL); in btrfs_get_chunk_map()
2965 if (em->start > logical || em->start + em->len < logical) { in btrfs_get_chunk_map()
2967 "found a bad mapping, wanted %llu-%llu, found %llu-%llu", in btrfs_get_chunk_map()
2968 logical, length, em->start, em->start + em->len); in btrfs_get_chunk_map()
2970 return ERR_PTR(-EINVAL); in btrfs_get_chunk_map()
2979 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_remove_chunk()
2981 struct map_lookup *map; in btrfs_remove_chunk() local
2984 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_remove_chunk()
2996 map = em->map_lookup; in btrfs_remove_chunk()
2997 mutex_lock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
2998 check_system_chunk(trans, map->type); in btrfs_remove_chunk()
2999 mutex_unlock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3004 * with map stripes (dev-replace.c:btrfs_dev_replace_finishing()). in btrfs_remove_chunk()
3006 mutex_lock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3007 for (i = 0; i < map->num_stripes; i++) { in btrfs_remove_chunk()
3008 struct btrfs_device *device = map->stripes[i].dev; in btrfs_remove_chunk()
3010 map->stripes[i].physical, in btrfs_remove_chunk()
3013 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3018 if (device->bytes_used > 0) { in btrfs_remove_chunk()
3019 mutex_lock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3021 device->bytes_used - dev_extent_len); in btrfs_remove_chunk()
3022 atomic64_add(dev_extent_len, &fs_info->free_chunk_space); in btrfs_remove_chunk()
3024 mutex_unlock(&fs_info->chunk_mutex); in btrfs_remove_chunk()
3029 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3034 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_remove_chunk()
3042 trace_btrfs_chunk_free(fs_info, map, chunk_offset, em->len); in btrfs_remove_chunk()
3044 if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) { in btrfs_remove_chunk()
3066 struct btrfs_root *root = fs_info->chunk_root; in btrfs_relocate_chunk()
3080 * we release the path used to search the chunk/dev tree and before in btrfs_relocate_chunk()
3083 lockdep_assert_held(&fs_info->delete_unused_bgs_mutex); in btrfs_relocate_chunk()
3094 return -ENOENT; in btrfs_relocate_chunk()
3095 btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group); in btrfs_relocate_chunk()
3098 trans = btrfs_start_trans_remove_block_group(root->fs_info, in btrfs_relocate_chunk()
3102 btrfs_handle_fs_error(root->fs_info, ret, NULL); in btrfs_relocate_chunk()
3117 struct btrfs_root *chunk_root = fs_info->chunk_root; in btrfs_relocate_sys_chunks()
3118 struct btrfs_path *path; in btrfs_relocate_sys_chunks() local
3128 path = btrfs_alloc_path(); in btrfs_relocate_sys_chunks()
3129 if (!path) in btrfs_relocate_sys_chunks()
3130 return -ENOMEM; in btrfs_relocate_sys_chunks()
3134 key.offset = (u64)-1; in btrfs_relocate_sys_chunks()
3138 mutex_lock(&fs_info->delete_unused_bgs_mutex); in btrfs_relocate_sys_chunks()
3139 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0); in btrfs_relocate_sys_chunks()
3141 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_relocate_sys_chunks()
3146 ret = btrfs_previous_item(chunk_root, path, key.objectid, in btrfs_relocate_sys_chunks()
3149 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_relocate_sys_chunks()
3155 leaf = path->nodes[0]; in btrfs_relocate_sys_chunks()
3156 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); in btrfs_relocate_sys_chunks()
3158 chunk = btrfs_item_ptr(leaf, path->slots[0], in btrfs_relocate_sys_chunks()
3161 btrfs_release_path(path); in btrfs_relocate_sys_chunks()
3165 if (ret == -ENOSPC) in btrfs_relocate_sys_chunks()
3170 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_relocate_sys_chunks()
3174 key.offset = found_key.offset - 1; in btrfs_relocate_sys_chunks()
3182 ret = -ENOSPC; in btrfs_relocate_sys_chunks()
3185 btrfs_free_path(path); in btrfs_relocate_sys_chunks()
3203 chunk_type = cache->flags; in btrfs_may_alloc_data_chunk()
3209 spin_lock(&fs_info->data_sinfo->lock); in btrfs_may_alloc_data_chunk()
3210 bytes_used = fs_info->data_sinfo->bytes_used; in btrfs_may_alloc_data_chunk()
3211 spin_unlock(&fs_info->data_sinfo->lock); in btrfs_may_alloc_data_chunk()
3217 trans = btrfs_join_transaction(fs_info->tree_root); in btrfs_may_alloc_data_chunk()
3234 struct btrfs_root *root = fs_info->tree_root; in insert_balance_item()
3238 struct btrfs_path *path; in insert_balance_item() local
3243 path = btrfs_alloc_path(); in insert_balance_item()
3244 if (!path) in insert_balance_item()
3245 return -ENOMEM; in insert_balance_item()
3249 btrfs_free_path(path); in insert_balance_item()
3257 ret = btrfs_insert_empty_item(trans, root, path, &key, in insert_balance_item()
3262 leaf = path->nodes[0]; in insert_balance_item()
3263 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item); in insert_balance_item()
3267 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->data); in insert_balance_item()
3269 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->meta); in insert_balance_item()
3271 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->sys); in insert_balance_item()
3274 btrfs_set_balance_flags(leaf, item, bctl->flags); in insert_balance_item()
3278 btrfs_free_path(path); in insert_balance_item()
3287 struct btrfs_root *root = fs_info->tree_root; in del_balance_item()
3289 struct btrfs_path *path; in del_balance_item() local
3293 path = btrfs_alloc_path(); in del_balance_item()
3294 if (!path) in del_balance_item()
3295 return -ENOMEM; in del_balance_item()
3299 btrfs_free_path(path); in del_balance_item()
3307 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in del_balance_item()
3311 ret = -ENOENT; in del_balance_item()
3315 ret = btrfs_del_item(trans, root, path); in del_balance_item()
3317 btrfs_free_path(path); in del_balance_item()
3333 if (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3334 bctl->data.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3335 if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3336 bctl->sys.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3337 if (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) in update_balance_args()
3338 bctl->meta.flags |= BTRFS_BALANCE_ARGS_SOFT; in update_balance_args()
3344 * converted - that will keep us from relocating unconverted in update_balance_args()
3347 if (!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3348 !(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3349 !(bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3350 bctl->data.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3351 bctl->data.usage = 90; in update_balance_args()
3353 if (!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3354 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3355 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3356 bctl->sys.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3357 bctl->sys.usage = 90; in update_balance_args()
3359 if (!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE) && in update_balance_args()
3360 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in update_balance_args()
3361 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)) { in update_balance_args()
3362 bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE; in update_balance_args()
3363 bctl->meta.usage = 90; in update_balance_args()
3372 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in reset_balance_state()
3375 BUG_ON(!fs_info->balance_ctl); in reset_balance_state()
3377 spin_lock(&fs_info->balance_lock); in reset_balance_state()
3378 fs_info->balance_ctl = NULL; in reset_balance_state()
3379 spin_unlock(&fs_info->balance_lock); in reset_balance_state()
3397 if (bargs->profiles & chunk_type) in chunk_profiles_filter()
3413 chunk_used = cache->used; in chunk_usage_range_filter()
3415 if (bargs->usage_min == 0) in chunk_usage_range_filter()
3418 user_thresh_min = div_factor_fine(cache->length, in chunk_usage_range_filter()
3419 bargs->usage_min); in chunk_usage_range_filter()
3421 if (bargs->usage_max == 0) in chunk_usage_range_filter()
3423 else if (bargs->usage_max > 100) in chunk_usage_range_filter()
3424 user_thresh_max = cache->length; in chunk_usage_range_filter()
3426 user_thresh_max = div_factor_fine(cache->length, in chunk_usage_range_filter()
3427 bargs->usage_max); in chunk_usage_range_filter()
3444 chunk_used = cache->used; in chunk_usage_filter()
3446 if (bargs->usage_min == 0) in chunk_usage_filter()
3448 else if (bargs->usage > 100) in chunk_usage_filter()
3449 user_thresh = cache->length; in chunk_usage_filter()
3451 user_thresh = div_factor_fine(cache->length, bargs->usage); in chunk_usage_filter()
3470 if (btrfs_stripe_devid(leaf, stripe) == bargs->devid) in chunk_devid_filter()
3484 return num_stripes - nparity; in calc_data_stripes()
3502 if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID)) in chunk_drange_filter()
3510 if (btrfs_stripe_devid(leaf, stripe) != bargs->devid) in chunk_drange_filter()
3517 if (stripe_offset < bargs->pend && in chunk_drange_filter()
3518 stripe_offset + stripe_length > bargs->pstart) in chunk_drange_filter()
3531 if (chunk_offset < bargs->vend && in chunk_vrange_filter()
3532 chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart) in chunk_vrange_filter()
3545 if (bargs->stripes_min <= num_stripes in chunk_stripes_range_filter()
3546 && num_stripes <= bargs->stripes_max) in chunk_stripes_range_filter()
3555 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT)) in chunk_soft_convert_filter()
3561 if (bargs->target == chunk_type) in chunk_soft_convert_filter()
3570 struct btrfs_fs_info *fs_info = leaf->fs_info; in should_balance_chunk()
3571 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in should_balance_chunk()
3577 (bctl->flags & BTRFS_BALANCE_TYPE_MASK))) { in should_balance_chunk()
3582 bargs = &bctl->data; in should_balance_chunk()
3584 bargs = &bctl->sys; in should_balance_chunk()
3586 bargs = &bctl->meta; in should_balance_chunk()
3589 if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) && in should_balance_chunk()
3595 if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) && in should_balance_chunk()
3598 } else if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) && in should_balance_chunk()
3604 if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) && in should_balance_chunk()
3610 if ((bargs->flags & BTRFS_BALANCE_ARGS_DRANGE) && in should_balance_chunk()
3616 if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) && in should_balance_chunk()
3622 if ((bargs->flags & BTRFS_BALANCE_ARGS_STRIPES_RANGE) && in should_balance_chunk()
3628 if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) && in should_balance_chunk()
3636 if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT)) { in should_balance_chunk()
3637 if (bargs->limit == 0) in should_balance_chunk()
3640 bargs->limit--; in should_balance_chunk()
3641 } else if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT_RANGE)) { in should_balance_chunk()
3647 if (bargs->limit_max == 0) in should_balance_chunk()
3650 bargs->limit_max--; in should_balance_chunk()
3658 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in __btrfs_balance()
3659 struct btrfs_root *chunk_root = fs_info->chunk_root; in __btrfs_balance()
3662 struct btrfs_path *path = NULL; in __btrfs_balance() local
3671 u64 limit_data = bctl->data.limit; in __btrfs_balance()
3672 u64 limit_meta = bctl->meta.limit; in __btrfs_balance()
3673 u64 limit_sys = bctl->sys.limit; in __btrfs_balance()
3679 path = btrfs_alloc_path(); in __btrfs_balance()
3680 if (!path) { in __btrfs_balance()
3681 ret = -ENOMEM; in __btrfs_balance()
3686 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3687 memset(&bctl->stat, 0, sizeof(bctl->stat)); in __btrfs_balance()
3688 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3695 bctl->data.limit = limit_data; in __btrfs_balance()
3696 bctl->meta.limit = limit_meta; in __btrfs_balance()
3697 bctl->sys.limit = limit_sys; in __btrfs_balance()
3700 key.offset = (u64)-1; in __btrfs_balance()
3704 if ((!counting && atomic_read(&fs_info->balance_pause_req)) || in __btrfs_balance()
3705 atomic_read(&fs_info->balance_cancel_req)) { in __btrfs_balance()
3706 ret = -ECANCELED; in __btrfs_balance()
3710 mutex_lock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3711 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0); in __btrfs_balance()
3713 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3724 ret = btrfs_previous_item(chunk_root, path, 0, in __btrfs_balance()
3727 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3732 leaf = path->nodes[0]; in __btrfs_balance()
3733 slot = path->slots[0]; in __btrfs_balance()
3737 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3745 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3746 bctl->stat.considered++; in __btrfs_balance()
3747 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3752 btrfs_release_path(path); in __btrfs_balance()
3754 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3759 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3760 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3761 bctl->stat.expected++; in __btrfs_balance()
3762 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3779 count_data < bctl->data.limit_min) in __btrfs_balance()
3781 count_meta < bctl->meta.limit_min) in __btrfs_balance()
3783 count_sys < bctl->sys.limit_min)) { in __btrfs_balance()
3784 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3798 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3806 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in __btrfs_balance()
3807 if (ret == -ENOSPC) { in __btrfs_balance()
3809 } else if (ret == -ETXTBSY) { in __btrfs_balance()
3817 spin_lock(&fs_info->balance_lock); in __btrfs_balance()
3818 bctl->stat.completed++; in __btrfs_balance()
3819 spin_unlock(&fs_info->balance_lock); in __btrfs_balance()
3824 key.offset = found_key.offset - 1; in __btrfs_balance()
3828 btrfs_release_path(path); in __btrfs_balance()
3833 btrfs_free_path(path); in __btrfs_balance()
3838 ret = -ENOSPC; in __btrfs_balance()
3845 * alloc_profile_is_valid - see if a given profile is valid and reduced
3869 /* cancel requested || normal exit path */ in balance_need_close()
3870 return atomic_read(&fs_info->balance_cancel_req) || in balance_need_close()
3871 (atomic_read(&fs_info->balance_pause_req) == 0 && in balance_need_close()
3872 atomic_read(&fs_info->balance_cancel_req) == 0); in balance_need_close()
3883 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT)) in validate_convert_profile()
3887 if (alloc_profile_is_valid(bargs->target, 1) && in validate_convert_profile()
3888 (bargs->target & ~allowed) == 0) in validate_convert_profile()
3892 type, btrfs_bg_type_to_raid_name(bargs->target)); in validate_convert_profile()
3907 u64 flags = bargs->flags; in describe_balance_args()
3918 size_bp -= ret; \ in describe_balance_args()
3927 size_bp -= ret; \ in describe_balance_args()
3936 size_bp -= ret; \ in describe_balance_args()
3942 btrfs_bg_type_to_raid_name(bargs->target)); in describe_balance_args()
3948 btrfs_describe_block_groups(bargs->profiles, tmp_buf, in describe_balance_args()
3954 CHECK_APPEND_1ARG("usage=%llu,", bargs->usage); in describe_balance_args()
3958 bargs->usage_min, bargs->usage_max); in describe_balance_args()
3961 CHECK_APPEND_1ARG("devid=%llu,", bargs->devid); in describe_balance_args()
3965 bargs->pstart, bargs->pend); in describe_balance_args()
3969 bargs->vstart, bargs->vend); in describe_balance_args()
3972 CHECK_APPEND_1ARG("limit=%llu,", bargs->limit); in describe_balance_args()
3976 bargs->limit_min, bargs->limit_max); in describe_balance_args()
3980 bargs->stripes_min, bargs->stripes_max); in describe_balance_args()
3989 buf[size_buf - size_bp - 1] = '\0'; /* remove last , */ in describe_balance_args()
4002 struct btrfs_balance_control *bctl = fs_info->balance_ctl; in describe_balance_start_or_resume()
4015 size_bp -= ret; \ in describe_balance_start_or_resume()
4019 if (bctl->flags & BTRFS_BALANCE_FORCE) in describe_balance_start_or_resume()
4020 CHECK_APPEND_1ARG("%s", "-f "); in describe_balance_start_or_resume()
4022 if (bctl->flags & BTRFS_BALANCE_DATA) { in describe_balance_start_or_resume()
4023 describe_balance_args(&bctl->data, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4024 CHECK_APPEND_1ARG("-d%s ", tmp_buf); in describe_balance_start_or_resume()
4027 if (bctl->flags & BTRFS_BALANCE_METADATA) { in describe_balance_start_or_resume()
4028 describe_balance_args(&bctl->meta, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4029 CHECK_APPEND_1ARG("-m%s ", tmp_buf); in describe_balance_start_or_resume()
4032 if (bctl->flags & BTRFS_BALANCE_SYSTEM) { in describe_balance_start_or_resume()
4033 describe_balance_args(&bctl->sys, tmp_buf, sizeof(tmp_buf)); in describe_balance_start_or_resume()
4034 CHECK_APPEND_1ARG("-s%s ", tmp_buf); in describe_balance_start_or_resume()
4042 buf[size_buf - size_bp - 1] = '\0'; /* remove last " " */ in describe_balance_start_or_resume()
4044 (bctl->flags & BTRFS_BALANCE_RESUME) ? in describe_balance_start_or_resume()
4067 atomic_read(&fs_info->balance_pause_req) || in btrfs_balance()
4069 ret = -EINVAL; in btrfs_balance()
4073 allowed = btrfs_super_incompat_flags(fs_info->super_copy); in btrfs_balance()
4082 if (mixed && (bctl->flags & allowed)) { in btrfs_balance()
4083 if (!(bctl->flags & BTRFS_BALANCE_DATA) || in btrfs_balance()
4084 !(bctl->flags & BTRFS_BALANCE_METADATA) || in btrfs_balance()
4085 memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) { in btrfs_balance()
4088 ret = -EINVAL; in btrfs_balance()
4097 num_devices = fs_info->fs_devices->rw_devices; in btrfs_balance()
4100 * SINGLE profile on-disk has no profile bit, but in-memory we have a in btrfs_balance()
4109 if (!validate_convert_profile(fs_info, &bctl->data, allowed, "data") || in btrfs_balance()
4110 !validate_convert_profile(fs_info, &bctl->meta, allowed, "metadata") || in btrfs_balance()
4111 !validate_convert_profile(fs_info, &bctl->sys, allowed, "system")) { in btrfs_balance()
4112 ret = -EINVAL; in btrfs_balance()
4127 seq = read_seqbegin(&fs_info->profiles_lock); in btrfs_balance()
4129 if (((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) && in btrfs_balance()
4130 (fs_info->avail_system_alloc_bits & allowed) && in btrfs_balance()
4131 !(bctl->sys.target & allowed)) || in btrfs_balance()
4132 ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) && in btrfs_balance()
4133 (fs_info->avail_metadata_alloc_bits & allowed) && in btrfs_balance()
4134 !(bctl->meta.target & allowed))) in btrfs_balance()
4140 meta_target = (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) ? in btrfs_balance()
4141 bctl->meta.target : fs_info->avail_metadata_alloc_bits; in btrfs_balance()
4142 data_target = (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) ? in btrfs_balance()
4143 bctl->data.target : fs_info->avail_data_alloc_bits; in btrfs_balance()
4144 } while (read_seqretry(&fs_info->profiles_lock, seq)); in btrfs_balance()
4147 if (bctl->flags & BTRFS_BALANCE_FORCE) { in btrfs_balance()
4152 "balance: reduces metadata redundancy, use --force if you want this"); in btrfs_balance()
4153 ret = -EINVAL; in btrfs_balance()
4166 if (fs_info->send_in_progress) { in btrfs_balance()
4169 fs_info->send_in_progress); in btrfs_balance()
4170 ret = -EAGAIN; in btrfs_balance()
4175 if (ret && ret != -EEXIST) in btrfs_balance()
4178 if (!(bctl->flags & BTRFS_BALANCE_RESUME)) { in btrfs_balance()
4179 BUG_ON(ret == -EEXIST); in btrfs_balance()
4180 BUG_ON(fs_info->balance_ctl); in btrfs_balance()
4181 spin_lock(&fs_info->balance_lock); in btrfs_balance()
4182 fs_info->balance_ctl = bctl; in btrfs_balance()
4183 spin_unlock(&fs_info->balance_lock); in btrfs_balance()
4185 BUG_ON(ret != -EEXIST); in btrfs_balance()
4186 spin_lock(&fs_info->balance_lock); in btrfs_balance()
4188 spin_unlock(&fs_info->balance_lock); in btrfs_balance()
4191 ASSERT(!test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_balance()
4192 set_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags); in btrfs_balance()
4194 mutex_unlock(&fs_info->balance_mutex); in btrfs_balance()
4198 mutex_lock(&fs_info->balance_mutex); in btrfs_balance()
4199 if (ret == -ECANCELED && atomic_read(&fs_info->balance_pause_req)) in btrfs_balance()
4204 * - Regular cancel request in btrfs_balance()
4205 * Then ret == -ECANCELED and balance_cancel_req > 0 in btrfs_balance()
4207 * - Fatal signal to "btrfs" process in btrfs_balance()
4209 * got -EINTR, or caught by btrfs_should_cancel_balance() and in btrfs_balance()
4210 * got -ECANCELED. in btrfs_balance()
4212 * ret == -EINTR or ret == -ECANCELED. in btrfs_balance()
4216 else if (ret == -ECANCELED || ret == -EINTR) in btrfs_balance()
4221 clear_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags); in btrfs_balance()
4228 if ((ret && ret != -ECANCELED && ret != -ENOSPC) || in btrfs_balance()
4234 wake_up(&fs_info->balance_wait_q); in btrfs_balance()
4238 if (bctl->flags & BTRFS_BALANCE_RESUME) in btrfs_balance()
4252 sb_start_write(fs_info->sb); in balance_kthread()
4253 mutex_lock(&fs_info->balance_mutex); in balance_kthread()
4254 if (fs_info->balance_ctl) in balance_kthread()
4255 ret = btrfs_balance(fs_info, fs_info->balance_ctl, NULL); in balance_kthread()
4256 mutex_unlock(&fs_info->balance_mutex); in balance_kthread()
4257 sb_end_write(fs_info->sb); in balance_kthread()
4266 mutex_lock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4267 if (!fs_info->balance_ctl) { in btrfs_resume_balance_async()
4268 mutex_unlock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4271 mutex_unlock(&fs_info->balance_mutex); in btrfs_resume_balance_async()
4279 * A ro->rw remount sequence should continue with the paused balance in btrfs_resume_balance_async()
4283 spin_lock(&fs_info->balance_lock); in btrfs_resume_balance_async()
4284 fs_info->balance_ctl->flags |= BTRFS_BALANCE_RESUME; in btrfs_resume_balance_async()
4285 spin_unlock(&fs_info->balance_lock); in btrfs_resume_balance_async()
4287 tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance"); in btrfs_resume_balance_async()
4296 struct btrfs_path *path; in btrfs_recover_balance() local
4301 path = btrfs_alloc_path(); in btrfs_recover_balance()
4302 if (!path) in btrfs_recover_balance()
4303 return -ENOMEM; in btrfs_recover_balance()
4309 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); in btrfs_recover_balance()
4312 if (ret > 0) { /* ret = -ENOENT; */ in btrfs_recover_balance()
4319 ret = -ENOMEM; in btrfs_recover_balance()
4323 leaf = path->nodes[0]; in btrfs_recover_balance()
4324 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item); in btrfs_recover_balance()
4326 bctl->flags = btrfs_balance_flags(leaf, item); in btrfs_recover_balance()
4327 bctl->flags |= BTRFS_BALANCE_RESUME; in btrfs_recover_balance()
4330 btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs); in btrfs_recover_balance()
4332 btrfs_disk_balance_args_to_cpu(&bctl->meta, &disk_bargs); in btrfs_recover_balance()
4334 btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs); in btrfs_recover_balance()
4350 btrfs_release_path(path); in btrfs_recover_balance()
4352 mutex_lock(&fs_info->balance_mutex); in btrfs_recover_balance()
4353 BUG_ON(fs_info->balance_ctl); in btrfs_recover_balance()
4354 spin_lock(&fs_info->balance_lock); in btrfs_recover_balance()
4355 fs_info->balance_ctl = bctl; in btrfs_recover_balance()
4356 spin_unlock(&fs_info->balance_lock); in btrfs_recover_balance()
4357 mutex_unlock(&fs_info->balance_mutex); in btrfs_recover_balance()
4359 btrfs_free_path(path); in btrfs_recover_balance()
4367 mutex_lock(&fs_info->balance_mutex); in btrfs_pause_balance()
4368 if (!fs_info->balance_ctl) { in btrfs_pause_balance()
4369 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4370 return -ENOTCONN; in btrfs_pause_balance()
4373 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { in btrfs_pause_balance()
4374 atomic_inc(&fs_info->balance_pause_req); in btrfs_pause_balance()
4375 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4377 wait_event(fs_info->balance_wait_q, in btrfs_pause_balance()
4378 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_pause_balance()
4380 mutex_lock(&fs_info->balance_mutex); in btrfs_pause_balance()
4382 BUG_ON(test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_pause_balance()
4383 atomic_dec(&fs_info->balance_pause_req); in btrfs_pause_balance()
4385 ret = -ENOTCONN; in btrfs_pause_balance()
4388 mutex_unlock(&fs_info->balance_mutex); in btrfs_pause_balance()
4394 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4395 if (!fs_info->balance_ctl) { in btrfs_cancel_balance()
4396 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4397 return -ENOTCONN; in btrfs_cancel_balance()
4402 * mount time if the mount is read-write. Otherwise it's still paused in btrfs_cancel_balance()
4405 if (sb_rdonly(fs_info->sb)) { in btrfs_cancel_balance()
4406 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4407 return -EROFS; in btrfs_cancel_balance()
4410 atomic_inc(&fs_info->balance_cancel_req); in btrfs_cancel_balance()
4415 if (test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)) { in btrfs_cancel_balance()
4416 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4417 wait_event(fs_info->balance_wait_q, in btrfs_cancel_balance()
4418 !test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_cancel_balance()
4419 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4421 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4426 mutex_lock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4428 if (fs_info->balance_ctl) { in btrfs_cancel_balance()
4435 BUG_ON(fs_info->balance_ctl || in btrfs_cancel_balance()
4436 test_bit(BTRFS_FS_BALANCE_RUNNING, &fs_info->flags)); in btrfs_cancel_balance()
4437 atomic_dec(&fs_info->balance_cancel_req); in btrfs_cancel_balance()
4438 mutex_unlock(&fs_info->balance_mutex); in btrfs_cancel_balance()
4445 struct btrfs_root *root = fs_info->tree_root; in btrfs_uuid_scan_kthread()
4447 struct btrfs_path *path = NULL; in btrfs_uuid_scan_kthread() local
4456 path = btrfs_alloc_path(); in btrfs_uuid_scan_kthread()
4457 if (!path) { in btrfs_uuid_scan_kthread()
4458 ret = -ENOMEM; in btrfs_uuid_scan_kthread()
4471 ret = btrfs_search_forward(root, &key, path, in btrfs_uuid_scan_kthread()
4485 eb = path->nodes[0]; in btrfs_uuid_scan_kthread()
4486 slot = path->slots[0]; in btrfs_uuid_scan_kthread()
4502 btrfs_release_path(path); in btrfs_uuid_scan_kthread()
4504 * 1 - subvol uuid item in btrfs_uuid_scan_kthread()
4505 * 1 - received_subvol uuid item in btrfs_uuid_scan_kthread()
4507 trans = btrfs_start_transaction(fs_info->uuid_root, 2); in btrfs_uuid_scan_kthread()
4517 btrfs_release_path(path); in btrfs_uuid_scan_kthread()
4542 btrfs_release_path(path); in btrfs_uuid_scan_kthread()
4550 if (key.offset < (u64)-1) { in btrfs_uuid_scan_kthread()
4555 } else if (key.objectid < (u64)-1) { in btrfs_uuid_scan_kthread()
4566 btrfs_free_path(path); in btrfs_uuid_scan_kthread()
4572 set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags); in btrfs_uuid_scan_kthread()
4573 up(&fs_info->uuid_tree_rescan_sem); in btrfs_uuid_scan_kthread()
4580 struct btrfs_root *tree_root = fs_info->tree_root; in btrfs_create_uuid_tree()
4586 * 1 - root node in btrfs_create_uuid_tree()
4587 * 1 - root item in btrfs_create_uuid_tree()
4601 fs_info->uuid_root = uuid_root; in btrfs_create_uuid_tree()
4607 down(&fs_info->uuid_tree_rescan_sem); in btrfs_create_uuid_tree()
4608 task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid"); in btrfs_create_uuid_tree()
4610 /* fs_info->update_uuid_tree_gen remains 0 in all error case */ in btrfs_create_uuid_tree()
4612 up(&fs_info->uuid_tree_rescan_sem); in btrfs_create_uuid_tree()
4626 struct btrfs_fs_info *fs_info = device->fs_info; in btrfs_shrink_device()
4627 struct btrfs_root *root = fs_info->dev_root; in btrfs_shrink_device()
4630 struct btrfs_path *path; in btrfs_shrink_device() local
4639 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_shrink_device()
4645 new_size = round_down(new_size, fs_info->sectorsize); in btrfs_shrink_device()
4647 diff = round_down(old_size - new_size, fs_info->sectorsize); in btrfs_shrink_device()
4649 if (test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) in btrfs_shrink_device()
4650 return -EINVAL; in btrfs_shrink_device()
4652 path = btrfs_alloc_path(); in btrfs_shrink_device()
4653 if (!path) in btrfs_shrink_device()
4654 return -ENOMEM; in btrfs_shrink_device()
4656 path->reada = READA_BACK; in btrfs_shrink_device()
4660 btrfs_free_path(path); in btrfs_shrink_device()
4664 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4667 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in btrfs_shrink_device()
4668 device->fs_devices->total_rw_bytes -= diff; in btrfs_shrink_device()
4669 atomic64_sub(diff, &fs_info->free_chunk_space); in btrfs_shrink_device()
4674 * in-memory chunks are synced to disk so that the loop below sees them in btrfs_shrink_device()
4678 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4683 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4688 key.objectid = device->devid; in btrfs_shrink_device()
4689 key.offset = (u64)-1; in btrfs_shrink_device()
4693 mutex_lock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4694 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); in btrfs_shrink_device()
4696 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4700 ret = btrfs_previous_item(root, path, 0, key.type); in btrfs_shrink_device()
4702 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4707 btrfs_release_path(path); in btrfs_shrink_device()
4711 l = path->nodes[0]; in btrfs_shrink_device()
4712 slot = path->slots[0]; in btrfs_shrink_device()
4713 btrfs_item_key_to_cpu(l, &key, path->slots[0]); in btrfs_shrink_device()
4715 if (key.objectid != device->devid) { in btrfs_shrink_device()
4716 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4717 btrfs_release_path(path); in btrfs_shrink_device()
4725 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4726 btrfs_release_path(path); in btrfs_shrink_device()
4731 btrfs_release_path(path); in btrfs_shrink_device()
4741 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4746 mutex_unlock(&fs_info->delete_unused_bgs_mutex); in btrfs_shrink_device()
4747 if (ret == -ENOSPC) { in btrfs_shrink_device()
4750 if (ret == -ETXTBSY) { in btrfs_shrink_device()
4757 } while (key.offset-- > 0); in btrfs_shrink_device()
4764 ret = -ENOSPC; in btrfs_shrink_device()
4775 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4777 clear_extent_bits(&device->alloc_state, new_size, (u64)-1, in btrfs_shrink_device()
4781 if (list_empty(&device->post_commit_list)) in btrfs_shrink_device()
4782 list_add_tail(&device->post_commit_list, in btrfs_shrink_device()
4783 &trans->transaction->dev_update_list); in btrfs_shrink_device()
4787 round_down(old_total - diff, fs_info->sectorsize)); in btrfs_shrink_device()
4788 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4790 /* Now btrfs_update_device() will change the on-disk size. */ in btrfs_shrink_device()
4799 btrfs_free_path(path); in btrfs_shrink_device()
4801 mutex_lock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4803 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) in btrfs_shrink_device()
4804 device->fs_devices->total_rw_bytes += diff; in btrfs_shrink_device()
4805 atomic64_add(diff, &fs_info->free_chunk_space); in btrfs_shrink_device()
4806 mutex_unlock(&fs_info->chunk_mutex); in btrfs_shrink_device()
4815 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_add_system_chunk()
4820 mutex_lock(&fs_info->chunk_mutex); in btrfs_add_system_chunk()
4824 mutex_unlock(&fs_info->chunk_mutex); in btrfs_add_system_chunk()
4825 return -EFBIG; in btrfs_add_system_chunk()
4828 ptr = super_copy->sys_chunk_array + array_size; in btrfs_add_system_chunk()
4835 mutex_unlock(&fs_info->chunk_mutex); in btrfs_add_system_chunk()
4848 if (di_a->max_avail > di_b->max_avail) in btrfs_cmp_device_info()
4849 return -1; in btrfs_cmp_device_info()
4850 if (di_a->max_avail < di_b->max_avail) in btrfs_cmp_device_info()
4852 if (di_a->total_avail > di_b->total_avail) in btrfs_cmp_device_info()
4853 return -1; in btrfs_cmp_device_info()
4854 if (di_a->total_avail < di_b->total_avail) in btrfs_cmp_device_info()
4884 /* sub_stripes info for map */
4910 u64 type = ctl->type; in init_alloc_chunk_ctl_policy_regular()
4913 ctl->max_stripe_size = SZ_1G; in init_alloc_chunk_ctl_policy_regular()
4914 ctl->max_chunk_size = BTRFS_MAX_DATA_CHUNK_SIZE; in init_alloc_chunk_ctl_policy_regular()
4917 if (fs_devices->total_rw_bytes > 50ULL * SZ_1G) in init_alloc_chunk_ctl_policy_regular()
4918 ctl->max_stripe_size = SZ_1G; in init_alloc_chunk_ctl_policy_regular()
4920 ctl->max_stripe_size = SZ_256M; in init_alloc_chunk_ctl_policy_regular()
4921 ctl->max_chunk_size = ctl->max_stripe_size; in init_alloc_chunk_ctl_policy_regular()
4923 ctl->max_stripe_size = SZ_32M; in init_alloc_chunk_ctl_policy_regular()
4924 ctl->max_chunk_size = 2 * ctl->max_stripe_size; in init_alloc_chunk_ctl_policy_regular()
4925 ctl->devs_max = min_t(int, ctl->devs_max, in init_alloc_chunk_ctl_policy_regular()
4932 ctl->max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1), in init_alloc_chunk_ctl_policy_regular()
4933 ctl->max_chunk_size); in init_alloc_chunk_ctl_policy_regular()
4934 ctl->dev_extent_min = BTRFS_STRIPE_LEN * ctl->dev_stripes; in init_alloc_chunk_ctl_policy_regular()
4940 int index = btrfs_bg_flags_to_raid_index(ctl->type); in init_alloc_chunk_ctl()
4942 ctl->sub_stripes = btrfs_raid_array[index].sub_stripes; in init_alloc_chunk_ctl()
4943 ctl->dev_stripes = btrfs_raid_array[index].dev_stripes; in init_alloc_chunk_ctl()
4944 ctl->devs_max = btrfs_raid_array[index].devs_max; in init_alloc_chunk_ctl()
4945 if (!ctl->devs_max) in init_alloc_chunk_ctl()
4946 ctl->devs_max = BTRFS_MAX_DEVS(fs_devices->fs_info); in init_alloc_chunk_ctl()
4947 ctl->devs_min = btrfs_raid_array[index].devs_min; in init_alloc_chunk_ctl()
4948 ctl->devs_increment = btrfs_raid_array[index].devs_increment; in init_alloc_chunk_ctl()
4949 ctl->ncopies = btrfs_raid_array[index].ncopies; in init_alloc_chunk_ctl()
4950 ctl->nparity = btrfs_raid_array[index].nparity; in init_alloc_chunk_ctl()
4951 ctl->ndevs = 0; in init_alloc_chunk_ctl()
4953 switch (fs_devices->chunk_alloc_policy) { in init_alloc_chunk_ctl()
4966 struct btrfs_fs_info *info = fs_devices->fs_info; in gather_device_info()
4969 u64 dev_extent_want = ctl->max_stripe_size * ctl->dev_stripes; in gather_device_info()
4979 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) { in gather_device_info()
4980 if (!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { in gather_device_info()
4982 "BTRFS: read-only device in alloc_list\n"); in gather_device_info()
4987 &device->dev_state) || in gather_device_info()
4988 test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) in gather_device_info()
4991 if (device->total_bytes > device->bytes_used) in gather_device_info()
4992 total_avail = device->total_bytes - device->bytes_used; in gather_device_info()
4997 if (total_avail < ctl->dev_extent_min) in gather_device_info()
5002 if (ret && ret != -ENOSPC) in gather_device_info()
5008 if (max_avail < ctl->dev_extent_min) { in gather_device_info()
5012 __func__, device->devid, max_avail, in gather_device_info()
5013 ctl->dev_extent_min); in gather_device_info()
5017 if (ndevs == fs_devices->rw_devices) { in gather_device_info()
5019 __func__, fs_devices->rw_devices); in gather_device_info()
5028 ctl->ndevs = ndevs; in gather_device_info()
5052 ctl->stripe_size = div_u64(devices_info[ctl->ndevs - 1].max_avail, in decide_stripe_size_regular()
5053 ctl->dev_stripes); in decide_stripe_size_regular()
5054 ctl->num_stripes = ctl->ndevs * ctl->dev_stripes; in decide_stripe_size_regular()
5057 data_stripes = (ctl->num_stripes - ctl->nparity) / ctl->ncopies; in decide_stripe_size_regular()
5065 if (ctl->stripe_size * data_stripes > ctl->max_chunk_size) { in decide_stripe_size_regular()
5071 ctl->stripe_size = min(round_up(div_u64(ctl->max_chunk_size, in decide_stripe_size_regular()
5073 ctl->stripe_size); in decide_stripe_size_regular()
5077 ctl->stripe_size = round_down(ctl->stripe_size, BTRFS_STRIPE_LEN); in decide_stripe_size_regular()
5078 ctl->chunk_size = ctl->stripe_size * data_stripes; in decide_stripe_size_regular()
5087 struct btrfs_fs_info *info = fs_devices->fs_info; in decide_stripe_size()
5094 ctl->ndevs = rounddown(ctl->ndevs, ctl->devs_increment); in decide_stripe_size()
5096 if (ctl->ndevs < ctl->devs_min) { in decide_stripe_size()
5100 __func__, ctl->ndevs, ctl->devs_min); in decide_stripe_size()
5102 return -ENOSPC; in decide_stripe_size()
5105 ctl->ndevs = min(ctl->ndevs, ctl->devs_max); in decide_stripe_size()
5107 switch (fs_devices->chunk_alloc_policy) { in decide_stripe_size()
5119 struct btrfs_fs_info *info = trans->fs_info; in create_chunk()
5120 struct map_lookup *map = NULL; in create_chunk() local
5123 u64 start = ctl->start; in create_chunk()
5124 u64 type = ctl->type; in create_chunk()
5129 map = kmalloc(map_lookup_size(ctl->num_stripes), GFP_NOFS); in create_chunk()
5130 if (!map) in create_chunk()
5131 return -ENOMEM; in create_chunk()
5132 map->num_stripes = ctl->num_stripes; in create_chunk()
5134 for (i = 0; i < ctl->ndevs; ++i) { in create_chunk()
5135 for (j = 0; j < ctl->dev_stripes; ++j) { in create_chunk()
5136 int s = i * ctl->dev_stripes + j; in create_chunk()
5137 map->stripes[s].dev = devices_info[i].dev; in create_chunk()
5138 map->stripes[s].physical = devices_info[i].dev_offset + in create_chunk()
5139 j * ctl->stripe_size; in create_chunk()
5142 map->stripe_len = BTRFS_STRIPE_LEN; in create_chunk()
5143 map->io_align = BTRFS_STRIPE_LEN; in create_chunk()
5144 map->io_width = BTRFS_STRIPE_LEN; in create_chunk()
5145 map->type = type; in create_chunk()
5146 map->sub_stripes = ctl->sub_stripes; in create_chunk()
5148 trace_btrfs_chunk_alloc(info, map, start, ctl->chunk_size); in create_chunk()
5152 kfree(map); in create_chunk()
5153 return -ENOMEM; in create_chunk()
5155 set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); in create_chunk()
5156 em->map_lookup = map; in create_chunk()
5157 em->start = start; in create_chunk()
5158 em->len = ctl->chunk_size; in create_chunk()
5159 em->block_start = 0; in create_chunk()
5160 em->block_len = em->len; in create_chunk()
5161 em->orig_block_len = ctl->stripe_size; in create_chunk()
5163 em_tree = &info->mapping_tree; in create_chunk()
5164 write_lock(&em_tree->lock); in create_chunk()
5167 write_unlock(&em_tree->lock); in create_chunk()
5171 write_unlock(&em_tree->lock); in create_chunk()
5173 ret = btrfs_make_block_group(trans, 0, type, start, ctl->chunk_size); in create_chunk()
5177 for (i = 0; i < map->num_stripes; i++) { in create_chunk()
5178 struct btrfs_device *dev = map->stripes[i].dev; in create_chunk()
5181 dev->bytes_used + ctl->stripe_size); in create_chunk()
5182 if (list_empty(&dev->post_commit_list)) in create_chunk()
5183 list_add_tail(&dev->post_commit_list, in create_chunk()
5184 &trans->transaction->dev_update_list); in create_chunk()
5187 atomic64_sub(ctl->stripe_size * map->num_stripes, in create_chunk()
5188 &info->free_chunk_space); in create_chunk()
5197 write_lock(&em_tree->lock); in create_chunk()
5199 write_unlock(&em_tree->lock); in create_chunk()
5211 struct btrfs_fs_info *info = trans->fs_info; in btrfs_alloc_chunk()
5212 struct btrfs_fs_devices *fs_devices = info->fs_devices; in btrfs_alloc_chunk()
5217 lockdep_assert_held(&info->chunk_mutex); in btrfs_alloc_chunk()
5221 return -EINVAL; in btrfs_alloc_chunk()
5224 if (list_empty(&fs_devices->alloc_list)) { in btrfs_alloc_chunk()
5227 return -ENOSPC; in btrfs_alloc_chunk()
5233 return -EINVAL; in btrfs_alloc_chunk()
5240 devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info), in btrfs_alloc_chunk()
5243 return -ENOMEM; in btrfs_alloc_chunk()
5270 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_finish_chunk_alloc()
5271 struct btrfs_root *extent_root = fs_info->extent_root; in btrfs_finish_chunk_alloc()
5272 struct btrfs_root *chunk_root = fs_info->chunk_root; in btrfs_finish_chunk_alloc()
5278 struct map_lookup *map; in btrfs_finish_chunk_alloc() local
5289 map = em->map_lookup; in btrfs_finish_chunk_alloc()
5290 item_size = btrfs_chunk_item_size(map->num_stripes); in btrfs_finish_chunk_alloc()
5291 stripe_size = em->orig_block_len; in btrfs_finish_chunk_alloc()
5295 ret = -ENOMEM; in btrfs_finish_chunk_alloc()
5302 * with the map's stripes, because the device object's id can change in btrfs_finish_chunk_alloc()
5304 * (dev-replace.c:btrfs_dev_replace_finishing()). in btrfs_finish_chunk_alloc()
5306 mutex_lock(&fs_info->fs_devices->device_list_mutex); in btrfs_finish_chunk_alloc()
5307 for (i = 0; i < map->num_stripes; i++) { in btrfs_finish_chunk_alloc()
5308 device = map->stripes[i].dev; in btrfs_finish_chunk_alloc()
5309 dev_offset = map->stripes[i].physical; in btrfs_finish_chunk_alloc()
5320 mutex_unlock(&fs_info->fs_devices->device_list_mutex); in btrfs_finish_chunk_alloc()
5324 stripe = &chunk->stripe; in btrfs_finish_chunk_alloc()
5325 for (i = 0; i < map->num_stripes; i++) { in btrfs_finish_chunk_alloc()
5326 device = map->stripes[i].dev; in btrfs_finish_chunk_alloc()
5327 dev_offset = map->stripes[i].physical; in btrfs_finish_chunk_alloc()
5329 btrfs_set_stack_stripe_devid(stripe, device->devid); in btrfs_finish_chunk_alloc()
5331 memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE); in btrfs_finish_chunk_alloc()
5334 mutex_unlock(&fs_info->fs_devices->device_list_mutex); in btrfs_finish_chunk_alloc()
5337 btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid); in btrfs_finish_chunk_alloc()
5338 btrfs_set_stack_chunk_stripe_len(chunk, map->stripe_len); in btrfs_finish_chunk_alloc()
5339 btrfs_set_stack_chunk_type(chunk, map->type); in btrfs_finish_chunk_alloc()
5340 btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes); in btrfs_finish_chunk_alloc()
5341 btrfs_set_stack_chunk_io_align(chunk, map->stripe_len); in btrfs_finish_chunk_alloc()
5342 btrfs_set_stack_chunk_io_width(chunk, map->stripe_len); in btrfs_finish_chunk_alloc()
5343 btrfs_set_stack_chunk_sector_size(chunk, fs_info->sectorsize); in btrfs_finish_chunk_alloc()
5344 btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes); in btrfs_finish_chunk_alloc()
5351 if (ret == 0 && map->type & BTRFS_BLOCK_GROUP_SYSTEM) { in btrfs_finish_chunk_alloc()
5367 struct btrfs_fs_info *fs_info = trans->fs_info; in init_first_rw_device()
5381 static inline int btrfs_chunk_max_errors(struct map_lookup *map) in btrfs_chunk_max_errors() argument
5383 const int index = btrfs_bg_flags_to_raid_index(map->type); in btrfs_chunk_max_errors()
5391 struct map_lookup *map; in btrfs_chunk_readonly() local
5400 map = em->map_lookup; in btrfs_chunk_readonly()
5401 for (i = 0; i < map->num_stripes; i++) { in btrfs_chunk_readonly()
5403 &map->stripes[i].dev->dev_state)) { in btrfs_chunk_readonly()
5408 &map->stripes[i].dev->dev_state)) { in btrfs_chunk_readonly()
5419 if (miss_ndevs > btrfs_chunk_max_errors(map)) in btrfs_chunk_readonly()
5431 write_lock(&tree->lock); in btrfs_mapping_tree_free()
5432 em = lookup_extent_mapping(tree, 0, (u64)-1); in btrfs_mapping_tree_free()
5435 write_unlock(&tree->lock); in btrfs_mapping_tree_free()
5448 struct map_lookup *map; in btrfs_num_copies() local
5461 map = em->map_lookup; in btrfs_num_copies()
5462 if (map->type & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1_MASK)) in btrfs_num_copies()
5463 ret = map->num_stripes; in btrfs_num_copies()
5464 else if (map->type & BTRFS_BLOCK_GROUP_RAID10) in btrfs_num_copies()
5465 ret = map->sub_stripes; in btrfs_num_copies()
5466 else if (map->type & BTRFS_BLOCK_GROUP_RAID5) in btrfs_num_copies()
5468 else if (map->type & BTRFS_BLOCK_GROUP_RAID6) in btrfs_num_copies()
5476 ret = map->num_stripes; in btrfs_num_copies()
5481 down_read(&fs_info->dev_replace.rwsem); in btrfs_num_copies()
5482 if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace) && in btrfs_num_copies()
5483 fs_info->dev_replace.tgtdev) in btrfs_num_copies()
5485 up_read(&fs_info->dev_replace.rwsem); in btrfs_num_copies()
5494 struct map_lookup *map; in btrfs_full_stripe_len() local
5495 unsigned long len = fs_info->sectorsize; in btrfs_full_stripe_len()
5500 map = em->map_lookup; in btrfs_full_stripe_len()
5501 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) in btrfs_full_stripe_len()
5502 len = map->stripe_len * nr_data_stripes(map); in btrfs_full_stripe_len()
5511 struct map_lookup *map; in btrfs_is_parity_mirror() local
5517 map = em->map_lookup; in btrfs_is_parity_mirror()
5518 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) in btrfs_is_parity_mirror()
5526 struct map_lookup *map, int first, in find_live_mirror() argument
5535 ASSERT((map->type & in find_live_mirror()
5538 if (map->type & BTRFS_BLOCK_GROUP_RAID10) in find_live_mirror()
5539 num_stripes = map->sub_stripes; in find_live_mirror()
5541 num_stripes = map->num_stripes; in find_live_mirror()
5543 preferred_mirror = first + current->pid % num_stripes; in find_live_mirror()
5546 fs_info->dev_replace.cont_reading_from_srcdev_mode == in find_live_mirror()
5548 srcdev = fs_info->dev_replace.srcdev; in find_live_mirror()
5554 * dev-replace procedure, only choose it if no other non-missing in find_live_mirror()
5558 if (map->stripes[preferred_mirror].dev->bdev && in find_live_mirror()
5559 (tolerance || map->stripes[preferred_mirror].dev != srcdev)) in find_live_mirror()
5562 if (map->stripes[i].dev->bdev && in find_live_mirror()
5563 (tolerance || map->stripes[i].dev != srcdev)) in find_live_mirror()
5574 /* Bubble-sort the stripe set to put the parity/syndrome stripes last */
5582 for (i = 0; i < num_stripes - 1; i++) { in sort_parity_stripes()
5584 if (bbio->raid_map[i] > bbio->raid_map[i + 1]) { in sort_parity_stripes()
5585 swap(bbio->stripes[i], bbio->stripes[i + 1]); in sort_parity_stripes()
5586 swap(bbio->raid_map[i], bbio->raid_map[i + 1]); in sort_parity_stripes()
5609 atomic_set(&bbio->error, 0); in alloc_btrfs_bio()
5610 refcount_set(&bbio->refs, 1); in alloc_btrfs_bio()
5612 bbio->tgtdev_map = (int *)(bbio->stripes + total_stripes); in alloc_btrfs_bio()
5613 bbio->raid_map = (u64 *)(bbio->tgtdev_map + real_stripes); in alloc_btrfs_bio()
5620 WARN_ON(!refcount_read(&bbio->refs)); in btrfs_get_bbio()
5621 refcount_inc(&bbio->refs); in btrfs_get_bbio()
5628 if (refcount_dec_and_test(&bbio->refs)) in btrfs_put_bbio()
5642 struct map_lookup *map; in __btrfs_map_block_for_discard() local
5669 map = em->map_lookup; in __btrfs_map_block_for_discard()
5671 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in __btrfs_map_block_for_discard()
5672 ret = -EOPNOTSUPP; in __btrfs_map_block_for_discard()
5676 offset = logical - em->start; in __btrfs_map_block_for_discard()
5677 length = min_t(u64, em->start + em->len - logical, length); in __btrfs_map_block_for_discard()
5680 stripe_len = map->stripe_len; in __btrfs_map_block_for_discard()
5688 stripe_offset = offset - stripe_nr * stripe_len; in __btrfs_map_block_for_discard()
5690 stripe_nr_end = round_up(offset + length, map->stripe_len); in __btrfs_map_block_for_discard()
5691 stripe_nr_end = div64_u64(stripe_nr_end, map->stripe_len); in __btrfs_map_block_for_discard()
5692 stripe_cnt = stripe_nr_end - stripe_nr; in __btrfs_map_block_for_discard()
5693 stripe_end_offset = stripe_nr_end * map->stripe_len - in __btrfs_map_block_for_discard()
5702 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | in __btrfs_map_block_for_discard()
5704 if (map->type & BTRFS_BLOCK_GROUP_RAID0) in __btrfs_map_block_for_discard()
5707 sub_stripes = map->sub_stripes; in __btrfs_map_block_for_discard()
5709 factor = map->num_stripes / sub_stripes; in __btrfs_map_block_for_discard()
5710 num_stripes = min_t(u64, map->num_stripes, in __btrfs_map_block_for_discard()
5716 div_u64_rem(stripe_nr_end - 1, factor, &last_stripe); in __btrfs_map_block_for_discard()
5718 } else if (map->type & (BTRFS_BLOCK_GROUP_RAID1_MASK | in __btrfs_map_block_for_discard()
5720 num_stripes = map->num_stripes; in __btrfs_map_block_for_discard()
5722 stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, in __btrfs_map_block_for_discard()
5728 ret = -ENOMEM; in __btrfs_map_block_for_discard()
5733 bbio->stripes[i].physical = in __btrfs_map_block_for_discard()
5734 map->stripes[stripe_index].physical + in __btrfs_map_block_for_discard()
5735 stripe_offset + stripe_nr * map->stripe_len; in __btrfs_map_block_for_discard()
5736 bbio->stripes[i].dev = map->stripes[stripe_index].dev; in __btrfs_map_block_for_discard()
5738 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | in __btrfs_map_block_for_discard()
5740 bbio->stripes[i].length = stripes_per_dev * in __btrfs_map_block_for_discard()
5741 map->stripe_len; in __btrfs_map_block_for_discard()
5744 bbio->stripes[i].length += in __btrfs_map_block_for_discard()
5745 map->stripe_len; in __btrfs_map_block_for_discard()
5751 * |-------|...|-------| in __btrfs_map_block_for_discard()
5752 * |----------| in __btrfs_map_block_for_discard()
5756 bbio->stripes[i].length -= in __btrfs_map_block_for_discard()
5761 sub_stripes - 1)) in __btrfs_map_block_for_discard()
5762 bbio->stripes[i].length -= in __btrfs_map_block_for_discard()
5765 if (i == sub_stripes - 1) in __btrfs_map_block_for_discard()
5768 bbio->stripes[i].length = length; in __btrfs_map_block_for_discard()
5772 if (stripe_index == map->num_stripes) { in __btrfs_map_block_for_discard()
5779 bbio->map_type = map->type; in __btrfs_map_block_for_discard()
5780 bbio->num_stripes = num_stripes; in __btrfs_map_block_for_discard()
5787 * In dev-replace case, for repair case (that's the only case where the mirror
5796 * can happen because btrfs_num_copies() returns one more in the dev-replace
5819 num_stripes = bbio->num_stripes; in get_extra_mirror_from_replace()
5827 return -EIO; in get_extra_mirror_from_replace()
5836 if (bbio->stripes[i].dev->devid != srcdev_devid) in get_extra_mirror_from_replace()
5844 physical_of_found <= bbio->stripes[i].physical) in get_extra_mirror_from_replace()
5849 physical_of_found = bbio->stripes[i].physical; in get_extra_mirror_from_replace()
5856 return -EIO; in get_extra_mirror_from_replace()
5869 u64 srcdev_devid = dev_replace->srcdev->devid; in handle_ops_on_dev_replace()
5885 * Note that device->missing is handled by the caller, and that in handle_ops_on_dev_replace()
5891 if (bbio->stripes[i].dev->devid == srcdev_devid) { in handle_ops_on_dev_replace()
5894 bbio->stripes + index_where_to_add; in handle_ops_on_dev_replace()
5896 bbio->stripes + i; in handle_ops_on_dev_replace()
5898 new->physical = old->physical; in handle_ops_on_dev_replace()
5899 new->length = old->length; in handle_ops_on_dev_replace()
5900 new->dev = dev_replace->tgtdev; in handle_ops_on_dev_replace()
5901 bbio->tgtdev_map[i] = index_where_to_add; in handle_ops_on_dev_replace()
5914 * During the dev-replace procedure, the target drive can also in handle_ops_on_dev_replace()
5921 if (bbio->stripes[i].dev->devid == srcdev_devid) { in handle_ops_on_dev_replace()
5929 bbio->stripes[i].physical) in handle_ops_on_dev_replace()
5933 physical_of_found = bbio->stripes[i].physical; in handle_ops_on_dev_replace()
5938 bbio->stripes + num_stripes; in handle_ops_on_dev_replace()
5940 tgtdev_stripe->physical = physical_of_found; in handle_ops_on_dev_replace()
5941 tgtdev_stripe->length = in handle_ops_on_dev_replace()
5942 bbio->stripes[index_srcdev].length; in handle_ops_on_dev_replace()
5943 tgtdev_stripe->dev = dev_replace->tgtdev; in handle_ops_on_dev_replace()
5944 bbio->tgtdev_map[index_srcdev] = num_stripes; in handle_ops_on_dev_replace()
5953 bbio->num_tgtdevs = tgtdev_indexes; in handle_ops_on_dev_replace()
5963 * btrfs_get_io_geometry - calculates the geomery of a particular (address, len)
5967 * @fs_info - the filesystem
5968 * @logical - address that we want to figure out the geometry of
5969 * @len - the length of IO we are going to perform, starting at @logical
5970 * @op - type of operation - write or read
5971 * @io_geom - pointer used to return values
5980 struct map_lookup *map; in btrfs_get_io_geometry() local
5985 u64 raid56_full_stripe_start = (u64)-1; in btrfs_get_io_geometry()
5995 map = em->map_lookup; in btrfs_get_io_geometry()
5997 offset = logical - em->start; in btrfs_get_io_geometry()
5999 stripe_len = map->stripe_len; in btrfs_get_io_geometry()
6007 stripe_offset, offset, em->start, logical, stripe_len); in btrfs_get_io_geometry()
6008 ret = -EINVAL; in btrfs_get_io_geometry()
6013 stripe_offset = offset - stripe_offset; in btrfs_get_io_geometry()
6014 data_stripes = nr_data_stripes(map); in btrfs_get_io_geometry()
6016 if (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) { in btrfs_get_io_geometry()
6017 u64 max_len = stripe_len - stripe_offset; in btrfs_get_io_geometry()
6022 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in btrfs_get_io_geometry()
6040 max_len = stripe_len * data_stripes - in btrfs_get_io_geometry()
6041 (offset - raid56_full_stripe_start); in btrfs_get_io_geometry()
6044 len = min_t(u64, em->len - offset, max_len); in btrfs_get_io_geometry()
6046 len = em->len - offset; in btrfs_get_io_geometry()
6049 io_geom->len = len; in btrfs_get_io_geometry()
6050 io_geom->offset = offset; in btrfs_get_io_geometry()
6051 io_geom->stripe_len = stripe_len; in btrfs_get_io_geometry()
6052 io_geom->stripe_nr = stripe_nr; in btrfs_get_io_geometry()
6053 io_geom->stripe_offset = stripe_offset; in btrfs_get_io_geometry()
6054 io_geom->raid56_stripe_offset = raid56_full_stripe_start; in btrfs_get_io_geometry()
6069 struct map_lookup *map; in __btrfs_map_block() local
6081 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace; in __btrfs_map_block()
6086 u64 raid56_full_stripe_start = (u64)-1; in __btrfs_map_block()
6098 map = em->map_lookup; in __btrfs_map_block()
6105 data_stripes = nr_data_stripes(map); in __btrfs_map_block()
6107 down_read(&dev_replace->rwsem); in __btrfs_map_block()
6114 up_read(&dev_replace->rwsem); in __btrfs_map_block()
6116 if (dev_replace_is_ongoing && mirror_num == map->num_stripes + 1 && in __btrfs_map_block()
6117 !need_full_stripe(op) && dev_replace->tgtdev != NULL) { in __btrfs_map_block()
6119 dev_replace->srcdev->devid, in __btrfs_map_block()
6126 } else if (mirror_num > map->num_stripes) { in __btrfs_map_block()
6132 if (map->type & BTRFS_BLOCK_GROUP_RAID0) { in __btrfs_map_block()
6133 stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, in __btrfs_map_block()
6137 } else if (map->type & BTRFS_BLOCK_GROUP_RAID1_MASK) { in __btrfs_map_block()
6139 num_stripes = map->num_stripes; in __btrfs_map_block()
6141 stripe_index = mirror_num - 1; in __btrfs_map_block()
6143 stripe_index = find_live_mirror(fs_info, map, 0, in __btrfs_map_block()
6148 } else if (map->type & BTRFS_BLOCK_GROUP_DUP) { in __btrfs_map_block()
6150 num_stripes = map->num_stripes; in __btrfs_map_block()
6152 stripe_index = mirror_num - 1; in __btrfs_map_block()
6157 } else if (map->type & BTRFS_BLOCK_GROUP_RAID10) { in __btrfs_map_block()
6158 u32 factor = map->num_stripes / map->sub_stripes; in __btrfs_map_block()
6161 stripe_index *= map->sub_stripes; in __btrfs_map_block()
6164 num_stripes = map->sub_stripes; in __btrfs_map_block()
6166 stripe_index += mirror_num - 1; in __btrfs_map_block()
6169 stripe_index = find_live_mirror(fs_info, map, in __btrfs_map_block()
6172 mirror_num = stripe_index - old_stripe_index + 1; in __btrfs_map_block()
6175 } else if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) { in __btrfs_map_block()
6182 num_stripes = map->num_stripes; in __btrfs_map_block()
6183 max_errors = nr_parity_stripes(map); in __btrfs_map_block()
6185 *length = map->stripe_len; in __btrfs_map_block()
6197 stripe_index = data_stripes + mirror_num - 2; in __btrfs_map_block()
6200 div_u64_rem(stripe_nr + stripe_index, map->num_stripes, in __btrfs_map_block()
6211 stripe_nr = div_u64_rem(stripe_nr, map->num_stripes, in __btrfs_map_block()
6215 if (stripe_index >= map->num_stripes) { in __btrfs_map_block()
6218 stripe_index, map->num_stripes); in __btrfs_map_block()
6219 ret = -EINVAL; in __btrfs_map_block()
6224 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL) { in __btrfs_map_block()
6234 ret = -ENOMEM; in __btrfs_map_block()
6239 bbio->stripes[i].physical = map->stripes[stripe_index].physical + in __btrfs_map_block()
6240 stripe_offset + stripe_nr * map->stripe_len; in __btrfs_map_block()
6241 bbio->stripes[i].dev = map->stripes[stripe_index].dev; in __btrfs_map_block()
6246 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK && need_raid_map && in __btrfs_map_block()
6251 /* Work out the disk rotation on this stripe-set */ in __btrfs_map_block()
6257 bbio->raid_map[(i+rot) % num_stripes] = in __btrfs_map_block()
6258 em->start + (tmp + i) * map->stripe_len; in __btrfs_map_block()
6260 bbio->raid_map[(i+rot) % map->num_stripes] = RAID5_P_STRIPE; in __btrfs_map_block()
6261 if (map->type & BTRFS_BLOCK_GROUP_RAID6) in __btrfs_map_block()
6262 bbio->raid_map[(i+rot+1) % num_stripes] = in __btrfs_map_block()
6269 max_errors = btrfs_chunk_max_errors(map); in __btrfs_map_block()
6271 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL && in __btrfs_map_block()
6278 bbio->map_type = map->type; in __btrfs_map_block()
6279 bbio->num_stripes = num_stripes; in __btrfs_map_block()
6280 bbio->max_errors = max_errors; in __btrfs_map_block()
6281 bbio->mirror_num = mirror_num; in __btrfs_map_block()
6290 bbio->stripes[0].dev = dev_replace->tgtdev; in __btrfs_map_block()
6291 bbio->stripes[0].physical = physical_to_patch_in_first_stripe; in __btrfs_map_block()
6292 bbio->mirror_num = map->num_stripes + 1; in __btrfs_map_block()
6296 lockdep_assert_held(&dev_replace->rwsem); in __btrfs_map_block()
6298 up_read(&dev_replace->rwsem); in __btrfs_map_block()
6326 bio->bi_private = bbio->private; in btrfs_end_bbio()
6327 bio->bi_end_io = bbio->end_io; in btrfs_end_bbio()
6335 struct btrfs_bio *bbio = bio->bi_private; in btrfs_end_bio()
6338 if (bio->bi_status) { in btrfs_end_bio()
6339 atomic_inc(&bbio->error); in btrfs_end_bio()
6340 if (bio->bi_status == BLK_STS_IOERR || in btrfs_end_bio()
6341 bio->bi_status == BLK_STS_TARGET) { in btrfs_end_bio()
6342 struct btrfs_device *dev = btrfs_io_bio(bio)->device; in btrfs_end_bio()
6344 ASSERT(dev->bdev); in btrfs_end_bio()
6348 else if (!(bio->bi_opf & REQ_RAHEAD)) in btrfs_end_bio()
6351 if (bio->bi_opf & REQ_PREFLUSH) in btrfs_end_bio()
6357 if (bio == bbio->orig_bio) in btrfs_end_bio()
6360 btrfs_bio_counter_dec(bbio->fs_info); in btrfs_end_bio()
6362 if (atomic_dec_and_test(&bbio->stripes_pending)) { in btrfs_end_bio()
6365 bio = bbio->orig_bio; in btrfs_end_bio()
6368 btrfs_io_bio(bio)->mirror_num = bbio->mirror_num; in btrfs_end_bio()
6372 if (atomic_read(&bbio->error) > bbio->max_errors) { in btrfs_end_bio()
6373 bio->bi_status = BLK_STS_IOERR; in btrfs_end_bio()
6379 bio->bi_status = BLK_STS_OK; in btrfs_end_bio()
6391 struct btrfs_fs_info *fs_info = bbio->fs_info; in submit_stripe_bio()
6393 bio->bi_private = bbio; in submit_stripe_bio()
6394 btrfs_io_bio(bio)->device = dev; in submit_stripe_bio()
6395 bio->bi_end_io = btrfs_end_bio; in submit_stripe_bio()
6396 bio->bi_iter.bi_sector = physical >> 9; in submit_stripe_bio()
6399 bio_op(bio), bio->bi_opf, (u64)bio->bi_iter.bi_sector, in submit_stripe_bio()
6400 (unsigned long)dev->bdev->bd_dev, rcu_str_deref(dev->name), in submit_stripe_bio()
6401 dev->devid, bio->bi_iter.bi_size); in submit_stripe_bio()
6402 bio_set_dev(bio, dev->bdev); in submit_stripe_bio()
6411 atomic_inc(&bbio->error); in bbio_error()
6412 if (atomic_dec_and_test(&bbio->stripes_pending)) { in bbio_error()
6414 WARN_ON(bio != bbio->orig_bio); in bbio_error()
6416 btrfs_io_bio(bio)->mirror_num = bbio->mirror_num; in bbio_error()
6417 bio->bi_iter.bi_sector = logical >> 9; in bbio_error()
6418 if (atomic_read(&bbio->error) > bbio->max_errors) in bbio_error()
6419 bio->bi_status = BLK_STS_IOERR; in bbio_error()
6421 bio->bi_status = BLK_STS_OK; in bbio_error()
6431 u64 logical = (u64)bio->bi_iter.bi_sector << 9; in btrfs_map_bio()
6439 length = bio->bi_iter.bi_size; in btrfs_map_bio()
6450 total_devs = bbio->num_stripes; in btrfs_map_bio()
6451 bbio->orig_bio = first_bio; in btrfs_map_bio()
6452 bbio->private = first_bio->bi_private; in btrfs_map_bio()
6453 bbio->end_io = first_bio->bi_end_io; in btrfs_map_bio()
6454 bbio->fs_info = fs_info; in btrfs_map_bio()
6455 atomic_set(&bbio->stripes_pending, bbio->num_stripes); in btrfs_map_bio()
6457 if ((bbio->map_type & BTRFS_BLOCK_GROUP_RAID56_MASK) && in btrfs_map_bio()
6481 dev = bbio->stripes[dev_nr].dev; in btrfs_map_bio()
6482 if (!dev || !dev->bdev || test_bit(BTRFS_DEV_STATE_MISSING, in btrfs_map_bio()
6483 &dev->dev_state) || in btrfs_map_bio()
6485 !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))) { in btrfs_map_bio()
6490 if (dev_nr < total_devs - 1) in btrfs_map_bio()
6495 submit_stripe_bio(bbio, bio, bbio->stripes[dev_nr].physical, dev); in btrfs_map_bio()
6517 if (!fsid || !memcmp(fs_devices->metadata_uuid, fsid, BTRFS_FSID_SIZE)) { in btrfs_find_device()
6518 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_find_device()
6519 if (device->devid == devid && in btrfs_find_device()
6520 (!uuid || memcmp(device->uuid, uuid, in btrfs_find_device()
6526 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_find_device()
6528 !memcmp(seed_devs->metadata_uuid, fsid, BTRFS_FSID_SIZE)) { in btrfs_find_device()
6529 list_for_each_entry(device, &seed_devs->devices, in btrfs_find_device()
6531 if (device->devid == devid && in btrfs_find_device()
6532 (!uuid || memcmp(device->uuid, uuid, in btrfs_find_device()
6560 list_add(&device->dev_list, &fs_devices->devices); in add_missing_dev()
6561 device->fs_devices = fs_devices; in add_missing_dev()
6562 fs_devices->num_devices++; in add_missing_dev()
6564 set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in add_missing_dev()
6565 fs_devices->missing_devices++; in add_missing_dev()
6571 * btrfs_alloc_device - allocate struct btrfs_device
6591 return ERR_PTR(-EINVAL); in btrfs_alloc_device()
6608 dev->devid = tmp; in btrfs_alloc_device()
6611 memcpy(dev->uuid, uuid, BTRFS_UUID_SIZE); in btrfs_alloc_device()
6613 generate_random_uuid(dev->uuid); in btrfs_alloc_device()
6637 data_stripes = num_stripes - nparity; in calc_stripe_length()
6647 struct btrfs_fs_info *fs_info = leaf->fs_info; in read_one_chunk()
6648 struct extent_map_tree *map_tree = &fs_info->mapping_tree; in read_one_chunk()
6649 struct map_lookup *map; in read_one_chunk() local
6659 logical = key->offset; in read_one_chunk()
6665 * as chunk item in tree block is already verified by tree-checker. in read_one_chunk()
6667 if (leaf->start == BTRFS_SUPER_INFO_OFFSET) { in read_one_chunk()
6673 read_lock(&map_tree->lock); in read_one_chunk()
6675 read_unlock(&map_tree->lock); in read_one_chunk()
6678 if (em && em->start <= logical && em->start + em->len > logical) { in read_one_chunk()
6687 return -ENOMEM; in read_one_chunk()
6688 map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS); in read_one_chunk()
6689 if (!map) { in read_one_chunk()
6691 return -ENOMEM; in read_one_chunk()
6694 set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); in read_one_chunk()
6695 em->map_lookup = map; in read_one_chunk()
6696 em->start = logical; in read_one_chunk()
6697 em->len = length; in read_one_chunk()
6698 em->orig_start = 0; in read_one_chunk()
6699 em->block_start = 0; in read_one_chunk()
6700 em->block_len = em->len; in read_one_chunk()
6702 map->num_stripes = num_stripes; in read_one_chunk()
6703 map->io_width = btrfs_chunk_io_width(leaf, chunk); in read_one_chunk()
6704 map->io_align = btrfs_chunk_io_align(leaf, chunk); in read_one_chunk()
6705 map->stripe_len = btrfs_chunk_stripe_len(leaf, chunk); in read_one_chunk()
6706 map->type = btrfs_chunk_type(leaf, chunk); in read_one_chunk()
6707 map->sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk); in read_one_chunk()
6708 map->verified_stripes = 0; in read_one_chunk()
6709 em->orig_block_len = calc_stripe_length(map->type, em->len, in read_one_chunk()
6710 map->num_stripes); in read_one_chunk()
6712 map->stripes[i].physical = in read_one_chunk()
6718 map->stripes[i].dev = btrfs_find_device(fs_info->fs_devices, in read_one_chunk()
6720 if (!map->stripes[i].dev && in read_one_chunk()
6724 return -ENOENT; in read_one_chunk()
6726 if (!map->stripes[i].dev) { in read_one_chunk()
6727 map->stripes[i].dev = in read_one_chunk()
6728 add_missing_dev(fs_info->fs_devices, devid, in read_one_chunk()
6730 if (IS_ERR(map->stripes[i].dev)) { in read_one_chunk()
6734 devid, PTR_ERR(map->stripes[i].dev)); in read_one_chunk()
6735 return PTR_ERR(map->stripes[i].dev); in read_one_chunk()
6740 &(map->stripes[i].dev->dev_state)); in read_one_chunk()
6744 write_lock(&map_tree->lock); in read_one_chunk()
6746 write_unlock(&map_tree->lock); in read_one_chunk()
6749 "failed to add chunk map, start=%llu len=%llu: %d", in read_one_chunk()
6750 em->start, em->len, ret); in read_one_chunk()
6763 device->devid = btrfs_device_id(leaf, dev_item); in fill_device_from_item()
6764 device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item); in fill_device_from_item()
6765 device->total_bytes = device->disk_total_bytes; in fill_device_from_item()
6766 device->commit_total_bytes = device->disk_total_bytes; in fill_device_from_item()
6767 device->bytes_used = btrfs_device_bytes_used(leaf, dev_item); in fill_device_from_item()
6768 device->commit_bytes_used = device->bytes_used; in fill_device_from_item()
6769 device->type = btrfs_device_type(leaf, dev_item); in fill_device_from_item()
6770 device->io_align = btrfs_device_io_align(leaf, dev_item); in fill_device_from_item()
6771 device->io_width = btrfs_device_io_width(leaf, dev_item); in fill_device_from_item()
6772 device->sector_size = btrfs_device_sector_size(leaf, dev_item); in fill_device_from_item()
6773 WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID); in fill_device_from_item()
6774 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); in fill_device_from_item()
6777 read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); in fill_device_from_item()
6789 /* This will match only for multi-device seed fs */ in open_seed_devices()
6790 list_for_each_entry(fs_devices, &fs_info->fs_devices->seed_list, seed_list) in open_seed_devices()
6791 if (!memcmp(fs_devices->fsid, fsid, BTRFS_FSID_SIZE)) in open_seed_devices()
6798 return ERR_PTR(-ENOENT); in open_seed_devices()
6804 fs_devices->seeding = true; in open_seed_devices()
6805 fs_devices->opened = 1; in open_seed_devices()
6811 * respective fs_devices and anchor it at fs_info->fs_devices->seed_list in open_seed_devices()
6817 ret = open_fs_devices(fs_devices, FMODE_READ, fs_info->bdev_holder); in open_seed_devices()
6823 if (!fs_devices->seeding) { in open_seed_devices()
6826 return ERR_PTR(-EINVAL); in open_seed_devices()
6829 list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list); in open_seed_devices()
6837 struct btrfs_fs_info *fs_info = leaf->fs_info; in read_one_dev()
6838 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in read_one_dev()
6851 if (memcmp(fs_uuid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE)) { in read_one_dev()
6857 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid, in read_one_dev()
6863 return -ENOENT; in read_one_dev()
6875 if (!device->bdev) { in read_one_dev()
6879 return -ENOENT; in read_one_dev()
6885 if (!device->bdev && in read_one_dev()
6886 !test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state)) { in read_one_dev()
6890 * device->bdev is NULL, and so we have to set in read_one_dev()
6891 * device->missing to one here in read_one_dev()
6893 device->fs_devices->missing_devices++; in read_one_dev()
6894 set_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); in read_one_dev()
6898 if (device->fs_devices != fs_devices) { in read_one_dev()
6900 &device->dev_state)); in read_one_dev()
6902 list_move(&device->dev_list, &fs_devices->devices); in read_one_dev()
6903 device->fs_devices->num_devices--; in read_one_dev()
6904 fs_devices->num_devices++; in read_one_dev()
6906 device->fs_devices->missing_devices--; in read_one_dev()
6907 fs_devices->missing_devices++; in read_one_dev()
6909 device->fs_devices = fs_devices; in read_one_dev()
6913 if (device->fs_devices != fs_info->fs_devices) { in read_one_dev()
6914 BUG_ON(test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)); in read_one_dev()
6915 if (device->generation != in read_one_dev()
6917 return -EINVAL; in read_one_dev()
6921 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); in read_one_dev()
6922 if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && in read_one_dev()
6923 !test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)) { in read_one_dev()
6924 device->fs_devices->total_rw_bytes += device->total_bytes; in read_one_dev()
6925 atomic64_add(device->total_bytes - device->bytes_used, in read_one_dev()
6926 &fs_info->free_chunk_space); in read_one_dev()
6934 struct btrfs_root *root = fs_info->tree_root; in btrfs_read_sys_array()
6935 struct btrfs_super_block *super_copy = fs_info->super_copy; in btrfs_read_sys_array()
6949 ASSERT(BTRFS_SUPER_INFO_SIZE <= fs_info->nodesize); in btrfs_read_sys_array()
6953 * overallocate but we can keep it as-is, only the first page is used. in btrfs_read_sys_array()
6959 btrfs_set_buffer_lockdep_class(root->root_key.objectid, sb, 0); in btrfs_read_sys_array()
6963 * pages up-to-date when the page is larger: extent does not cover the in btrfs_read_sys_array()
6965 * the page's extents up-to-date (the hole beyond sb), in btrfs_read_sys_array()
6973 SetPageUptodate(sb->pages[0]); in btrfs_read_sys_array()
6978 array_ptr = super_copy->sys_chunk_array; in btrfs_read_sys_array()
6998 ret = -EIO; in btrfs_read_sys_array()
7016 ret = -EIO; in btrfs_read_sys_array()
7025 ret = -EIO; in btrfs_read_sys_array()
7050 return -EIO; in btrfs_read_sys_array()
7054 * Check if all chunks in the fs are OK for read-write degraded mount
7064 struct extent_map_tree *map_tree = &fs_info->mapping_tree; in btrfs_check_rw_degradable()
7069 read_lock(&map_tree->lock); in btrfs_check_rw_degradable()
7070 em = lookup_extent_mapping(map_tree, 0, (u64)-1); in btrfs_check_rw_degradable()
7071 read_unlock(&map_tree->lock); in btrfs_check_rw_degradable()
7078 struct map_lookup *map; in btrfs_check_rw_degradable() local
7083 map = em->map_lookup; in btrfs_check_rw_degradable()
7086 map->type); in btrfs_check_rw_degradable()
7087 for (i = 0; i < map->num_stripes; i++) { in btrfs_check_rw_degradable()
7088 struct btrfs_device *dev = map->stripes[i].dev; in btrfs_check_rw_degradable()
7090 if (!dev || !dev->bdev || in btrfs_check_rw_degradable()
7091 test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state) || in btrfs_check_rw_degradable()
7092 dev->last_flush_error) in btrfs_check_rw_degradable()
7101 em->start, missing, max_tolerated); in btrfs_check_rw_degradable()
7109 read_lock(&map_tree->lock); in btrfs_check_rw_degradable()
7111 (u64)(-1) - next_start); in btrfs_check_rw_degradable()
7112 read_unlock(&map_tree->lock); in btrfs_check_rw_degradable()
7127 readahead_tree_block(node->fs_info, start); in readahead_tree_node_children()
7133 struct btrfs_root *root = fs_info->chunk_root; in btrfs_read_chunk_tree()
7134 struct btrfs_path *path; in btrfs_read_chunk_tree() local
7143 path = btrfs_alloc_path(); in btrfs_read_chunk_tree()
7144 if (!path) in btrfs_read_chunk_tree()
7145 return -ENOMEM; in btrfs_read_chunk_tree()
7155 * we execute this code path, but open_fs_devices failed to clear in btrfs_read_chunk_tree()
7159 fs_info->fs_devices->total_rw_bytes = 0; in btrfs_read_chunk_tree()
7165 * item - BTRFS_FIRST_CHUNK_TREE_OBJECTID). in btrfs_read_chunk_tree()
7170 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); in btrfs_read_chunk_tree()
7176 leaf = path->nodes[0]; in btrfs_read_chunk_tree()
7177 slot = path->slots[0]; in btrfs_read_chunk_tree()
7179 ret = btrfs_next_leaf(root, path); in btrfs_read_chunk_tree()
7190 node = path->nodes[1]; in btrfs_read_chunk_tree()
7192 if (last_ra_node != node->start) { in btrfs_read_chunk_tree()
7194 last_ra_node = node->start; in btrfs_read_chunk_tree()
7209 mutex_lock(&fs_info->chunk_mutex); in btrfs_read_chunk_tree()
7211 mutex_unlock(&fs_info->chunk_mutex); in btrfs_read_chunk_tree()
7215 path->slots[0]++; in btrfs_read_chunk_tree()
7222 if (total_dev != fs_info->fs_devices->total_devices) { in btrfs_read_chunk_tree()
7225 btrfs_super_num_devices(fs_info->super_copy), in btrfs_read_chunk_tree()
7227 fs_info->fs_devices->total_devices = total_dev; in btrfs_read_chunk_tree()
7228 btrfs_set_super_num_devices(fs_info->super_copy, total_dev); in btrfs_read_chunk_tree()
7230 if (btrfs_super_total_bytes(fs_info->super_copy) < in btrfs_read_chunk_tree()
7231 fs_info->fs_devices->total_rw_bytes) { in btrfs_read_chunk_tree()
7234 btrfs_super_total_bytes(fs_info->super_copy), in btrfs_read_chunk_tree()
7235 fs_info->fs_devices->total_rw_bytes); in btrfs_read_chunk_tree()
7236 ret = -EINVAL; in btrfs_read_chunk_tree()
7243 btrfs_free_path(path); in btrfs_read_chunk_tree()
7249 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs; in btrfs_init_devices_late()
7252 fs_devices->fs_info = fs_info; in btrfs_init_devices_late()
7254 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_devices_late()
7255 list_for_each_entry(device, &fs_devices->devices, dev_list) in btrfs_init_devices_late()
7256 device->fs_info = fs_info; in btrfs_init_devices_late()
7258 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_init_devices_late()
7259 list_for_each_entry(device, &seed_devs->devices, dev_list) in btrfs_init_devices_late()
7260 device->fs_info = fs_info; in btrfs_init_devices_late()
7262 seed_devs->fs_info = fs_info; in btrfs_init_devices_late()
7264 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_devices_late()
7291 struct btrfs_path *path) in btrfs_device_init_dev_stats() argument
7301 key.offset = device->devid; in btrfs_device_init_dev_stats()
7302 ret = btrfs_search_slot(NULL, device->fs_info->dev_root, &key, path, 0, 0); in btrfs_device_init_dev_stats()
7306 device->dev_stats_valid = 1; in btrfs_device_init_dev_stats()
7307 btrfs_release_path(path); in btrfs_device_init_dev_stats()
7310 slot = path->slots[0]; in btrfs_device_init_dev_stats()
7311 eb = path->nodes[0]; in btrfs_device_init_dev_stats()
7324 device->dev_stats_valid = 1; in btrfs_device_init_dev_stats()
7326 btrfs_release_path(path); in btrfs_device_init_dev_stats()
7333 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs; in btrfs_init_dev_stats()
7335 struct btrfs_path *path = NULL; in btrfs_init_dev_stats() local
7338 path = btrfs_alloc_path(); in btrfs_init_dev_stats()
7339 if (!path) in btrfs_init_dev_stats()
7340 return -ENOMEM; in btrfs_init_dev_stats()
7342 mutex_lock(&fs_devices->device_list_mutex); in btrfs_init_dev_stats()
7343 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_init_dev_stats()
7344 ret = btrfs_device_init_dev_stats(device, path); in btrfs_init_dev_stats()
7348 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) { in btrfs_init_dev_stats()
7349 list_for_each_entry(device, &seed_devs->devices, dev_list) { in btrfs_init_dev_stats()
7350 ret = btrfs_device_init_dev_stats(device, path); in btrfs_init_dev_stats()
7356 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_init_dev_stats()
7358 btrfs_free_path(path); in btrfs_init_dev_stats()
7365 struct btrfs_fs_info *fs_info = trans->fs_info; in update_dev_stat_item()
7366 struct btrfs_root *dev_root = fs_info->dev_root; in update_dev_stat_item()
7367 struct btrfs_path *path; in update_dev_stat_item() local
7376 key.offset = device->devid; in update_dev_stat_item()
7378 path = btrfs_alloc_path(); in update_dev_stat_item()
7379 if (!path) in update_dev_stat_item()
7380 return -ENOMEM; in update_dev_stat_item()
7381 ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1); in update_dev_stat_item()
7385 ret, rcu_str_deref(device->name)); in update_dev_stat_item()
7390 btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) { in update_dev_stat_item()
7392 ret = btrfs_del_item(trans, dev_root, path); in update_dev_stat_item()
7396 rcu_str_deref(device->name), ret); in update_dev_stat_item()
7404 btrfs_release_path(path); in update_dev_stat_item()
7405 ret = btrfs_insert_empty_item(trans, dev_root, path, in update_dev_stat_item()
7410 rcu_str_deref(device->name), ret); in update_dev_stat_item()
7415 eb = path->nodes[0]; in update_dev_stat_item()
7416 ptr = btrfs_item_ptr(eb, path->slots[0], struct btrfs_dev_stats_item); in update_dev_stat_item()
7423 btrfs_free_path(path); in update_dev_stat_item()
7432 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_run_dev_stats()
7433 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_run_dev_stats()
7438 mutex_lock(&fs_devices->device_list_mutex); in btrfs_run_dev_stats()
7439 list_for_each_entry(device, &fs_devices->devices, dev_list) { in btrfs_run_dev_stats()
7440 stats_cnt = atomic_read(&device->dev_stats_ccnt); in btrfs_run_dev_stats()
7441 if (!device->dev_stats_valid || stats_cnt == 0) in btrfs_run_dev_stats()
7446 * There is a LOAD-LOAD control dependency between the value of in btrfs_run_dev_stats()
7447 * dev_stats_ccnt and updating the on-disk values which requires in btrfs_run_dev_stats()
7448 * reading the in-memory counters. Such control dependencies in btrfs_run_dev_stats()
7460 atomic_sub(stats_cnt, &device->dev_stats_ccnt); in btrfs_run_dev_stats()
7462 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_run_dev_stats()
7475 if (!dev->dev_stats_valid) in btrfs_dev_stat_print_on_error()
7477 btrfs_err_rl_in_rcu(dev->fs_info, in btrfs_dev_stat_print_on_error()
7479 rcu_str_deref(dev->name), in btrfs_dev_stat_print_on_error()
7497 btrfs_info_in_rcu(dev->fs_info, in btrfs_dev_stat_print_on_load()
7499 rcu_str_deref(dev->name), in btrfs_dev_stat_print_on_load()
7511 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; in btrfs_get_dev_stats()
7514 mutex_lock(&fs_devices->device_list_mutex); in btrfs_get_dev_stats()
7515 dev = btrfs_find_device(fs_info->fs_devices, stats->devid, NULL, NULL, in btrfs_get_dev_stats()
7517 mutex_unlock(&fs_devices->device_list_mutex); in btrfs_get_dev_stats()
7521 return -ENODEV; in btrfs_get_dev_stats()
7522 } else if (!dev->dev_stats_valid) { in btrfs_get_dev_stats()
7524 return -ENODEV; in btrfs_get_dev_stats()
7525 } else if (stats->flags & BTRFS_DEV_STATS_RESET) { in btrfs_get_dev_stats()
7527 if (stats->nr_items > i) in btrfs_get_dev_stats()
7528 stats->values[i] = in btrfs_get_dev_stats()
7534 current->comm, task_pid_nr(current)); in btrfs_get_dev_stats()
7537 if (stats->nr_items > i) in btrfs_get_dev_stats()
7538 stats->values[i] = btrfs_dev_stat_read(dev, i); in btrfs_get_dev_stats()
7540 if (stats->nr_items > BTRFS_DEV_STAT_VALUES_MAX) in btrfs_get_dev_stats()
7541 stats->nr_items = BTRFS_DEV_STAT_VALUES_MAX; in btrfs_get_dev_stats()
7556 ASSERT(trans->state == TRANS_STATE_COMMIT_DOING); in btrfs_commit_device_sizes()
7558 if (list_empty(&trans->dev_update_list)) in btrfs_commit_device_sizes()
7566 mutex_lock(&trans->fs_info->chunk_mutex); in btrfs_commit_device_sizes()
7567 list_for_each_entry_safe(curr, next, &trans->dev_update_list, in btrfs_commit_device_sizes()
7569 list_del_init(&curr->post_commit_list); in btrfs_commit_device_sizes()
7570 curr->commit_total_bytes = curr->disk_total_bytes; in btrfs_commit_device_sizes()
7571 curr->commit_bytes_used = curr->bytes_used; in btrfs_commit_device_sizes()
7573 mutex_unlock(&trans->fs_info->chunk_mutex); in btrfs_commit_device_sizes()
7577 * Multiplicity factor for simple profiles: DUP, RAID1-like and RAID10.
7592 struct extent_map_tree *em_tree = &fs_info->mapping_tree; in verify_one_dev_extent()
7594 struct map_lookup *map; in verify_one_dev_extent() local
7601 read_lock(&em_tree->lock); in verify_one_dev_extent()
7603 read_unlock(&em_tree->lock); in verify_one_dev_extent()
7609 ret = -EUCLEAN; in verify_one_dev_extent()
7613 map = em->map_lookup; in verify_one_dev_extent()
7614 stripe_len = calc_stripe_length(map->type, em->len, map->num_stripes); in verify_one_dev_extent()
7618 physical_offset, devid, em->start, physical_len, in verify_one_dev_extent()
7620 ret = -EUCLEAN; in verify_one_dev_extent()
7624 for (i = 0; i < map->num_stripes; i++) { in verify_one_dev_extent()
7625 if (map->stripes[i].dev->devid == devid && in verify_one_dev_extent()
7626 map->stripes[i].physical == physical_offset) { in verify_one_dev_extent()
7628 if (map->verified_stripes >= map->num_stripes) { in verify_one_dev_extent()
7631 em->start); in verify_one_dev_extent()
7632 ret = -EUCLEAN; in verify_one_dev_extent()
7635 map->verified_stripes++; in verify_one_dev_extent()
7643 ret = -EUCLEAN; in verify_one_dev_extent()
7647 dev = btrfs_find_device(fs_info->fs_devices, devid, NULL, NULL, true); in verify_one_dev_extent()
7650 ret = -EUCLEAN; in verify_one_dev_extent()
7655 if (dev->disk_total_bytes == 0) { in verify_one_dev_extent()
7658 devs = list_first_entry(&fs_info->fs_devices->seed_list, in verify_one_dev_extent()
7664 ret = -EUCLEAN; in verify_one_dev_extent()
7669 if (physical_offset + physical_len > dev->disk_total_bytes) { in verify_one_dev_extent()
7673 dev->disk_total_bytes); in verify_one_dev_extent()
7674 ret = -EUCLEAN; in verify_one_dev_extent()
7684 struct extent_map_tree *em_tree = &fs_info->mapping_tree; in verify_chunk_dev_extent_mapping()
7689 read_lock(&em_tree->lock); in verify_chunk_dev_extent_mapping()
7690 for (node = rb_first_cached(&em_tree->map); node; node = rb_next(node)) { in verify_chunk_dev_extent_mapping()
7692 if (em->map_lookup->num_stripes != in verify_chunk_dev_extent_mapping()
7693 em->map_lookup->verified_stripes) { in verify_chunk_dev_extent_mapping()
7696 em->start, em->map_lookup->verified_stripes, in verify_chunk_dev_extent_mapping()
7697 em->map_lookup->num_stripes); in verify_chunk_dev_extent_mapping()
7698 ret = -EUCLEAN; in verify_chunk_dev_extent_mapping()
7703 read_unlock(&em_tree->lock); in verify_chunk_dev_extent_mapping()
7716 struct btrfs_path *path; in btrfs_verify_dev_extents() local
7717 struct btrfs_root *root = fs_info->dev_root; in btrfs_verify_dev_extents()
7727 path = btrfs_alloc_path(); in btrfs_verify_dev_extents()
7728 if (!path) in btrfs_verify_dev_extents()
7729 return -ENOMEM; in btrfs_verify_dev_extents()
7731 path->reada = READA_FORWARD; in btrfs_verify_dev_extents()
7732 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); in btrfs_verify_dev_extents()
7736 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) { in btrfs_verify_dev_extents()
7737 ret = btrfs_next_item(root, path); in btrfs_verify_dev_extents()
7742 ret = -EUCLEAN; in btrfs_verify_dev_extents()
7747 struct extent_buffer *leaf = path->nodes[0]; in btrfs_verify_dev_extents()
7749 int slot = path->slots[0]; in btrfs_verify_dev_extents()
7770 ret = -EUCLEAN; in btrfs_verify_dev_extents()
7781 ret = btrfs_next_item(root, path); in btrfs_verify_dev_extents()
7793 btrfs_free_path(path); in btrfs_verify_dev_extents()
7806 spin_lock(&fs_info->swapfile_pins_lock); in btrfs_pinned_by_swapfile()
7807 node = fs_info->swapfile_pins.rb_node; in btrfs_pinned_by_swapfile()
7810 if (ptr < sp->ptr) in btrfs_pinned_by_swapfile()
7811 node = node->rb_left; in btrfs_pinned_by_swapfile()
7812 else if (ptr > sp->ptr) in btrfs_pinned_by_swapfile()
7813 node = node->rb_right; in btrfs_pinned_by_swapfile()
7817 spin_unlock(&fs_info->swapfile_pins_lock); in btrfs_pinned_by_swapfile()