Lines Matching defs:fs_devices
271 * protects the fs_uuids list that tracks all per-fs fs_devices, resulting from
277 * protects: updates to fs_devices counters like missing devices, rw devices,
282 * does not protect: manipulation of the fs_devices::devices list in general
288 * fs_devices::device_list_mutex (per-fs, with RCU)
290 * protects updates to fs_devices::devices, ie. adding and deleting
372 * @fsid: if not NULL, copy the UUID to fs_devices::fsid and to
373 * fs_devices::metadata_fsid
411 static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
415 WARN_ON(fs_devices->opened);
416 while (!list_empty(&fs_devices->devices)) {
417 device = list_entry(fs_devices->devices.next,
422 kfree(fs_devices);
427 struct btrfs_fs_devices *fs_devices;
430 fs_devices = list_entry(fs_uuids.next,
432 list_del(&fs_devices->fs_list);
433 free_fs_devices(fs_devices);
437 static bool match_fsid_fs_devices(const struct btrfs_fs_devices *fs_devices,
440 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) != 0)
446 if (memcmp(metadata_fsid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE) != 0)
455 struct btrfs_fs_devices *fs_devices;
460 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
461 if (match_fsid_fs_devices(fs_devices, fsid, metadata_fsid))
462 return fs_devices;
520 struct btrfs_fs_devices *fs_devices, *tmp_fs_devices;
529 list_for_each_entry_safe(fs_devices, tmp_fs_devices, &fs_uuids, fs_list) {
531 mutex_lock(&fs_devices->device_list_mutex);
533 &fs_devices->devices, dev_list) {
538 if (fs_devices->opened) {
545 fs_devices->num_devices--;
551 mutex_unlock(&fs_devices->device_list_mutex);
553 if (fs_devices->num_devices == 0) {
554 btrfs_sysfs_remove_fsid(fs_devices);
555 list_del(&fs_devices->fs_list);
556 free_fs_devices(fs_devices);
593 /* Try to find a fs_devices by matching devt. */
637 * messing with our fs_devices by the uuid_mutex, thus we do not need the
638 * fs_devices->device_list_mutex here.
640 static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,
677 fs_devices->seeding = true;
686 fs_devices->rotating = true;
689 fs_devices->discardable = true;
705 fs_devices->open_devices++;
708 fs_devices->rw_devices++;
709 list_add_tail(&device->dev_alloc_list, &fs_devices->alloc_list);
742 struct btrfs_fs_devices *fs_devices = NULL;
766 fs_devices = find_fsid_by_device(disk_super, path_devt, &same_fsid_diff_dev);
768 if (!fs_devices) {
769 fs_devices = alloc_fs_devices(disk_super->fsid);
770 if (IS_ERR(fs_devices))
771 return ERR_CAST(fs_devices);
774 memcpy(fs_devices->metadata_uuid,
778 generate_random_uuid(fs_devices->fsid);
779 fs_devices->temp_fsid = true;
782 fs_devices->fsid);
785 mutex_lock(&fs_devices->device_list_mutex);
786 list_add(&fs_devices->fs_list, &fs_uuids);
795 mutex_lock(&fs_devices->device_list_mutex);
796 device = btrfs_find_device(fs_devices, &args);
798 if (found_transid > fs_devices->latest_generation) {
799 memcpy(fs_devices->fsid, disk_super->fsid,
801 memcpy(fs_devices->metadata_uuid,
809 if (fs_devices->opened) {
813 fs_devices->fsid, current->comm,
815 mutex_unlock(&fs_devices->device_list_mutex);
824 mutex_unlock(&fs_devices->device_list_mutex);
825 /* we can safely leave the fs_devices entry around */
831 list_add_rcu(&device->dev_list, &fs_devices->devices);
832 fs_devices->num_devices++;
834 device->fs_devices = fs_devices;
877 if (!fs_devices->opened && found_transid < device->generation) {
885 mutex_unlock(&fs_devices->device_list_mutex);
903 mutex_unlock(&fs_devices->device_list_mutex);
920 mutex_unlock(&fs_devices->device_list_mutex);
926 fs_devices->missing_devices--;
938 if (!fs_devices->opened) {
940 fs_devices->latest_generation = max_t(u64, found_transid,
941 fs_devices->latest_generation);
944 fs_devices->total_devices = btrfs_super_num_devices(disk_super);
946 mutex_unlock(&fs_devices->device_list_mutex);
952 struct btrfs_fs_devices *fs_devices;
959 fs_devices = alloc_fs_devices(orig->fsid);
960 if (IS_ERR(fs_devices))
961 return fs_devices;
963 fs_devices->total_devices = orig->total_devices;
994 list_add(&device->dev_list, &fs_devices->devices);
995 device->fs_devices = fs_devices;
996 fs_devices->num_devices++;
998 return fs_devices;
1000 free_fs_devices(fs_devices);
1004 static void __btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices,
1010 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
1034 fs_devices->open_devices--;
1039 fs_devices->rw_devices--;
1042 fs_devices->num_devices--;
1052 void btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices)
1058 __btrfs_free_extra_devids(fs_devices, &latest_dev);
1060 list_for_each_entry(seed_dev, &fs_devices->seed_list, seed_list)
1063 fs_devices->latest_dev = latest_dev;
1083 struct btrfs_fs_devices *fs_devices = device->fs_devices;
1088 fs_devices->rw_devices--;
1096 fs_devices->missing_devices--;
1101 fs_devices->open_devices--;
1131 static void close_fs_devices(struct btrfs_fs_devices *fs_devices)
1137 if (--fs_devices->opened > 0)
1140 list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list)
1143 WARN_ON(fs_devices->open_devices);
1144 WARN_ON(fs_devices->rw_devices);
1145 fs_devices->opened = 0;
1146 fs_devices->seeding = false;
1147 fs_devices->fs_info = NULL;
1150 void btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
1156 close_fs_devices(fs_devices);
1157 if (!fs_devices->opened) {
1158 list_splice_init(&fs_devices->seed_list, &list);
1166 if (fs_devices->num_devices == 1) {
1167 list_del(&fs_devices->fs_list);
1168 free_fs_devices(fs_devices);
1173 list_for_each_entry_safe(fs_devices, tmp, &list, seed_list) {
1174 close_fs_devices(fs_devices);
1175 list_del(&fs_devices->seed_list);
1176 free_fs_devices(fs_devices);
1181 static int open_fs_devices(struct btrfs_fs_devices *fs_devices,
1189 list_for_each_entry_safe(device, tmp_device, &fs_devices->devices,
1193 ret2 = btrfs_open_one_device(fs_devices, device, flags, holder);
1198 fs_devices->num_devices--;
1206 if (fs_devices->open_devices == 0) {
1212 fs_devices->opened = 1;
1213 fs_devices->latest_dev = latest_dev;
1214 fs_devices->total_rw_bytes = 0;
1215 fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_REGULAR;
1216 fs_devices->read_policy = BTRFS_READ_POLICY_PID;
1236 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
1250 if (fs_devices->opened) {
1251 fs_devices->opened++;
1254 list_sort(NULL, &fs_devices->devices, devid_cmp);
1255 ret = open_fs_devices(fs_devices, flags, holder);
1327 struct btrfs_fs_devices *fs_devices;
1335 list_for_each_entry(fs_devices, &fs_uuids, fs_list) {
1338 mutex_lock(&fs_devices->device_list_mutex);
1340 if (!fs_devices->opened) {
1341 mutex_unlock(&fs_devices->device_list_mutex);
1345 list_for_each_entry(device, &fs_devices->devices, dev_list) {
1348 mutex_unlock(&fs_devices->device_list_mutex);
1354 mutex_unlock(&fs_devices->device_list_mutex);
1472 switch (device->fs_devices->chunk_alloc_policy) {
1561 switch (device->fs_devices->chunk_alloc_policy) {
1921 write_extent_buffer(leaf, trans->fs_info->fs_devices->metadata_uuid,
2039 next_device = btrfs_find_next_active_device(fs_info->fs_devices,
2047 if (fs_info->fs_devices->latest_dev->bdev == device->bdev)
2048 fs_info->fs_devices->latest_dev = next_device;
2057 u64 num_devices = fs_info->fs_devices->num_devices;
2120 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2130 * The device list in fs_devices is accessed without locks (neither
2140 device = btrfs_find_device(fs_info->fs_devices, args);
2160 fs_info->fs_devices->rw_devices == 1)
2166 device->fs_devices->rw_devices--;
2205 * In normal cases the cur_devices == fs_devices. But in case
2207 * its own fs_devices listed under the fs_devices->seed_list.
2209 cur_devices = device->fs_devices;
2210 mutex_lock(&fs_devices->device_list_mutex);
2215 /* Update total_devices of the parent fs_devices if it's seed */
2216 if (cur_devices != fs_devices)
2217 fs_devices->total_devices--;
2232 mutex_unlock(&fs_devices->device_list_mutex);
2261 * remove it from our list and free the fs_devices.
2278 &fs_devices->alloc_list);
2279 device->fs_devices->rw_devices++;
2287 struct btrfs_fs_devices *fs_devices;
2289 lockdep_assert_held(&srcdev->fs_info->fs_devices->device_list_mutex);
2292 * in case of fs with no seed, srcdev->fs_devices will point
2293 * to fs_devices of fs_info. However when the dev being replaced is
2294 * a seed dev it will point to the seed's local fs_devices. In short
2295 * srcdev will have its correct fs_devices in both the cases.
2297 fs_devices = srcdev->fs_devices;
2301 fs_devices->num_devices--;
2303 fs_devices->missing_devices--;
2306 fs_devices->rw_devices--;
2309 fs_devices->open_devices--;
2314 struct btrfs_fs_devices *fs_devices = srcdev->fs_devices;
2322 /* if this is no devs we rather delete the fs_devices */
2323 if (!fs_devices->num_devices) {
2330 ASSERT(fs_devices->seeding);
2332 list_del_init(&fs_devices->seed_list);
2333 close_fs_devices(fs_devices);
2334 free_fs_devices(fs_devices);
2341 struct btrfs_fs_devices *fs_devices = tgtdev->fs_info->fs_devices;
2343 mutex_lock(&fs_devices->device_list_mutex);
2348 fs_devices->open_devices--;
2350 fs_devices->num_devices--;
2356 mutex_unlock(&fs_devices->device_list_mutex);
2446 device = btrfs_find_device(fs_info->fs_devices, &args);
2455 device = btrfs_find_device(fs_info->fs_devices, &args);
2464 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2469 if (!fs_devices->seeding)
2474 * fs_info->fs_devices->seed_list
2481 * It's necessary to retain a copy of the original seed fs_devices in
2486 old_devices = clone_fs_devices(fs_devices);
2494 memcpy(seed_devices, fs_devices, sizeof(*seed_devices));
2504 * Splice seed devices into the sprout fs_devices.
2510 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2533 lockdep_assert_held(&fs_devices->device_list_mutex);
2535 list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
2538 device->fs_devices = seed_devices;
2540 fs_devices->seeding = false;
2541 fs_devices->num_devices = 0;
2542 fs_devices->open_devices = 0;
2543 fs_devices->missing_devices = 0;
2544 fs_devices->rotating = false;
2545 list_add(&seed_devices->seed_list, &fs_devices->seed_list);
2547 generate_random_uuid(fs_devices->fsid);
2548 memcpy(fs_devices->metadata_uuid, fs_devices->fsid, BTRFS_FSID_SIZE);
2549 memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
2616 device = btrfs_find_device(fs_info->fs_devices, &args);
2619 if (device->fs_devices->seeding) {
2641 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2649 if (sb_rdonly(sb) && !fs_devices->seeding)
2662 if (fs_devices->seeding) {
2672 list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {
2683 /* we can safely leave the fs_devices entry around */
2731 mutex_lock(&fs_devices->device_list_mutex);
2734 btrfs_assign_next_active_device(fs_info->fs_devices->latest_dev,
2738 device->fs_devices = fs_devices;
2741 list_add_rcu(&device->dev_list, &fs_devices->devices);
2742 list_add(&device->dev_alloc_list, &fs_devices->alloc_list);
2743 fs_devices->num_devices++;
2744 fs_devices->open_devices++;
2745 fs_devices->rw_devices++;
2746 fs_devices->total_devices++;
2747 fs_devices->total_rw_bytes += device->total_bytes;
2752 fs_devices->rotating = true;
2774 mutex_unlock(&fs_devices->device_list_mutex);
2800 * fs_devices now represents the newly sprouted filesystem and
2803 btrfs_sysfs_update_sprout_fsid(fs_devices);
2833 * other fs_devices list if device_path alienates any other scanned
2847 mutex_lock(&fs_info->fs_devices->device_list_mutex);
2851 fs_info->fs_devices->num_devices--;
2852 fs_info->fs_devices->open_devices--;
2853 fs_info->fs_devices->rw_devices--;
2854 fs_info->fs_devices->total_devices--;
2855 fs_info->fs_devices->total_rw_bytes -= device->total_bytes;
2862 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
2953 device->fs_devices->total_rw_bytes += diff;
3191 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
3214 mutex_lock(&fs_devices->device_list_mutex);
3221 mutex_unlock(&fs_devices->device_list_mutex);
3235 mutex_unlock(&fs_devices->device_list_mutex);
4439 num_devices = fs_info->fs_devices->rw_devices;
5009 device->fs_devices->total_rw_bytes -= diff;
5158 device->fs_devices->total_rw_bytes += diff;
5260 struct btrfs_fs_devices *fs_devices,
5265 space_info = btrfs_find_space_info(fs_devices->fs_info, ctl->type);
5275 ctl->max_chunk_size = min(mult_perc(fs_devices->total_rw_bytes, 10),
5281 struct btrfs_fs_devices *fs_devices,
5284 u64 zone_size = fs_devices->fs_info->zone_size;
5306 limit = max(round_down(mult_perc(fs_devices->total_rw_bytes, 10),
5313 static void init_alloc_chunk_ctl(struct btrfs_fs_devices *fs_devices,
5322 ctl->devs_max = BTRFS_MAX_DEVS(fs_devices->fs_info);
5329 switch (fs_devices->chunk_alloc_policy) {
5331 init_alloc_chunk_ctl_policy_regular(fs_devices, ctl);
5334 init_alloc_chunk_ctl_policy_zoned(fs_devices, ctl);
5341 static int gather_device_info(struct btrfs_fs_devices *fs_devices,
5345 struct btrfs_fs_info *info = fs_devices->fs_info;
5358 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) {
5396 if (ndevs == fs_devices->rw_devices) {
5398 __func__, fs_devices->rw_devices);
5497 static int decide_stripe_size(struct btrfs_fs_devices *fs_devices,
5501 struct btrfs_fs_info *info = fs_devices->fs_info;
5521 switch (fs_devices->chunk_alloc_policy) {
5704 struct btrfs_fs_devices *fs_devices = info->fs_devices;
5717 if (list_empty(&fs_devices->alloc_list)) {
5731 init_alloc_chunk_ctl(fs_devices, &ctl);
5733 devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info),
5738 ret = gather_device_info(fs_devices, &ctl, devices_info);
5744 ret = decide_stripe_size(fs_devices, &ctl, devices_info);
6048 const enum btrfs_read_policy policy = READ_ONCE(fs_info->fs_devices->read_policy);
6068 WRITE_ONCE(fs_info->fs_devices->read_policy, BTRFS_READ_POLICY_PID);
6824 const struct btrfs_fs_devices *fs_devices)
6828 if (memcmp(fs_devices->metadata_uuid, args->fsid, BTRFS_FSID_SIZE) == 0)
6851 * Find a device specified by @devid or @uuid in the list of @fs_devices, or
6857 struct btrfs_device *btrfs_find_device(const struct btrfs_fs_devices *fs_devices,
6863 if (dev_args_match_fs_devices(args, fs_devices)) {
6864 list_for_each_entry(device, &fs_devices->devices, dev_list) {
6870 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) {
6882 static struct btrfs_device *add_missing_dev(struct btrfs_fs_devices *fs_devices,
6901 list_add(&device->dev_list, &fs_devices->devices);
6902 device->fs_devices = fs_devices;
6903 fs_devices->num_devices++;
6906 fs_devices->missing_devices++;
7048 dev = add_missing_dev(fs_info->fs_devices, devid, uuid);
7138 map->stripes[i].dev = btrfs_find_device(fs_info->fs_devices, &args);
7189 struct btrfs_fs_devices *fs_devices;
7196 list_for_each_entry(fs_devices, &fs_info->fs_devices->seed_list, seed_list)
7197 if (!memcmp(fs_devices->fsid, fsid, BTRFS_FSID_SIZE))
7198 return fs_devices;
7201 fs_devices = find_fsid(fsid, NULL);
7202 if (!fs_devices) {
7206 fs_devices = alloc_fs_devices(fsid);
7207 if (IS_ERR(fs_devices))
7208 return fs_devices;
7210 fs_devices->seeding = true;
7211 fs_devices->opened = 1;
7212 return fs_devices;
7217 * respective fs_devices and anchor it at fs_info->fs_devices->seed_list
7219 fs_devices = clone_fs_devices(fs_devices);
7220 if (IS_ERR(fs_devices))
7221 return fs_devices;
7223 ret = open_fs_devices(fs_devices, BLK_OPEN_READ, fs_info->bdev_holder);
7225 free_fs_devices(fs_devices);
7229 if (!fs_devices->seeding) {
7230 close_fs_devices(fs_devices);
7231 free_fs_devices(fs_devices);
7235 list_add(&fs_devices->seed_list, &fs_info->fs_devices->seed_list);
7237 return fs_devices;
7245 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
7261 if (memcmp(fs_uuid, fs_devices->metadata_uuid, BTRFS_FSID_SIZE)) {
7262 fs_devices = open_seed_devices(fs_info, fs_uuid);
7263 if (IS_ERR(fs_devices))
7264 return PTR_ERR(fs_devices);
7267 device = btrfs_find_device(fs_info->fs_devices, &args);
7275 device = add_missing_dev(fs_devices, devid, dev_uuid);
7302 device->fs_devices->missing_devices++;
7306 /* Move the device to its own fs_devices */
7307 if (device->fs_devices != fs_devices) {
7311 list_move(&device->dev_list, &fs_devices->devices);
7312 device->fs_devices->num_devices--;
7313 fs_devices->num_devices++;
7315 device->fs_devices->missing_devices--;
7316 fs_devices->missing_devices++;
7318 device->fs_devices = fs_devices;
7322 if (device->fs_devices != fs_info->fs_devices) {
7343 device->fs_devices->total_rw_bytes += device->total_bytes;
7552 fs_info->fs_devices->total_rw_bytes = 0;
7623 if (total_dev != fs_info->fs_devices->total_devices) {
7628 fs_info->fs_devices->total_devices = total_dev;
7632 fs_info->fs_devices->total_rw_bytes) {
7634 "super_total_bytes %llu mismatch with fs_devices total_rw_bytes %llu",
7636 fs_info->fs_devices->total_rw_bytes);
7650 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;
7654 fs_devices->fs_info = fs_info;
7656 mutex_lock(&fs_devices->device_list_mutex);
7657 list_for_each_entry(device, &fs_devices->devices, dev_list)
7660 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) {
7670 mutex_unlock(&fs_devices->device_list_mutex);
7744 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;
7753 mutex_lock(&fs_devices->device_list_mutex);
7754 list_for_each_entry(device, &fs_devices->devices, dev_list) {
7759 list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list) {
7767 mutex_unlock(&fs_devices->device_list_mutex);
7844 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
7849 mutex_lock(&fs_devices->device_list_mutex);
7850 list_for_each_entry(device, &fs_devices->devices, dev_list) {
7873 mutex_unlock(&fs_devices->device_list_mutex);
7919 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
7922 mutex_lock(&fs_devices->device_list_mutex);
7924 dev = btrfs_find_device(fs_info->fs_devices, &args);
7925 mutex_unlock(&fs_devices->device_list_mutex);
8060 dev = btrfs_find_device(fs_info->fs_devices, &args);