Lines Matching defs:clone
33 #include "dm-clone-metadata.h"
35 #define DM_MSG_PREFIX "clone"
60 /* dm-clone metadata modes */
69 struct clone {
147 * dm-clone flags
158 static enum clone_metadata_mode get_clone_mode(struct clone *clone)
160 return READ_ONCE(clone->mode);
163 static const char *clone_device_name(struct clone *clone)
165 return dm_table_device_name(clone->ti->table);
168 static void __set_clone_mode(struct clone *clone, enum clone_metadata_mode new_mode)
176 enum clone_metadata_mode old_mode = get_clone_mode(clone);
185 dm_clone_metadata_set_read_only(clone->cmd);
189 dm_clone_metadata_set_read_write(clone->cmd);
193 WRITE_ONCE(clone->mode, new_mode);
196 dm_table_event(clone->ti->table);
197 DMINFO("%s: Switching to %s mode", clone_device_name(clone),
202 static void __abort_transaction(struct clone *clone)
204 const char *dev_name = clone_device_name(clone);
206 if (get_clone_mode(clone) >= CM_READ_ONLY)
210 if (dm_clone_metadata_abort(clone->cmd)) {
212 __set_clone_mode(clone, CM_FAIL);
216 static void __reload_in_core_bitset(struct clone *clone)
218 const char *dev_name = clone_device_name(clone);
220 if (get_clone_mode(clone) == CM_FAIL)
225 if (dm_clone_reload_in_core_bitset(clone->cmd)) {
227 __set_clone_mode(clone, CM_FAIL);
231 static void __metadata_operation_failed(struct clone *clone, const char *op, int r)
234 clone_device_name(clone), op, r);
236 __abort_transaction(clone);
237 __set_clone_mode(clone, CM_READ_ONLY);
244 __reload_in_core_bitset(clone);
250 static inline void wakeup_hydration_waiters(struct clone *clone)
252 wake_up_all(&clone->hydration_stopped);
255 static inline void wake_worker(struct clone *clone)
257 queue_work(clone->wq, &clone->worker);
265 static inline void remap_to_source(struct clone *clone, struct bio *bio)
267 bio_set_dev(bio, clone->source_dev->bdev);
270 static inline void remap_to_dest(struct clone *clone, struct bio *bio)
272 bio_set_dev(bio, clone->dest_dev->bdev);
275 static bool bio_triggers_commit(struct clone *clone, struct bio *bio)
278 dm_clone_changed_this_transaction(clone->cmd);
282 static inline sector_t region_to_sector(struct clone *clone, unsigned long region_nr)
284 return ((sector_t)region_nr << clone->region_shift);
288 static inline unsigned long bio_to_region(struct clone *clone, struct bio *bio)
290 return (bio->bi_iter.bi_sector >> clone->region_shift);
294 static void bio_region_range(struct clone *clone, struct bio *bio,
299 *rs = dm_sector_div_up(bio->bi_iter.bi_sector, clone->region_size);
300 end = bio_end_sector(bio) >> clone->region_shift;
309 static inline bool is_overwrite_bio(struct clone *clone, struct bio *bio)
311 return (bio_data_dir(bio) == WRITE && bio_sectors(bio) == clone->region_size);
345 static void issue_bio(struct clone *clone, struct bio *bio)
347 if (!bio_triggers_commit(clone, bio)) {
356 if (unlikely(get_clone_mode(clone) >= CM_READ_ONLY)) {
365 spin_lock_irq(&clone->lock);
366 bio_list_add(&clone->deferred_flush_bios, bio);
367 spin_unlock_irq(&clone->lock);
369 wake_worker(clone);
378 static void remap_and_issue(struct clone *clone, struct bio *bio)
380 remap_to_dest(clone, bio);
381 issue_bio(clone, bio);
391 static void issue_deferred_bios(struct clone *clone, struct bio_list *bios)
402 if (bio_triggers_commit(clone, bio))
408 spin_lock_irqsave(&clone->lock, flags);
409 bio_list_merge(&clone->deferred_bios, &normal_bios);
410 bio_list_merge(&clone->deferred_flush_bios, &flush_bios);
411 spin_unlock_irqrestore(&clone->lock, flags);
413 wake_worker(clone);
416 static void complete_overwrite_bio(struct clone *clone, struct bio *bio)
439 if (unlikely(get_clone_mode(clone) >= CM_READ_ONLY)) {
448 spin_lock_irqsave(&clone->lock, flags);
449 bio_list_add(&clone->deferred_flush_completions, bio);
450 spin_unlock_irqrestore(&clone->lock, flags);
452 wake_worker(clone);
461 static void complete_discard_bio(struct clone *clone, struct bio *bio, bool success)
470 if (test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags) && success) {
471 remap_to_dest(clone, bio);
472 bio_region_range(clone, bio, &rs, &nr_regions);
473 trim_bio(bio, region_to_sector(clone, rs),
474 nr_regions << clone->region_shift);
480 static void process_discard_bio(struct clone *clone, struct bio *bio)
484 bio_region_range(clone, bio, &rs, &nr_regions);
490 if (WARN_ON(rs >= clone->nr_regions || (rs + nr_regions) < rs ||
491 (rs + nr_regions) > clone->nr_regions)) {
493 clone_device_name(clone), rs, nr_regions,
494 clone->nr_regions,
505 if (dm_clone_is_range_hydrated(clone->cmd, rs, nr_regions)) {
506 complete_discard_bio(clone, bio, true);
515 if (unlikely(get_clone_mode(clone) >= CM_READ_ONLY)) {
523 spin_lock_irq(&clone->lock);
524 bio_list_add(&clone->deferred_discard_bios, bio);
525 spin_unlock_irq(&clone->lock);
527 wake_worker(clone);
533 * dm-clone region hydrations.
536 struct clone *clone;
582 static int hash_table_init(struct clone *clone)
589 clone->ht = kvmalloc(sz * sizeof(struct hash_table_bucket), GFP_KERNEL);
590 if (!clone->ht)
594 bucket = clone->ht + i;
603 static void hash_table_exit(struct clone *clone)
605 kvfree(clone->ht);
608 static struct hash_table_bucket *get_hash_table_bucket(struct clone *clone,
611 return &clone->ht[hash_long(region_nr, HASH_TABLE_BITS)];
668 static struct dm_clone_region_hydration *alloc_hydration(struct clone *clone)
676 hd = mempool_alloc(&clone->hydration_pool, GFP_NOIO);
677 hd->clone = clone;
684 mempool_free(hd, &hd->clone->hydration_pool);
702 * Update dm-clone's metadata after a region has finished hydrating and remove
710 struct clone *clone = hd->clone;
712 if (unlikely(get_clone_mode(clone) >= CM_READ_ONLY))
717 r = dm_clone_set_region_hydrated(clone->cmd, hd->region_nr);
719 bucket = get_hash_table_bucket(clone, hd->region_nr);
732 * 1. Update dm-clone's metadata.
743 struct clone *clone = hd->clone;
749 complete_overwrite_bio(clone, hd->overwrite_bio);
751 issue_deferred_bios(clone, &hd->deferred_bios);
763 if (atomic_dec_and_test(&clone->hydrations_in_flight))
764 wakeup_hydration_waiters(clone);
772 struct clone *clone = hd->clone;
777 DMERR_LIMIT("%s: hydration failed", clone_device_name(clone));
794 if (test_bit(DM_CLONE_HYDRATION_ENABLED, &clone->flags) &&
795 !atomic_read(&clone->ios_in_flight))
796 wake_worker(clone);
804 struct clone *clone = hd->clone;
809 region_size = clone->region_size;
813 total_size = region_to_sector(clone, nr_regions - 1);
815 if (region_end == clone->nr_regions - 1) {
820 tail_size = clone->ti->len & (region_size - 1);
829 from.bdev = clone->source_dev->bdev;
830 from.sector = region_to_sector(clone, region_start);
833 to.bdev = clone->dest_dev->bdev;
838 atomic_add(nr_regions, &clone->hydrations_in_flight);
839 dm_kcopyd_copy(clone->kcopyd_client, &from, 1, &to, 0,
866 atomic_inc(&hd->clone->hydrations_in_flight);
880 static void hydrate_bio_region(struct clone *clone, struct bio *bio)
886 region_nr = bio_to_region(clone, bio);
887 bucket = get_hash_table_bucket(clone, region_nr);
899 if (dm_clone_is_region_hydrated(clone->cmd, region_nr)) {
902 issue_bio(clone, bio);
912 hd = alloc_hydration(clone);
918 if (dm_clone_is_region_hydrated(clone->cmd, region_nr)) {
921 issue_bio(clone, bio);
939 if (unlikely(get_clone_mode(clone) >= CM_READ_ONLY)) {
954 if (is_overwrite_bio(clone, bio)) {
987 struct clone *clone = hd->clone;
988 unsigned int max_batch_size = READ_ONCE(clone->hydration_batch_size);
1022 static unsigned long __start_next_hydration(struct clone *clone,
1028 unsigned long nr_regions = clone->nr_regions;
1030 hd = alloc_hydration(clone);
1034 offset = dm_clone_find_next_unhydrated_region(clone->cmd, offset);
1038 bucket = get_hash_table_bucket(clone, offset);
1041 if (!dm_clone_is_region_hydrated(clone->cmd, offset) &&
1067 static void do_hydration(struct clone *clone)
1070 unsigned long offset, nr_regions = clone->nr_regions;
1077 if (unlikely(get_clone_mode(clone) >= CM_READ_ONLY))
1080 if (dm_clone_is_hydration_done(clone->cmd))
1086 atomic_inc(&clone->hydrations_in_flight);
1098 offset = clone->hydration_offset;
1099 while (likely(!test_bit(DM_CLONE_HYDRATION_SUSPENDED, &clone->flags)) &&
1100 !atomic_read(&clone->ios_in_flight) &&
1101 test_bit(DM_CLONE_HYDRATION_ENABLED, &clone->flags) &&
1103 current_volume = atomic_read(&clone->hydrations_in_flight);
1106 if (current_volume > READ_ONCE(clone->hydration_threshold))
1109 offset = __start_next_hydration(clone, offset, &batch);
1118 clone->hydration_offset = offset;
1120 if (atomic_dec_and_test(&clone->hydrations_in_flight))
1121 wakeup_hydration_waiters(clone);
1126 static bool need_commit_due_to_time(struct clone *clone)
1128 return !time_in_range(jiffies, clone->last_commit_jiffies,
1129 clone->last_commit_jiffies + COMMIT_PERIOD);
1135 static int commit_metadata(struct clone *clone, bool *dest_dev_flushed)
1142 mutex_lock(&clone->commit_lock);
1144 if (!dm_clone_changed_this_transaction(clone->cmd))
1147 if (unlikely(get_clone_mode(clone) >= CM_READ_ONLY)) {
1152 r = dm_clone_metadata_pre_commit(clone->cmd);
1154 __metadata_operation_failed(clone, "dm_clone_metadata_pre_commit", r);
1158 bio_reset(&clone->flush_bio);
1159 bio_set_dev(&clone->flush_bio, clone->dest_dev->bdev);
1160 clone->flush_bio.bi_opf = REQ_OP_WRITE | REQ_PREFLUSH;
1162 r = submit_bio_wait(&clone->flush_bio);
1164 __metadata_operation_failed(clone, "flush destination device", r);
1171 r = dm_clone_metadata_commit(clone->cmd);
1173 __metadata_operation_failed(clone, "dm_clone_metadata_commit", r);
1177 if (dm_clone_is_hydration_done(clone->cmd))
1178 dm_table_event(clone->ti->table);
1180 mutex_unlock(&clone->commit_lock);
1185 static void process_deferred_discards(struct clone *clone)
1193 spin_lock_irq(&clone->lock);
1194 bio_list_merge(&discards, &clone->deferred_discard_bios);
1195 bio_list_init(&clone->deferred_discard_bios);
1196 spin_unlock_irq(&clone->lock);
1201 if (unlikely(get_clone_mode(clone) >= CM_READ_ONLY))
1206 bio_region_range(clone, bio, &rs, &nr_regions);
1212 r = dm_clone_cond_set_range(clone->cmd, rs, nr_regions);
1219 complete_discard_bio(clone, bio, r == 0);
1223 static void process_deferred_bios(struct clone *clone)
1227 spin_lock_irq(&clone->lock);
1228 bio_list_merge(&bios, &clone->deferred_bios);
1229 bio_list_init(&clone->deferred_bios);
1230 spin_unlock_irq(&clone->lock);
1238 static void process_deferred_flush_bios(struct clone *clone)
1249 spin_lock_irq(&clone->lock);
1250 bio_list_merge(&bios, &clone->deferred_flush_bios);
1251 bio_list_init(&clone->deferred_flush_bios);
1253 bio_list_merge(&bio_completions, &clone->deferred_flush_completions);
1254 bio_list_init(&clone->deferred_flush_completions);
1255 spin_unlock_irq(&clone->lock);
1258 !(dm_clone_changed_this_transaction(clone->cmd) && need_commit_due_to_time(clone)))
1261 if (commit_metadata(clone, &dest_dev_flushed)) {
1270 clone->last_commit_jiffies = jiffies;
1290 struct clone *clone = container_of(work, typeof(*clone), worker);
1292 process_deferred_bios(clone);
1293 process_deferred_discards(clone);
1304 process_deferred_flush_bios(clone);
1307 do_hydration(clone);
1317 struct clone *clone = container_of(to_delayed_work(work), struct clone, waker);
1319 wake_worker(clone);
1320 queue_delayed_work(clone->wq, &clone->waker, COMMIT_PERIOD);
1330 struct clone *clone = ti->private;
1333 atomic_inc(&clone->ios_in_flight);
1335 if (unlikely(get_clone_mode(clone) == CM_FAIL))
1346 remap_and_issue(clone, bio);
1353 * dm-clone interprets discards and performs a fast hydration of the
1358 process_discard_bio(clone, bio);
1372 region_nr = bio_to_region(clone, bio);
1373 if (dm_clone_is_region_hydrated(clone->cmd, region_nr)) {
1374 remap_and_issue(clone, bio);
1377 remap_to_source(clone, bio);
1381 remap_to_dest(clone, bio);
1382 hydrate_bio_region(clone, bio);
1389 struct clone *clone = ti->private;
1391 atomic_dec(&clone->ios_in_flight);
1396 static void emit_flags(struct clone *clone, char *result, unsigned int maxlen,
1402 count = !test_bit(DM_CLONE_HYDRATION_ENABLED, &clone->flags);
1403 count += !test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags);
1407 if (!test_bit(DM_CLONE_HYDRATION_ENABLED, &clone->flags))
1410 if (!test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags))
1416 static void emit_core_args(struct clone *clone, char *result,
1423 READ_ONCE(clone->hydration_threshold),
1424 READ_ONCE(clone->hydration_batch_size));
1433 * <clone region size> <#hydrated regions>/<#total regions> <#hydrating regions>
1434 * <#features> <features>* <#core args> <core args>* <clone metadata mode>
1446 struct clone *clone = ti->private;
1450 if (get_clone_mode(clone) == CM_FAIL) {
1457 (void) commit_metadata(clone, NULL);
1459 r = dm_clone_get_free_metadata_block_count(clone->cmd, &nr_free_metadata_blocks);
1463 clone_device_name(clone), r);
1467 r = dm_clone_get_metadata_dev_size(clone->cmd, &nr_metadata_blocks);
1471 clone_device_name(clone), r);
1479 (unsigned long long)clone->region_size,
1480 dm_clone_nr_of_hydrated_regions(clone->cmd),
1481 clone->nr_regions,
1482 atomic_read(&clone->hydrations_in_flight));
1484 emit_flags(clone, result, maxlen, &sz);
1485 emit_core_args(clone, result, maxlen, &sz);
1487 switch (get_clone_mode(clone)) {
1501 format_dev_t(buf, clone->metadata_dev->bdev->bd_dev);
1504 format_dev_t(buf, clone->dest_dev->bdev->bd_dev);
1507 format_dev_t(buf, clone->source_dev->bdev->bd_dev);
1510 for (i = 0; i < clone->nr_ctr_args; i++)
1511 DMEMIT(" %s", clone->ctr_args[i]);
1528 * Construct a clone device mapping:
1530 * clone <metadata dev> <destination dev> <source dev> <region size>
1534 * destination dev: The destination device, which will become a clone of the
1537 * region size: dm-clone unit size in sectors
1546 static int parse_feature_args(struct dm_arg_set *as, struct clone *clone)
1551 struct dm_target *ti = clone->ti;
1572 __clear_bit(DM_CLONE_HYDRATION_ENABLED, &clone->flags);
1574 __clear_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags);
1584 static int parse_core_args(struct dm_arg_set *as, struct clone *clone)
1590 struct dm_target *ti = clone->ti;
1599 clone->hydration_batch_size = DEFAULT_HYDRATION_BATCH_SIZE;
1600 clone->hydration_threshold = DEFAULT_HYDRATION_THRESHOLD;
1624 clone->hydration_threshold = value;
1630 clone->hydration_batch_size = value;
1640 static int parse_region_size(struct clone *clone, struct dm_arg_set *as, char **error)
1661 if (region_size % (bdev_logical_block_size(clone->source_dev->bdev) >> 9) ||
1662 region_size % (bdev_logical_block_size(clone->dest_dev->bdev) >> 9)) {
1667 clone->region_size = region_size;
1686 static int parse_metadata_dev(struct clone *clone, struct dm_arg_set *as, char **error)
1692 r = dm_get_device(clone->ti, dm_shift_arg(as), FMODE_READ | FMODE_WRITE,
1693 &clone->metadata_dev);
1699 metadata_dev_size = get_dev_size(clone->metadata_dev);
1702 bdevname(clone->metadata_dev->bdev, b), DM_CLONE_METADATA_MAX_SECTORS);
1707 static int parse_dest_dev(struct clone *clone, struct dm_arg_set *as, char **error)
1712 r = dm_get_device(clone->ti, dm_shift_arg(as), FMODE_READ | FMODE_WRITE,
1713 &clone->dest_dev);
1719 dest_dev_size = get_dev_size(clone->dest_dev);
1720 if (dest_dev_size < clone->ti->len) {
1721 dm_put_device(clone->ti, clone->dest_dev);
1729 static int parse_source_dev(struct clone *clone, struct dm_arg_set *as, char **error)
1734 r = dm_get_device(clone->ti, dm_shift_arg(as), FMODE_READ,
1735 &clone->source_dev);
1741 source_dev_size = get_dev_size(clone->source_dev);
1742 if (source_dev_size < clone->ti->len) {
1743 dm_put_device(clone->ti, clone->source_dev);
1751 static int copy_ctr_args(struct clone *clone, int argc, const char **argv, char **error)
1771 clone->nr_ctr_args = argc;
1772 clone->ctr_args = copy;
1784 struct clone *clone;
1795 clone = kzalloc(sizeof(*clone), GFP_KERNEL);
1796 if (!clone) {
1797 ti->error = "Failed to allocate clone structure";
1801 clone->ti = ti;
1803 /* Initialize dm-clone flags */
1804 __set_bit(DM_CLONE_HYDRATION_ENABLED, &clone->flags);
1805 __set_bit(DM_CLONE_HYDRATION_SUSPENDED, &clone->flags);
1806 __set_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags);
1808 r = parse_metadata_dev(clone, &as, &ti->error);
1812 r = parse_dest_dev(clone, &as, &ti->error);
1816 r = parse_source_dev(clone, &as, &ti->error);
1820 r = parse_region_size(clone, &as, &ti->error);
1824 clone->region_shift = __ffs(clone->region_size);
1825 nr_regions = dm_sector_div_up(ti->len, clone->region_size);
1834 clone->nr_regions = nr_regions;
1836 r = validate_nr_regions(clone->nr_regions, &ti->error);
1840 r = dm_set_target_max_io_len(ti, clone->region_size);
1846 r = parse_feature_args(&as, clone);
1850 r = parse_core_args(&as, clone);
1855 clone->cmd = dm_clone_metadata_open(clone->metadata_dev->bdev, ti->len,
1856 clone->region_size);
1857 if (IS_ERR(clone->cmd)) {
1859 r = PTR_ERR(clone->cmd);
1863 __set_clone_mode(clone, CM_WRITE);
1865 if (get_clone_mode(clone) != CM_WRITE) {
1871 clone->last_commit_jiffies = jiffies;
1874 r = hash_table_init(clone);
1880 atomic_set(&clone->ios_in_flight, 0);
1881 init_waitqueue_head(&clone->hydration_stopped);
1882 spin_lock_init(&clone->lock);
1883 bio_list_init(&clone->deferred_bios);
1884 bio_list_init(&clone->deferred_discard_bios);
1885 bio_list_init(&clone->deferred_flush_bios);
1886 bio_list_init(&clone->deferred_flush_completions);
1887 clone->hydration_offset = 0;
1888 atomic_set(&clone->hydrations_in_flight, 0);
1889 bio_init(&clone->flush_bio, NULL, 0);
1891 clone->wq = alloc_workqueue("dm-" DM_MSG_PREFIX, WQ_MEM_RECLAIM, 0);
1892 if (!clone->wq) {
1898 INIT_WORK(&clone->worker, do_worker);
1899 INIT_DELAYED_WORK(&clone->waker, do_waker);
1901 clone->kcopyd_client = dm_kcopyd_client_create(&dm_kcopyd_throttle);
1902 if (IS_ERR(clone->kcopyd_client)) {
1903 r = PTR_ERR(clone->kcopyd_client);
1907 r = mempool_init_slab_pool(&clone->hydration_pool, MIN_HYDRATIONS,
1915 r = copy_ctr_args(clone, argc - 3, (const char **)argv + 3, &ti->error);
1919 mutex_init(&clone->commit_lock);
1929 ti->private = clone;
1934 mempool_exit(&clone->hydration_pool);
1936 dm_kcopyd_client_destroy(clone->kcopyd_client);
1938 destroy_workqueue(clone->wq);
1940 hash_table_exit(clone);
1942 dm_clone_metadata_close(clone->cmd);
1944 dm_put_device(ti, clone->source_dev);
1946 dm_put_device(ti, clone->dest_dev);
1948 dm_put_device(ti, clone->metadata_dev);
1950 kfree(clone);
1958 struct clone *clone = ti->private;
1960 mutex_destroy(&clone->commit_lock);
1961 bio_uninit(&clone->flush_bio);
1963 for (i = 0; i < clone->nr_ctr_args; i++)
1964 kfree(clone->ctr_args[i]);
1965 kfree(clone->ctr_args);
1967 mempool_exit(&clone->hydration_pool);
1968 dm_kcopyd_client_destroy(clone->kcopyd_client);
1969 cancel_delayed_work_sync(&clone->waker);
1970 destroy_workqueue(clone->wq);
1971 hash_table_exit(clone);
1972 dm_clone_metadata_close(clone->cmd);
1973 dm_put_device(ti, clone->source_dev);
1974 dm_put_device(ti, clone->dest_dev);
1975 dm_put_device(ti, clone->metadata_dev);
1977 kfree(clone);
1984 struct clone *clone = ti->private;
2001 cancel_delayed_work_sync(&clone->waker);
2003 set_bit(DM_CLONE_HYDRATION_SUSPENDED, &clone->flags);
2014 wait_event(clone->hydration_stopped, !atomic_read(&clone->hydrations_in_flight));
2015 flush_workqueue(clone->wq);
2017 (void) commit_metadata(clone, NULL);
2022 struct clone *clone = ti->private;
2024 clear_bit(DM_CLONE_HYDRATION_SUSPENDED, &clone->flags);
2025 do_waker(&clone->waker.work);
2039 static void disable_passdown_if_not_supported(struct clone *clone)
2041 struct block_device *dest_dev = clone->dest_dev->bdev;
2046 if (!test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags))
2051 else if (dest_limits->max_discard_sectors < clone->region_size)
2057 clear_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags);
2061 static void set_discard_limits(struct clone *clone, struct queue_limits *limits)
2063 struct block_device *dest_bdev = clone->dest_dev->bdev;
2066 if (!test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags)) {
2068 limits->discard_granularity = clone->region_size << SECTOR_SHIFT;
2069 limits->max_discard_sectors = round_down(UINT_MAX >> SECTOR_SHIFT, clone->region_size);
2088 struct clone *clone = ti->private;
2093 * dm-clone's region size (io_opt is a factor) do not override them.
2095 if (io_opt_sectors < clone->region_size ||
2096 do_div(io_opt_sectors, clone->region_size)) {
2097 blk_limits_io_min(limits, clone->region_size << SECTOR_SHIFT);
2098 blk_limits_io_opt(limits, clone->region_size << SECTOR_SHIFT);
2101 disable_passdown_if_not_supported(clone);
2102 set_discard_limits(clone, limits);
2109 struct clone *clone = ti->private;
2110 struct dm_dev *dest_dev = clone->dest_dev;
2111 struct dm_dev *source_dev = clone->source_dev;
2120 * dm-clone message functions.
2122 static void set_hydration_threshold(struct clone *clone, unsigned int nr_regions)
2124 WRITE_ONCE(clone->hydration_threshold, nr_regions);
2131 wake_worker(clone);
2134 static void set_hydration_batch_size(struct clone *clone, unsigned int nr_regions)
2136 WRITE_ONCE(clone->hydration_batch_size, nr_regions);
2139 static void enable_hydration(struct clone *clone)
2141 if (!test_and_set_bit(DM_CLONE_HYDRATION_ENABLED, &clone->flags))
2142 wake_worker(clone);
2145 static void disable_hydration(struct clone *clone)
2147 clear_bit(DM_CLONE_HYDRATION_ENABLED, &clone->flags);
2153 struct clone *clone = ti->private;
2160 enable_hydration(clone);
2165 disable_hydration(clone);
2176 set_hydration_threshold(clone, value);
2185 set_hydration_batch_size(clone, value);
2190 DMERR("%s: Unsupported message `%s'", clone_device_name(clone), argv[0]);
2195 .name = "clone",
2223 DMERR("Failed to register clone target");
2243 MODULE_DESCRIPTION(DM_NAME " clone target");