Lines Matching refs:fs_devices
261 * protects the fs_uuids list that tracks all per-fs fs_devices, resulting from
267 * protects: updates to fs_devices counters like missing devices, rw devices,
272 * does not protect: manipulation of the fs_devices::devices list in general
278 * fs_devices::device_list_mutex (per-fs, with RCU)
280 * protects updates to fs_devices::devices, ie. adding and deleting
361 * @fsid: if not NULL, copy the UUID to fs_devices::fsid
362 * @metadata_fsid: if not NULL, copy the UUID to fs_devices::metadata_fsid
404 static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
408 WARN_ON(fs_devices->opened);
409 while (!list_empty(&fs_devices->devices)) {
410 device = list_entry(fs_devices->devices.next,
415 kfree(fs_devices);
420 struct btrfs_fs_devices *fs_devices;
423 fs_devices = list_entry(fs_uuids.next,
425 list_del(&fs_devices->fs_list);
426 free_fs_devices(fs_devices);
430 static bool match_fsid_fs_devices(const struct btrfs_fs_devices *fs_devices,
433 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) != 0)
439 if (memcmp(metadata_fsid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE) != 0)
448 struct btrfs_fs_devices *fs_devices;
453 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
454 if (match_fsid_fs_devices(fs_devices, fsid, metadata_fsid))
455 return fs_devices;
462 * fs_devices. Then check if the given fsid is the same as the metadata_uuid
463 * in the fs_devices. If it is, return true; otherwise, return false.
465 static inline bool check_fsid_changed(const struct btrfs_fs_devices *fs_devices,
468 return memcmp(fs_devices->fsid, fs_devices->metadata_uuid,
470 memcmp(fs_devices->metadata_uuid, fsid, BTRFS_FSID_SIZE) == 0;
477 struct btrfs_fs_devices *fs_devices;
481 * belonging to a fs_devices that was created by first scanning
485 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
486 if (!fs_devices->fsid_change)
489 if (match_fsid_fs_devices(fs_devices, disk_super->metadata_uuid,
490 fs_devices->fsid))
491 return fs_devices;
496 * belonging to a fs_devices that was created by a device that
500 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
501 if (!fs_devices->fsid_change)
504 if (check_fsid_changed(fs_devices, disk_super->metadata_uuid))
505 return fs_devices;
563 struct btrfs_fs_devices *fs_devices, *tmp_fs_devices;
572 list_for_each_entry_safe(fs_devices, tmp_fs_devices, &fs_uuids, fs_list) {
574 mutex_lock(&fs_devices->device_list_mutex);
576 &fs_devices->devices, dev_list) {
581 if (fs_devices->opened) {
589 fs_devices->num_devices--;
595 mutex_unlock(&fs_devices->device_list_mutex);
597 if (fs_devices->num_devices == 0) {
598 btrfs_sysfs_remove_fsid(fs_devices);
599 list_del(&fs_devices->fs_list);
600 free_fs_devices(fs_devices);
609 * messing with our fs_devices by the uuid_mutex, thus we do not need the
610 * fs_devices->device_list_mutex here.
612 static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,
649 fs_devices->seeding = true;
658 fs_devices->rotating = true;
661 fs_devices->discardable = true;
667 fs_devices->open_devices++;
670 fs_devices->rw_devices++;
671 list_add_tail(&device->dev_alloc_list, &fs_devices->alloc_list);
693 * Handle scanned device having its CHANGING_FSID_V2 flag set and the fs_devices
701 struct btrfs_fs_devices *fs_devices;
703 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
704 if (fs_devices->fsid_change)
707 if (check_fsid_changed(fs_devices, disk_super->fsid))
708 return fs_devices;
717 struct btrfs_fs_devices *fs_devices;
728 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
730 if (check_fsid_changed(fs_devices, disk_super->metadata_uuid) &&
731 memcmp(fs_devices->fsid, disk_super->fsid,
733 return fs_devices;
736 if (memcmp(fs_devices->metadata_uuid, fs_devices->fsid,
738 memcmp(fs_devices->fsid, disk_super->metadata_uuid,
740 return fs_devices;
749 struct btrfs_fs_devices *fs_devices;
754 * time fs_devices was first created by another constituent device
758 * fs_devices equal to the FSID of the disk.
760 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
761 if (!fs_devices->fsid_change)
764 if (check_fsid_changed(fs_devices, disk_super->fsid))
765 return fs_devices;
782 struct btrfs_fs_devices *fs_devices = NULL;
802 fs_devices = find_fsid_inprogress(disk_super);
804 fs_devices = find_fsid_changed(disk_super);
806 fs_devices = find_fsid_with_metadata_uuid(disk_super);
808 fs_devices = find_fsid_reverted_metadata(disk_super);
809 if (!fs_devices)
810 fs_devices = find_fsid(disk_super->fsid, NULL);
814 if (!fs_devices) {
815 fs_devices = alloc_fs_devices(disk_super->fsid,
817 if (IS_ERR(fs_devices))
818 return ERR_CAST(fs_devices);
820 fs_devices->fsid_change = fsid_change_in_progress;
822 mutex_lock(&fs_devices->device_list_mutex);
823 list_add(&fs_devices->fs_list, &fs_uuids);
832 mutex_lock(&fs_devices->device_list_mutex);
833 device = btrfs_find_device(fs_devices, &args);
838 * metadata_uuid/fsid values of the fs_devices.
840 if (fs_devices->fsid_change &&
841 found_transid > fs_devices->latest_generation) {
842 memcpy(fs_devices->fsid, disk_super->fsid,
844 memcpy(fs_devices->metadata_uuid,
846 fs_devices->fsid_change = false;
853 if (fs_devices->opened) {
856 path, fs_devices->fsid, current->comm,
858 mutex_unlock(&fs_devices->device_list_mutex);
867 mutex_unlock(&fs_devices->device_list_mutex);
868 /* we can safely leave the fs_devices entry around */
874 list_add_rcu(&device->dev_list, &fs_devices->devices);
875 fs_devices->num_devices++;
877 device->fs_devices = fs_devices;
918 if (!fs_devices->opened && found_transid < device->generation) {
926 mutex_unlock(&fs_devices->device_list_mutex);
944 mutex_unlock(&fs_devices->device_list_mutex);
961 mutex_unlock(&fs_devices->device_list_mutex);
967 fs_devices->missing_devices--;
979 if (!fs_devices->opened) {
981 fs_devices->latest_generation = max_t(u64, found_transid,
982 fs_devices->latest_generation);
985 fs_devices->total_devices = btrfs_super_num_devices(disk_super);
987 mutex_unlock(&fs_devices->device_list_mutex);
993 struct btrfs_fs_devices *fs_devices;
1000 fs_devices = alloc_fs_devices(orig->fsid, NULL);
1001 if (IS_ERR(fs_devices))
1002 return fs_devices;
1004 fs_devices->total_devices = orig->total_devices;
1035 list_add(&device->dev_list, &fs_devices->devices);
1036 device->fs_devices = fs_devices;
1037 fs_devices->num_devices++;
1039 return fs_devices;
1041 free_fs_devices(fs_devices);
1045 static void __btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices,
1051 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
1074 fs_devices->open_devices--;
1079 fs_devices->rw_devices--;
1082 fs_devices->num_devices--;
1092 void btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices)
1098 __btrfs_free_extra_devids(fs_devices, &latest_dev);
1100 list_for_each_entry(seed_dev, &fs_devices->seed_list, seed_list)
1103 fs_devices->latest_dev = latest_dev;
1123 struct btrfs_fs_devices *fs_devices = device->fs_devices;
1128 fs_devices->rw_devices--;
1136 fs_devices->missing_devices--;
1141 fs_devices->open_devices--;
1171 static void close_fs_devices(struct btrfs_fs_devices *fs_devices)
1177 if (--fs_devices->opened > 0)
1180 list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list)
1183 WARN_ON(fs_devices->open_devices);
1184 WARN_ON(fs_devices->rw_devices);
1185 fs_devices->opened = 0;
1186 fs_devices->seeding = false;
1187 fs_devices->fs_info = NULL;
1190 void btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
1196 close_fs_devices(fs_devices);
1197 if (!fs_devices->opened) {
1198 list_splice_init(&fs_devices->seed_list, &list);
1206 if (fs_devices->num_devices == 1) {
1207 list_del(&fs_devices->fs_list);
1208 free_fs_devices(fs_devices);
1213 list_for_each_entry_safe(fs_devices, tmp, &list, seed_list) {
1214 close_fs_devices(fs_devices);
1215 list_del(&fs_devices->seed_list);
1216 free_fs_devices(fs_devices);
1221 static int open_fs_devices(struct btrfs_fs_devices *fs_devices,
1228 list_for_each_entry_safe(device, tmp_device, &fs_devices->devices,
1232 ret = btrfs_open_one_device(fs_devices, device, flags, holder);
1237 fs_devices->num_devices--;
1242 if (fs_devices->open_devices == 0)
1245 fs_devices->opened = 1;
1246 fs_devices->latest_dev = latest_dev;
1247 fs_devices->total_rw_bytes = 0;
1248 fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_REGULAR;
1249 fs_devices->read_policy = BTRFS_READ_POLICY_PID;
1269 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
1283 if (fs_devices->opened) {
1284 fs_devices->opened++;
1287 list_sort(NULL, &fs_devices->devices, devid_cmp);
1288 ret = open_fs_devices(fs_devices, flags, holder);
1445 switch (device->fs_devices->chunk_alloc_policy) {
1534 switch (device->fs_devices->chunk_alloc_policy) {
1895 write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid,
2013 next_device = btrfs_find_next_active_device(fs_info->fs_devices,
2021 if (fs_info->fs_devices->latest_dev->bdev == device->bdev)
2022 fs_info->fs_devices->latest_dev = next_device;
2031 u64 num_devices = fs_info->fs_devices->num_devices;
2095 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2105 * The device list in fs_devices is accessed without locks (neither
2115 device = btrfs_find_device(fs_info->fs_devices, args);
2135 fs_info->fs_devices->rw_devices == 1)
2141 device->fs_devices->rw_devices--;
2180 * In normal cases the cur_devices == fs_devices. But in case
2182 * its own fs_devices listed under the fs_devices->seed_list.
2184 cur_devices = device->fs_devices;
2185 mutex_lock(&fs_devices->device_list_mutex);
2190 /* Update total_devices of the parent fs_devices if it's seed */
2191 if (cur_devices != fs_devices)
2192 fs_devices->total_devices--;
2207 mutex_unlock(&fs_devices->device_list_mutex);
2238 * remove it from our list and free the fs_devices.
2255 &fs_devices->alloc_list);
2256 device->fs_devices->rw_devices++;
2264 struct btrfs_fs_devices *fs_devices;
2266 lockdep_assert_held(&srcdev->fs_info->fs_devices->device_list_mutex);
2269 * in case of fs with no seed, srcdev->fs_devices will point
2270 * to fs_devices of fs_info. However when the dev being replaced is
2271 * a seed dev it will point to the seed's local fs_devices. In short
2272 * srcdev will have its correct fs_devices in both the cases.
2274 fs_devices = srcdev->fs_devices;
2278 fs_devices->num_devices--;
2280 fs_devices->missing_devices--;
2283 fs_devices->rw_devices--;
2286 fs_devices->open_devices--;
2291 struct btrfs_fs_devices *fs_devices = srcdev->fs_devices;
2299 /* if this is no devs we rather delete the fs_devices */
2300 if (!fs_devices->num_devices) {
2307 ASSERT(fs_devices->seeding);
2309 list_del_init(&fs_devices->seed_list);
2310 close_fs_devices(fs_devices);
2311 free_fs_devices(fs_devices);
2318 struct btrfs_fs_devices *fs_devices = tgtdev->fs_info->fs_devices;
2320 mutex_lock(&fs_devices->device_list_mutex);
2325 fs_devices->open_devices--;
2327 fs_devices->num_devices--;
2333 mutex_unlock(&fs_devices->device_list_mutex);
2424 device = btrfs_find_device(fs_info->fs_devices, &args);
2433 device = btrfs_find_device(fs_info->fs_devices, &args);
2442 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2447 if (!fs_devices->seeding)
2452 * fs_info->fs_devices->seed_list
2459 * It's necessary to retain a copy of the original seed fs_devices in
2464 old_devices = clone_fs_devices(fs_devices);
2472 memcpy(seed_devices, fs_devices, sizeof(*seed_devices));
2482 * Splice seed devices into the sprout fs_devices.
2488 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2511 lockdep_assert_held(&fs_devices->device_list_mutex);
2513 list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
2516 device->fs_devices = seed_devices;
2518 fs_devices->seeding = false;
2519 fs_devices->num_devices = 0;
2520 fs_devices->open_devices = 0;
2521 fs_devices->missing_devices = 0;
2522 fs_devices->rotating = false;
2523 list_add(&seed_devices->seed_list, &fs_devices->seed_list);
2525 generate_random_uuid(fs_devices->fsid);
2526 memcpy(fs_devices->metadata_uuid, fs_devices->fsid, BTRFS_FSID_SIZE);
2527 memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
2594 device = btrfs_find_device(fs_info->fs_devices, &args);
2597 if (device->fs_devices->seeding) {
2619 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2627 if (sb_rdonly(sb) && !fs_devices->seeding)
2640 if (fs_devices->seeding) {
2650 list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {
2661 /* we can safely leave the fs_devices entry around */
2709 mutex_lock(&fs_devices->device_list_mutex);
2712 btrfs_assign_next_active_device(fs_info->fs_devices->latest_dev,
2716 device->fs_devices = fs_devices;
2719 list_add_rcu(&device->dev_list, &fs_devices->devices);
2720 list_add(&device->dev_alloc_list, &fs_devices->alloc_list);
2721 fs_devices->num_devices++;
2722 fs_devices->open_devices++;
2723 fs_devices->rw_devices++;
2724 fs_devices->total_devices++;
2725 fs_devices->total_rw_bytes += device->total_bytes;
2730 fs_devices->rotating = true;
2752 mutex_unlock(&fs_devices->device_list_mutex);
2778 * fs_devices now represents the newly sprouted filesystem and
2781 btrfs_sysfs_update_sprout_fsid(fs_devices);
2811 * other fs_devices list if device_path alienates any other scanned
2825 mutex_lock(&fs_info->fs_devices->device_list_mutex);
2829 fs_info->fs_devices->num_devices--;
2830 fs_info->fs_devices->open_devices--;
2831 fs_info->fs_devices->rw_devices--;
2832 fs_info->fs_devices->total_devices--;
2833 fs_info->fs_devices->total_rw_bytes -= device->total_bytes;
2840 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
2931 device->fs_devices->total_rw_bytes += diff;
3096 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
3120 mutex_lock(&fs_devices->device_list_mutex);
3127 mutex_unlock(&fs_devices->device_list_mutex);
3141 mutex_unlock(&fs_devices->device_list_mutex);
4297 num_devices = fs_info->fs_devices->rw_devices;
4866 device->fs_devices->total_rw_bytes -= diff;
5003 device->fs_devices->total_rw_bytes += diff;
5104 struct btrfs_fs_devices *fs_devices,
5109 space_info = btrfs_find_space_info(fs_devices->fs_info, ctl->type);
5119 ctl->max_chunk_size = min(mult_perc(fs_devices->total_rw_bytes, 10),
5125 struct btrfs_fs_devices *fs_devices,
5128 u64 zone_size = fs_devices->fs_info->zone_size;
5150 limit = max(round_down(mult_perc(fs_devices->total_rw_bytes, 10),
5157 static void init_alloc_chunk_ctl(struct btrfs_fs_devices *fs_devices,
5166 ctl->devs_max = BTRFS_MAX_DEVS(fs_devices->fs_info);
5173 switch (fs_devices->chunk_alloc_policy) {
5175 init_alloc_chunk_ctl_policy_regular(fs_devices, ctl);
5178 init_alloc_chunk_ctl_policy_zoned(fs_devices, ctl);
5185 static int gather_device_info(struct btrfs_fs_devices *fs_devices,
5189 struct btrfs_fs_info *info = fs_devices->fs_info;
5202 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) {
5240 if (ndevs == fs_devices->rw_devices) {
5242 __func__, fs_devices->rw_devices);
5341 static int decide_stripe_size(struct btrfs_fs_devices *fs_devices,
5345 struct btrfs_fs_info *info = fs_devices->fs_info;
5365 switch (fs_devices->chunk_alloc_policy) {
5473 struct btrfs_fs_devices *fs_devices = info->fs_devices;
5486 if (list_empty(&fs_devices->alloc_list)) {
5500 init_alloc_chunk_ctl(fs_devices, &ctl);
5502 devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info),
5507 ret = gather_device_info(fs_devices, &ctl, devices_info);
5513 ret = decide_stripe_size(fs_devices, &ctl, devices_info);
5841 switch (fs_info->fs_devices->read_policy) {
5846 fs_info->fs_devices->read_policy);
5847 fs_info->fs_devices->read_policy = BTRFS_READ_POLICY_PID;
6504 const struct btrfs_fs_devices *fs_devices)
6508 if (memcmp(fs_devices->metadata_uuid, args->fsid, BTRFS_FSID_SIZE) == 0)
6531 * Find a device specified by @devid or @uuid in the list of @fs_devices, or
6537 struct btrfs_device *btrfs_find_device(const struct btrfs_fs_devices *fs_devices,
6543 if (dev_args_match_fs_devices(args, fs_devices)) {
6544 list_for_each_entry(device, &fs_devices->devices, dev_list) {
6550 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) {
6562 static struct btrfs_device *add_missing_dev(struct btrfs_fs_devices *fs_devices,
6581 list_add(&device->dev_list, &fs_devices->devices);
6582 device->fs_devices = fs_devices;
6583 fs_devices->num_devices++;
6586 fs_devices->missing_devices++;
6729 dev = add_missing_dev(fs_info->fs_devices, devid, uuid);
6834 map->stripes[i].dev = btrfs_find_device(fs_info->fs_devices, &args);
6888 struct btrfs_fs_devices *fs_devices;
6895 list_for_each_entry(fs_devices, &fs_info->fs_devices->seed_list, seed_list)
6896 if (!memcmp(fs_devices->fsid, fsid, BTRFS_FSID_SIZE))
6897 return fs_devices;
6900 fs_devices = find_fsid(fsid, NULL);
6901 if (!fs_devices) {
6905 fs_devices = alloc_fs_devices(fsid, NULL);
6906 if (IS_ERR(fs_devices))
6907 return fs_devices;
6909 fs_devices->seeding = true;
6910 fs_devices->opened = 1;
6911 return fs_devices;
6916 * respective fs_devices and anchor it at fs_info->fs_devices->seed_list
6918 fs_devices = clone_fs_devices(fs_devices);
6919 if (IS_ERR(fs_devices))
6920 return fs_devices;
6922 ret = open_fs_devices(fs_devices, BLK_OPEN_READ, fs_info->bdev_holder);
6924 free_fs_devices(fs_devices);
6928 if (!fs_devices->seeding) {
6929 close_fs_devices(fs_devices);
6930 free_fs_devices(fs_devices);
6934 list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list);
6936 return fs_devices;
6944 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
6960 if (memcmp(fs_uuid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE)) {
6961 fs_devices = open_seed_devices(fs_info, fs_uuid);
6962 if (IS_ERR(fs_devices))
6963 return PTR_ERR(fs_devices);
6966 device = btrfs_find_device(fs_info->fs_devices, &args);
6974 device = add_missing_dev(fs_devices, devid, dev_uuid);
7001 device->fs_devices->missing_devices++;
7005 /* Move the device to its own fs_devices */
7006 if (device->fs_devices != fs_devices) {
7010 list_move(&device->dev_list, &fs_devices->devices);
7011 device->fs_devices->num_devices--;
7012 fs_devices->num_devices++;
7014 device->fs_devices->missing_devices--;
7015 fs_devices->missing_devices++;
7017 device->fs_devices = fs_devices;
7021 if (device->fs_devices != fs_info->fs_devices) {
7042 device->fs_devices->total_rw_bytes += device->total_bytes;
7259 fs_info->fs_devices->total_rw_bytes = 0;
7330 if (total_dev != fs_info->fs_devices->total_devices) {
7335 fs_info->fs_devices->total_devices = total_dev;
7339 fs_info->fs_devices->total_rw_bytes) {
7341 "super_total_bytes %llu mismatch with fs_devices total_rw_bytes %llu",
7343 fs_info->fs_devices->total_rw_bytes);
7357 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;
7361 fs_devices->fs_info = fs_info;
7363 mutex_lock(&fs_devices->device_list_mutex);
7364 list_for_each_entry(device, &fs_devices->devices, dev_list)
7367 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) {
7377 mutex_unlock(&fs_devices->device_list_mutex);
7451 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;
7460 mutex_lock(&fs_devices->device_list_mutex);
7461 list_for_each_entry(device, &fs_devices->devices, dev_list) {
7466 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) {
7474 mutex_unlock(&fs_devices->device_list_mutex);
7551 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
7556 mutex_lock(&fs_devices->device_list_mutex);
7557 list_for_each_entry(device, &fs_devices->devices, dev_list) {
7580 mutex_unlock(&fs_devices->device_list_mutex);
7626 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
7629 mutex_lock(&fs_devices->device_list_mutex);
7631 dev = btrfs_find_device(fs_info->fs_devices, &args);
7632 mutex_unlock(&fs_devices->device_list_mutex);
7773 dev = btrfs_find_device(fs_info->fs_devices, &args);