Lines Matching refs:fs_devices
239 * protects the fs_uuids list that tracks all per-fs fs_devices, resulting from
245 * protects: updates to fs_devices counters like missing devices, rw devices,
250 * does not protect: manipulation of the fs_devices::devices list in general
256 * fs_devices::device_list_mutex (per-fs, with RCU)
258 * protects updates to fs_devices::devices, ie. adding and deleting
339 * @fsid: if not NULL, copy the UUID to fs_devices::fsid
340 * @metadata_fsid: if not NULL, copy the UUID to fs_devices::metadata_fsid
381 static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
385 WARN_ON(fs_devices->opened);
386 while (!list_empty(&fs_devices->devices)) {
387 device = list_entry(fs_devices->devices.next,
392 kfree(fs_devices);
397 struct btrfs_fs_devices *fs_devices;
400 fs_devices = list_entry(fs_uuids.next,
402 list_del(&fs_devices->fs_list);
403 free_fs_devices(fs_devices);
448 struct btrfs_fs_devices *fs_devices;
453 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
455 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0
456 && memcmp(metadata_fsid, fs_devices->metadata_uuid,
458 return fs_devices;
460 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0)
461 return fs_devices;
471 struct btrfs_fs_devices *fs_devices;
475 * belonging to a fs_devices that was created by first scanning
479 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
480 if (fs_devices->fsid_change &&
481 memcmp(disk_super->metadata_uuid, fs_devices->fsid,
483 memcmp(fs_devices->fsid, fs_devices->metadata_uuid,
485 return fs_devices;
490 * belonging to a fs_devices that was created by a device that
494 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
495 if (fs_devices->fsid_change &&
496 memcmp(fs_devices->metadata_uuid,
497 fs_devices->fsid, BTRFS_FSID_SIZE) != 0 &&
498 memcmp(disk_super->metadata_uuid, fs_devices->metadata_uuid,
500 return fs_devices;
601 struct btrfs_fs_devices *fs_devices, *tmp_fs_devices;
610 list_for_each_entry_safe(fs_devices, tmp_fs_devices, &fs_uuids, fs_list) {
612 mutex_lock(&fs_devices->device_list_mutex);
614 &fs_devices->devices, dev_list) {
619 if (fs_devices->opened) {
627 fs_devices->num_devices--;
633 mutex_unlock(&fs_devices->device_list_mutex);
635 if (fs_devices->num_devices == 0) {
636 btrfs_sysfs_remove_fsid(fs_devices);
637 list_del(&fs_devices->fs_list);
638 free_fs_devices(fs_devices);
647 * messing with our fs_devices by the uuid_mutex, thus we do not need the
648 * fs_devices->device_list_mutex here.
650 static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,
688 fs_devices->seeding = true;
698 fs_devices->rotating = true;
704 fs_devices->open_devices++;
707 fs_devices->rw_devices++;
708 list_add_tail(&device->dev_alloc_list, &fs_devices->alloc_list);
730 * Handle scanned device having its CHANGING_FSID_V2 flag set and the fs_devices
738 struct btrfs_fs_devices *fs_devices;
740 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
741 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid,
743 memcmp(fs_devices->metadata_uuid, disk_super->fsid,
744 BTRFS_FSID_SIZE) == 0 && !fs_devices->fsid_change) {
745 return fs_devices;
756 struct btrfs_fs_devices *fs_devices;
767 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
769 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid,
771 memcmp(fs_devices->metadata_uuid, disk_super->metadata_uuid,
773 memcmp(fs_devices->fsid, disk_super->fsid,
775 return fs_devices;
778 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid,
780 memcmp(fs_devices->fsid, disk_super->metadata_uuid,
782 return fs_devices;
791 struct btrfs_fs_devices *fs_devices;
796 * time * fs_devices was first created by another constitutent device
800 * fs_devices equal to the FSID of the disk.
802 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
803 if (memcmp(fs_devices->fsid, fs_devices->metadata_uuid,
805 memcmp(fs_devices->metadata_uuid, disk_super->fsid,
807 fs_devices->fsid_change)
808 return fs_devices;
825 struct btrfs_fs_devices *fs_devices = NULL;
836 fs_devices = find_fsid_inprogress(disk_super);
838 fs_devices = find_fsid_changed(disk_super);
840 fs_devices = find_fsid_with_metadata_uuid(disk_super);
842 fs_devices = find_fsid_reverted_metadata(disk_super);
843 if (!fs_devices)
844 fs_devices = find_fsid(disk_super->fsid, NULL);
848 if (!fs_devices) {
850 fs_devices = alloc_fs_devices(disk_super->fsid,
853 fs_devices = alloc_fs_devices(disk_super->fsid, NULL);
855 if (IS_ERR(fs_devices))
856 return ERR_CAST(fs_devices);
858 fs_devices->fsid_change = fsid_change_in_progress;
860 mutex_lock(&fs_devices->device_list_mutex);
861 list_add(&fs_devices->fs_list, &fs_uuids);
865 mutex_lock(&fs_devices->device_list_mutex);
866 device = btrfs_find_device(fs_devices, devid,
872 * metadata_uuid/fsid values of the fs_devices.
874 if (fs_devices->fsid_change &&
875 found_transid > fs_devices->latest_generation) {
876 memcpy(fs_devices->fsid, disk_super->fsid,
880 memcpy(fs_devices->metadata_uuid,
884 memcpy(fs_devices->metadata_uuid,
887 fs_devices->fsid_change = false;
892 if (fs_devices->opened) {
893 mutex_unlock(&fs_devices->device_list_mutex);
900 mutex_unlock(&fs_devices->device_list_mutex);
901 /* we can safely leave the fs_devices entry around */
908 mutex_unlock(&fs_devices->device_list_mutex);
913 list_add_rcu(&device->dev_list, &fs_devices->devices);
914 fs_devices->num_devices++;
916 device->fs_devices = fs_devices;
957 if (!fs_devices->opened && found_transid < device->generation) {
965 mutex_unlock(&fs_devices->device_list_mutex);
978 mutex_unlock(&fs_devices->device_list_mutex);
984 mutex_unlock(&fs_devices->device_list_mutex);
1008 mutex_unlock(&fs_devices->device_list_mutex);
1014 fs_devices->missing_devices--;
1025 if (!fs_devices->opened) {
1027 fs_devices->latest_generation = max_t(u64, found_transid,
1028 fs_devices->latest_generation);
1031 fs_devices->total_devices = btrfs_super_num_devices(disk_super);
1033 mutex_unlock(&fs_devices->device_list_mutex);
1039 struct btrfs_fs_devices *fs_devices;
1046 fs_devices = alloc_fs_devices(orig->fsid, NULL);
1047 if (IS_ERR(fs_devices))
1048 return fs_devices;
1050 fs_devices->total_devices = orig->total_devices;
1077 list_add(&device->dev_list, &fs_devices->devices);
1078 device->fs_devices = fs_devices;
1079 fs_devices->num_devices++;
1081 return fs_devices;
1083 free_fs_devices(fs_devices);
1087 static void __btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices,
1093 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
1116 fs_devices->open_devices--;
1121 fs_devices->rw_devices--;
1124 fs_devices->num_devices--;
1134 void btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices, int step)
1140 __btrfs_free_extra_devids(fs_devices, step, &latest_dev);
1142 list_for_each_entry(seed_dev, &fs_devices->seed_list, seed_list)
1145 fs_devices->latest_bdev = latest_dev->bdev;
1165 struct btrfs_fs_devices *fs_devices = device->fs_devices;
1170 fs_devices->rw_devices--;
1178 fs_devices->missing_devices--;
1183 fs_devices->open_devices--;
1213 static void close_fs_devices(struct btrfs_fs_devices *fs_devices)
1219 if (--fs_devices->opened > 0)
1222 list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list)
1225 WARN_ON(fs_devices->open_devices);
1226 WARN_ON(fs_devices->rw_devices);
1227 fs_devices->opened = 0;
1228 fs_devices->seeding = false;
1229 fs_devices->fs_info = NULL;
1232 void btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
1238 close_fs_devices(fs_devices);
1239 if (!fs_devices->opened) {
1240 list_splice_init(&fs_devices->seed_list, &list);
1248 if (fs_devices->num_devices == 1) {
1249 list_del(&fs_devices->fs_list);
1250 free_fs_devices(fs_devices);
1255 list_for_each_entry_safe(fs_devices, tmp, &list, seed_list) {
1256 close_fs_devices(fs_devices);
1257 list_del(&fs_devices->seed_list);
1258 free_fs_devices(fs_devices);
1263 static int open_fs_devices(struct btrfs_fs_devices *fs_devices,
1272 list_for_each_entry_safe(device, tmp_device, &fs_devices->devices,
1276 ret = btrfs_open_one_device(fs_devices, device, flags, holder);
1281 fs_devices->num_devices--;
1286 if (fs_devices->open_devices == 0)
1289 fs_devices->opened = 1;
1290 fs_devices->latest_bdev = latest_dev->bdev;
1291 fs_devices->total_rw_bytes = 0;
1292 fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_REGULAR;
1312 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
1326 if (fs_devices->opened) {
1327 fs_devices->opened++;
1330 list_sort(NULL, &fs_devices->devices, devid_cmp);
1331 ret = open_fs_devices(fs_devices, flags, holder);
1484 switch (device->fs_devices->chunk_alloc_policy) {
1525 switch (device->fs_devices->chunk_alloc_policy) {
1927 write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid,
2063 next_device = btrfs_find_next_active_device(fs_info->fs_devices,
2071 if (fs_info->fs_devices->latest_bdev == device->bdev)
2072 fs_info->fs_devices->latest_bdev = next_device->bdev;
2081 u64 num_devices = fs_info->fs_devices->num_devices;
2138 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2143 * The device list in fs_devices is accessed without locks (neither
2178 fs_info->fs_devices->rw_devices == 1) {
2186 device->fs_devices->rw_devices--;
2219 * In normal cases the cur_devices == fs_devices. But in case
2221 * its own fs_devices listed under the fs_devices->seed.
2223 cur_devices = device->fs_devices;
2224 mutex_lock(&fs_devices->device_list_mutex);
2229 /* Update total_devices of the parent fs_devices if it's seed */
2230 if (cur_devices != fs_devices)
2231 fs_devices->total_devices--;
2246 mutex_unlock(&fs_devices->device_list_mutex);
2275 &fs_devices->alloc_list);
2276 device->fs_devices->rw_devices++;
2284 struct btrfs_fs_devices *fs_devices;
2286 lockdep_assert_held(&srcdev->fs_info->fs_devices->device_list_mutex);
2289 * in case of fs with no seed, srcdev->fs_devices will point
2290 * to fs_devices of fs_info. However when the dev being replaced is
2291 * a seed dev it will point to the seed's local fs_devices. In short
2292 * srcdev will have its correct fs_devices in both the cases.
2294 fs_devices = srcdev->fs_devices;
2298 fs_devices->num_devices--;
2300 fs_devices->missing_devices--;
2303 fs_devices->rw_devices--;
2306 fs_devices->open_devices--;
2311 struct btrfs_fs_devices *fs_devices = srcdev->fs_devices;
2319 /* if this is no devs we rather delete the fs_devices */
2320 if (!fs_devices->num_devices) {
2327 ASSERT(fs_devices->seeding);
2329 list_del_init(&fs_devices->seed_list);
2330 close_fs_devices(fs_devices);
2331 free_fs_devices(fs_devices);
2338 struct btrfs_fs_devices *fs_devices = tgtdev->fs_info->fs_devices;
2340 mutex_lock(&fs_devices->device_list_mutex);
2345 fs_devices->open_devices--;
2347 fs_devices->num_devices--;
2353 mutex_unlock(&fs_devices->device_list_mutex);
2388 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid,
2391 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid,
2411 device = btrfs_find_device(fs_info->fs_devices, devid, NULL,
2423 list_for_each_entry(device, &fs_info->fs_devices->devices,
2440 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2448 if (!fs_devices->seeding)
2453 * fs_info->fs_devices->seed_list
2460 * It's necessary to retain a copy of the original seed fs_devices in
2465 old_devices = clone_fs_devices(fs_devices);
2473 memcpy(seed_devices, fs_devices, sizeof(*seed_devices));
2479 mutex_lock(&fs_devices->device_list_mutex);
2480 list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
2483 device->fs_devices = seed_devices;
2485 fs_devices->seeding = false;
2486 fs_devices->num_devices = 0;
2487 fs_devices->open_devices = 0;
2488 fs_devices->missing_devices = 0;
2489 fs_devices->rotating = false;
2490 list_add(&seed_devices->seed_list, &fs_devices->seed_list);
2492 generate_random_uuid(fs_devices->fsid);
2493 memcpy(fs_devices->metadata_uuid, fs_devices->fsid, BTRFS_FSID_SIZE);
2494 memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
2495 mutex_unlock(&fs_devices->device_list_mutex);
2560 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid,
2564 if (device->fs_devices->seeding) {
2588 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2595 if (sb_rdonly(sb) && !fs_devices->seeding)
2603 if (fs_devices->seeding) {
2613 list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {
2624 /* we can safely leave the fs_devices entry around */
2669 device->fs_devices = fs_devices;
2671 mutex_lock(&fs_devices->device_list_mutex);
2673 list_add_rcu(&device->dev_list, &fs_devices->devices);
2674 list_add(&device->dev_alloc_list, &fs_devices->alloc_list);
2675 fs_devices->num_devices++;
2676 fs_devices->open_devices++;
2677 fs_devices->rw_devices++;
2678 fs_devices->total_devices++;
2679 fs_devices->total_rw_bytes += device->total_bytes;
2684 fs_devices->rotating = true;
2706 mutex_unlock(&fs_devices->device_list_mutex);
2732 * fs_devices now represents the newly sprouted filesystem and
2735 btrfs_sysfs_update_sprout_fsid(fs_devices);
2765 * other fs_devices list if device_path alienates any other scanned
2779 mutex_lock(&fs_info->fs_devices->device_list_mutex);
2783 fs_info->fs_devices->num_devices--;
2784 fs_info->fs_devices->open_devices--;
2785 fs_info->fs_devices->rw_devices--;
2786 fs_info->fs_devices->total_devices--;
2787 fs_info->fs_devices->total_rw_bytes -= device->total_bytes;
2794 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
2882 device->fs_devices->total_rw_bytes += diff;
3021 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
3043 mutex_lock(&fs_devices->device_list_mutex);
3050 mutex_unlock(&fs_devices->device_list_mutex);
3066 mutex_unlock(&fs_devices->device_list_mutex);
3071 mutex_unlock(&fs_devices->device_list_mutex);
4134 num_devices = fs_info->fs_devices->rw_devices;
4704 device->fs_devices->total_rw_bytes -= diff;
4840 device->fs_devices->total_rw_bytes += diff;
4943 struct btrfs_fs_devices *fs_devices,
4953 if (fs_devices->total_rw_bytes > 50ULL * SZ_1G)
4968 ctl->max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),
4973 static void init_alloc_chunk_ctl(struct btrfs_fs_devices *fs_devices,
4982 ctl->devs_max = BTRFS_MAX_DEVS(fs_devices->fs_info);
4989 switch (fs_devices->chunk_alloc_policy) {
4991 init_alloc_chunk_ctl_policy_regular(fs_devices, ctl);
4998 static int gather_device_info(struct btrfs_fs_devices *fs_devices,
5002 struct btrfs_fs_info *info = fs_devices->fs_info;
5015 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) {
5053 if (ndevs == fs_devices->rw_devices) {
5055 __func__, fs_devices->rw_devices);
5119 static int decide_stripe_size(struct btrfs_fs_devices *fs_devices,
5123 struct btrfs_fs_info *info = fs_devices->fs_info;
5143 switch (fs_devices->chunk_alloc_policy) {
5248 struct btrfs_fs_devices *fs_devices = info->fs_devices;
5260 if (list_empty(&fs_devices->alloc_list)) {
5274 init_alloc_chunk_ctl(fs_devices, &ctl);
5276 devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info),
5281 ret = gather_device_info(fs_devices, &ctl, devices_info);
5285 ret = decide_stripe_size(fs_devices, &ctl, devices_info);
5342 mutex_lock(&fs_info->fs_devices->device_list_mutex);
5356 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
5370 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
6538 * Find a device specified by @devid or @uuid in the list of @fs_devices, or
6546 struct btrfs_device *btrfs_find_device(struct btrfs_fs_devices *fs_devices,
6553 if (!fsid || !memcmp(fs_devices->metadata_uuid, fsid, BTRFS_FSID_SIZE)) {
6554 list_for_each_entry(device, &fs_devices->devices, dev_list) {
6562 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) {
6578 static struct btrfs_device *add_missing_dev(struct btrfs_fs_devices *fs_devices,
6596 list_add(&device->dev_list, &fs_devices->devices);
6597 device->fs_devices = fs_devices;
6598 fs_devices->num_devices++;
6601 fs_devices->missing_devices++;
6754 map->stripes[i].dev = btrfs_find_device(fs_info->fs_devices,
6764 add_missing_dev(fs_info->fs_devices, devid,
6819 struct btrfs_fs_devices *fs_devices;
6826 list_for_each_entry(fs_devices, &fs_info->fs_devices->seed_list, seed_list)
6827 if (!memcmp(fs_devices->fsid, fsid, BTRFS_FSID_SIZE))
6828 return fs_devices;
6831 fs_devices = find_fsid(fsid, NULL);
6832 if (!fs_devices) {
6836 fs_devices = alloc_fs_devices(fsid, NULL);
6837 if (IS_ERR(fs_devices))
6838 return fs_devices;
6840 fs_devices->seeding = true;
6841 fs_devices->opened = 1;
6842 return fs_devices;
6847 * respective fs_devices and anchor it at fs_info->fs_devices->seed_list
6849 fs_devices = clone_fs_devices(fs_devices);
6850 if (IS_ERR(fs_devices))
6851 return fs_devices;
6853 ret = open_fs_devices(fs_devices, FMODE_READ, fs_info->bdev_holder);
6855 free_fs_devices(fs_devices);
6859 if (!fs_devices->seeding) {
6860 close_fs_devices(fs_devices);
6861 free_fs_devices(fs_devices);
6865 list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list);
6867 return fs_devices;
6874 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
6887 if (memcmp(fs_uuid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE)) {
6888 fs_devices = open_seed_devices(fs_info, fs_uuid);
6889 if (IS_ERR(fs_devices))
6890 return PTR_ERR(fs_devices);
6893 device = btrfs_find_device(fs_info->fs_devices, devid, dev_uuid,
6902 device = add_missing_dev(fs_devices, devid, dev_uuid);
6929 device->fs_devices->missing_devices++;
6933 /* Move the device to its own fs_devices */
6934 if (device->fs_devices != fs_devices) {
6938 list_move(&device->dev_list, &fs_devices->devices);
6939 device->fs_devices->num_devices--;
6940 fs_devices->num_devices++;
6942 device->fs_devices->missing_devices--;
6943 fs_devices->missing_devices++;
6945 device->fs_devices = fs_devices;
6949 if (device->fs_devices != fs_info->fs_devices) {
6960 device->fs_devices->total_rw_bytes += device->total_bytes;
7195 fs_info->fs_devices->total_rw_bytes = 0;
7258 if (total_dev != fs_info->fs_devices->total_devices) {
7263 fs_info->fs_devices->total_devices = total_dev;
7267 fs_info->fs_devices->total_rw_bytes) {
7269 "super_total_bytes %llu mismatch with fs_devices total_rw_bytes %llu",
7271 fs_info->fs_devices->total_rw_bytes);
7285 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;
7288 fs_devices->fs_info = fs_info;
7290 mutex_lock(&fs_devices->device_list_mutex);
7291 list_for_each_entry(device, &fs_devices->devices, dev_list)
7294 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) {
7300 mutex_unlock(&fs_devices->device_list_mutex);
7369 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;
7378 mutex_lock(&fs_devices->device_list_mutex);
7379 list_for_each_entry(device, &fs_devices->devices, dev_list) {
7384 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) {
7392 mutex_unlock(&fs_devices->device_list_mutex);
7469 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
7474 mutex_lock(&fs_devices->device_list_mutex);
7475 list_for_each_entry(device, &fs_devices->devices, dev_list) {
7498 mutex_unlock(&fs_devices->device_list_mutex);
7547 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
7550 mutex_lock(&fs_devices->device_list_mutex);
7551 dev = btrfs_find_device(fs_info->fs_devices, stats->devid, NULL, NULL,
7553 mutex_unlock(&fs_devices->device_list_mutex);
7683 dev = btrfs_find_device(fs_info->fs_devices, devid, NULL, NULL, true);
7694 devs = list_first_entry(&fs_info->fs_devices->seed_list,