Lines Matching refs:cmd
273 static inline int superblock_read_lock(struct dm_clone_metadata *cmd,
276 return dm_bm_read_lock(cmd->bm, SUPERBLOCK_LOCATION, &sb_validator, sblock);
279 static inline int superblock_write_lock(struct dm_clone_metadata *cmd,
282 return dm_bm_write_lock(cmd->bm, SUPERBLOCK_LOCATION, &sb_validator, sblock);
285 static inline int superblock_write_lock_zero(struct dm_clone_metadata *cmd,
288 return dm_bm_write_lock_zero(cmd->bm, SUPERBLOCK_LOCATION, &sb_validator, sblock);
291 static int __copy_sm_root(struct dm_clone_metadata *cmd)
296 r = dm_sm_root_size(cmd->sm, &root_size);
300 return dm_sm_copy_root(cmd->sm, &cmd->metadata_space_map_root, root_size);
304 static void __prepare_superblock(struct dm_clone_metadata *cmd,
316 memcpy(&sb->metadata_space_map_root, &cmd->metadata_space_map_root,
317 sizeof(cmd->metadata_space_map_root));
319 sb->region_size = cpu_to_le64(cmd->region_size);
320 sb->target_size = cpu_to_le64(cmd->target_size);
321 sb->bitset_root = cpu_to_le64(cmd->bitset_root);
324 static int __open_metadata(struct dm_clone_metadata *cmd)
330 r = superblock_read_lock(cmd, &sblock);
340 if (cmd->region_size != le64_to_cpu(sb->region_size) ||
341 cmd->target_size != le64_to_cpu(sb->target_size)) {
347 r = dm_tm_open_with_sm(cmd->bm, SUPERBLOCK_LOCATION,
350 &cmd->tm, &cmd->sm);
357 dm_disk_bitset_init(cmd->tm, &cmd->bitset_info);
358 cmd->bitset_root = le64_to_cpu(sb->bitset_root);
366 static int __format_metadata(struct dm_clone_metadata *cmd)
372 r = dm_tm_create_with_sm(cmd->bm, SUPERBLOCK_LOCATION, &cmd->tm, &cmd->sm);
378 dm_disk_bitset_init(cmd->tm, &cmd->bitset_info);
380 r = dm_bitset_empty(&cmd->bitset_info, &cmd->bitset_root);
386 r = dm_bitset_resize(&cmd->bitset_info, cmd->bitset_root, 0,
387 cmd->nr_regions, false, &cmd->bitset_root);
389 DMERR("Failed to resize on-disk bitset to %lu entries", cmd->nr_regions);
394 r = dm_tm_pre_commit(cmd->tm);
400 r = __copy_sm_root(cmd);
406 r = superblock_write_lock_zero(cmd, &sblock);
413 __prepare_superblock(cmd, sb);
414 r = dm_tm_commit(cmd->tm, sblock);
423 dm_sm_destroy(cmd->sm);
424 dm_tm_destroy(cmd->tm);
429 static int __open_or_format_metadata(struct dm_clone_metadata *cmd, bool may_format_device)
434 r = __superblock_all_zeroes(cmd->bm, &formatted);
439 return may_format_device ? __format_metadata(cmd) : -EPERM;
441 return __open_metadata(cmd);
444 static int __create_persistent_data_structures(struct dm_clone_metadata *cmd,
450 cmd->bm = dm_block_manager_create(cmd->bdev,
453 if (IS_ERR(cmd->bm)) {
455 return PTR_ERR(cmd->bm);
458 r = __open_or_format_metadata(cmd, may_format_device);
460 dm_block_manager_destroy(cmd->bm);
465 static void __destroy_persistent_data_structures(struct dm_clone_metadata *cmd)
467 dm_sm_destroy(cmd->sm);
468 dm_tm_destroy(cmd->tm);
469 dm_block_manager_destroy(cmd->bm);
503 static int dirty_map_init(struct dm_clone_metadata *cmd)
505 if (__dirty_map_init(&cmd->dmap[0], cmd->nr_words, cmd->nr_regions)) {
510 if (__dirty_map_init(&cmd->dmap[1], cmd->nr_words, cmd->nr_regions)) {
512 __dirty_map_exit(&cmd->dmap[0]);
516 cmd->current_dmap = &cmd->dmap[0];
517 cmd->committing_dmap = NULL;
522 static void dirty_map_exit(struct dm_clone_metadata *cmd)
524 __dirty_map_exit(&cmd->dmap[0]);
525 __dirty_map_exit(&cmd->dmap[1]);
528 static int __load_bitset_in_core(struct dm_clone_metadata *cmd)
535 r = dm_bitset_flush(&cmd->bitset_info, cmd->bitset_root, &cmd->bitset_root);
539 r = dm_bitset_cursor_begin(&cmd->bitset_info, cmd->bitset_root, cmd->nr_regions, &c);
545 __set_bit(i, cmd->region_map);
547 __clear_bit(i, cmd->region_map);
549 if (i >= (cmd->nr_regions - 1))
568 struct dm_clone_metadata *cmd;
570 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
571 if (!cmd) {
576 cmd->bdev = bdev;
577 cmd->target_size = target_size;
578 cmd->region_size = region_size;
579 cmd->nr_regions = dm_sector_div_up(cmd->target_size, cmd->region_size);
580 cmd->nr_words = BITS_TO_LONGS(cmd->nr_regions);
582 init_rwsem(&cmd->lock);
583 spin_lock_init(&cmd->bitmap_lock);
584 cmd->read_only = 0;
585 cmd->fail_io = false;
586 cmd->hydration_done = false;
588 cmd->region_map = kvmalloc(bitmap_size(cmd->nr_regions), GFP_KERNEL);
589 if (!cmd->region_map) {
595 r = __create_persistent_data_structures(cmd, true);
599 r = __load_bitset_in_core(cmd);
605 r = dirty_map_init(cmd);
609 if (bitmap_full(cmd->region_map, cmd->nr_regions))
610 cmd->hydration_done = true;
612 return cmd;
615 __destroy_persistent_data_structures(cmd);
618 kvfree(cmd->region_map);
621 kfree(cmd);
626 void dm_clone_metadata_close(struct dm_clone_metadata *cmd)
628 if (!cmd->fail_io)
629 __destroy_persistent_data_structures(cmd);
631 dirty_map_exit(cmd);
632 kvfree(cmd->region_map);
633 kfree(cmd);
636 bool dm_clone_is_hydration_done(struct dm_clone_metadata *cmd)
638 return cmd->hydration_done;
641 bool dm_clone_is_region_hydrated(struct dm_clone_metadata *cmd, unsigned long region_nr)
643 return dm_clone_is_hydration_done(cmd) || test_bit(region_nr, cmd->region_map);
646 bool dm_clone_is_range_hydrated(struct dm_clone_metadata *cmd,
651 if (dm_clone_is_hydration_done(cmd))
654 bit = find_next_zero_bit(cmd->region_map, cmd->nr_regions, start);
659 unsigned int dm_clone_nr_of_hydrated_regions(struct dm_clone_metadata *cmd)
661 return bitmap_weight(cmd->region_map, cmd->nr_regions);
664 unsigned long dm_clone_find_next_unhydrated_region(struct dm_clone_metadata *cmd,
667 return find_next_zero_bit(cmd->region_map, cmd->nr_regions, start);
670 static int __update_metadata_word(struct dm_clone_metadata *cmd,
676 unsigned long max_index = min(cmd->nr_regions, (word + 1) * BITS_PER_LONG);
680 r = dm_bitset_set_bit(&cmd->bitset_info, cmd->bitset_root,
681 index, &cmd->bitset_root);
694 static int __metadata_commit(struct dm_clone_metadata *cmd)
701 r = dm_bitset_flush(&cmd->bitset_info, cmd->bitset_root, &cmd->bitset_root);
708 r = dm_tm_pre_commit(cmd->tm);
714 /* Save the space map root in cmd->metadata_space_map_root */
715 r = __copy_sm_root(cmd);
722 r = superblock_write_lock_zero(cmd, &sblock);
730 __prepare_superblock(cmd, sb);
733 r = dm_tm_commit(cmd->tm, sblock);
742 if (bitmap_full(cmd->region_map, cmd->nr_regions))
743 cmd->hydration_done = true;
748 static int __flush_dmap(struct dm_clone_metadata *cmd, struct dirty_map *dmap)
755 word = find_next_bit(dmap->dirty_words, cmd->nr_words, word);
757 if (word == cmd->nr_words)
760 r = __update_metadata_word(cmd, dmap->dirty_regions, word);
767 } while (word < cmd->nr_words);
769 r = __metadata_commit(cmd);
775 spin_lock_irq(&cmd->bitmap_lock);
777 spin_unlock_irq(&cmd->bitmap_lock);
782 int dm_clone_metadata_pre_commit(struct dm_clone_metadata *cmd)
787 down_write(&cmd->lock);
789 if (cmd->fail_io || dm_bm_is_read_only(cmd->bm)) {
795 dmap = cmd->current_dmap;
798 next_dmap = (dmap == &cmd->dmap[0]) ? &cmd->dmap[1] : &cmd->dmap[0];
804 if (WARN_ON(next_dmap->changed || cmd->committing_dmap)) {
810 spin_lock_irq(&cmd->bitmap_lock);
811 cmd->current_dmap = next_dmap;
812 spin_unlock_irq(&cmd->bitmap_lock);
815 cmd->committing_dmap = dmap;
817 up_write(&cmd->lock);
822 int dm_clone_metadata_commit(struct dm_clone_metadata *cmd)
826 down_write(&cmd->lock);
828 if (cmd->fail_io || dm_bm_is_read_only(cmd->bm))
831 if (WARN_ON(!cmd->committing_dmap)) {
836 r = __flush_dmap(cmd, cmd->committing_dmap);
839 cmd->committing_dmap = NULL;
842 up_write(&cmd->lock);
847 int dm_clone_set_region_hydrated(struct dm_clone_metadata *cmd, unsigned long region_nr)
853 if (unlikely(region_nr >= cmd->nr_regions)) {
855 region_nr, cmd->nr_regions);
861 spin_lock_irqsave(&cmd->bitmap_lock, flags);
863 if (cmd->read_only) {
868 dmap = cmd->current_dmap;
872 __set_bit(region_nr, cmd->region_map);
876 spin_unlock_irqrestore(&cmd->bitmap_lock, flags);
881 int dm_clone_cond_set_range(struct dm_clone_metadata *cmd, unsigned long start,
888 if (unlikely(start >= cmd->nr_regions || (start + nr_regions) < start ||
889 (start + nr_regions) > cmd->nr_regions)) {
891 start, nr_regions, cmd->nr_regions);
895 spin_lock_irq(&cmd->bitmap_lock);
897 if (cmd->read_only) {
902 dmap = cmd->current_dmap;
904 if (!test_bit(region_nr, cmd->region_map)) {
908 __set_bit(region_nr, cmd->region_map);
913 spin_unlock_irq(&cmd->bitmap_lock);
921 * cmd->region_map without taking the cmd->bitmap_lock spinlock. The only
928 int dm_clone_reload_in_core_bitset(struct dm_clone_metadata *cmd)
932 down_write(&cmd->lock);
934 if (cmd->fail_io)
937 r = __load_bitset_in_core(cmd);
939 up_write(&cmd->lock);
944 bool dm_clone_changed_this_transaction(struct dm_clone_metadata *cmd)
949 spin_lock_irqsave(&cmd->bitmap_lock, flags);
950 r = cmd->dmap[0].changed || cmd->dmap[1].changed;
951 spin_unlock_irqrestore(&cmd->bitmap_lock, flags);
956 int dm_clone_metadata_abort(struct dm_clone_metadata *cmd)
960 down_write(&cmd->lock);
962 if (cmd->fail_io || dm_bm_is_read_only(cmd->bm))
965 __destroy_persistent_data_structures(cmd);
967 r = __create_persistent_data_structures(cmd, false);
970 cmd->fail_io = true;
973 up_write(&cmd->lock);
978 void dm_clone_metadata_set_read_only(struct dm_clone_metadata *cmd)
980 down_write(&cmd->lock);
982 spin_lock_irq(&cmd->bitmap_lock);
983 cmd->read_only = 1;
984 spin_unlock_irq(&cmd->bitmap_lock);
986 if (!cmd->fail_io)
987 dm_bm_set_read_only(cmd->bm);
989 up_write(&cmd->lock);
992 void dm_clone_metadata_set_read_write(struct dm_clone_metadata *cmd)
994 down_write(&cmd->lock);
996 spin_lock_irq(&cmd->bitmap_lock);
997 cmd->read_only = 0;
998 spin_unlock_irq(&cmd->bitmap_lock);
1000 if (!cmd->fail_io)
1001 dm_bm_set_read_write(cmd->bm);
1003 up_write(&cmd->lock);
1006 int dm_clone_get_free_metadata_block_count(struct dm_clone_metadata *cmd,
1011 down_read(&cmd->lock);
1013 if (!cmd->fail_io)
1014 r = dm_sm_get_nr_free(cmd->sm, result);
1016 up_read(&cmd->lock);
1021 int dm_clone_get_metadata_dev_size(struct dm_clone_metadata *cmd,
1026 down_read(&cmd->lock);
1028 if (!cmd->fail_io)
1029 r = dm_sm_get_nr_blocks(cmd->sm, result);
1031 up_read(&cmd->lock);