Lines Matching defs:zmd
207 #define dmz_zmd_info(zmd, format, args...) \
208 DMINFO("(%s): " format, (zmd)->label, ## args)
210 #define dmz_zmd_err(zmd, format, args...) \
211 DMERR("(%s): " format, (zmd)->label, ## args)
213 #define dmz_zmd_warn(zmd, format, args...) \
214 DMWARN("(%s): " format, (zmd)->label, ## args)
216 #define dmz_zmd_debug(zmd, format, args...) \
217 DMDEBUG("(%s): " format, (zmd)->label, ## args)
221 static unsigned int dmz_dev_zone_id(struct dmz_metadata *zmd, struct dm_zone *zone)
229 sector_t dmz_start_sect(struct dmz_metadata *zmd, struct dm_zone *zone)
231 unsigned int zone_id = dmz_dev_zone_id(zmd, zone);
233 return (sector_t)zone_id << zmd->zone_nr_sectors_shift;
236 sector_t dmz_start_block(struct dmz_metadata *zmd, struct dm_zone *zone)
238 unsigned int zone_id = dmz_dev_zone_id(zmd, zone);
240 return (sector_t)zone_id << zmd->zone_nr_blocks_shift;
243 unsigned int dmz_zone_nr_blocks(struct dmz_metadata *zmd)
245 return zmd->zone_nr_blocks;
248 unsigned int dmz_zone_nr_blocks_shift(struct dmz_metadata *zmd)
250 return zmd->zone_nr_blocks_shift;
253 unsigned int dmz_zone_nr_sectors(struct dmz_metadata *zmd)
255 return zmd->zone_nr_sectors;
258 unsigned int dmz_zone_nr_sectors_shift(struct dmz_metadata *zmd)
260 return zmd->zone_nr_sectors_shift;
263 unsigned int dmz_nr_zones(struct dmz_metadata *zmd)
265 return zmd->nr_zones;
268 unsigned int dmz_nr_chunks(struct dmz_metadata *zmd)
270 return zmd->nr_chunks;
273 unsigned int dmz_nr_rnd_zones(struct dmz_metadata *zmd, int idx)
275 return zmd->dev[idx].nr_rnd;
278 unsigned int dmz_nr_unmap_rnd_zones(struct dmz_metadata *zmd, int idx)
280 return atomic_read(&zmd->dev[idx].unmap_nr_rnd);
283 unsigned int dmz_nr_cache_zones(struct dmz_metadata *zmd)
285 return zmd->nr_cache;
288 unsigned int dmz_nr_unmap_cache_zones(struct dmz_metadata *zmd)
290 return atomic_read(&zmd->unmap_nr_cache);
293 unsigned int dmz_nr_seq_zones(struct dmz_metadata *zmd, int idx)
295 return zmd->dev[idx].nr_seq;
298 unsigned int dmz_nr_unmap_seq_zones(struct dmz_metadata *zmd, int idx)
300 return atomic_read(&zmd->dev[idx].unmap_nr_seq);
303 static struct dm_zone *dmz_get(struct dmz_metadata *zmd, unsigned int zone_id)
305 return xa_load(&zmd->zones, zone_id);
308 static struct dm_zone *dmz_insert(struct dmz_metadata *zmd,
316 if (xa_insert(&zmd->zones, zone_id, zone, GFP_KERNEL)) {
330 const char *dmz_metadata_label(struct dmz_metadata *zmd)
332 return (const char *)zmd->label;
335 bool dmz_check_dev(struct dmz_metadata *zmd)
339 for (i = 0; i < zmd->nr_devs; i++) {
340 if (!dmz_check_bdev(&zmd->dev[i]))
346 bool dmz_dev_is_dying(struct dmz_metadata *zmd)
350 for (i = 0; i < zmd->nr_devs; i++) {
351 if (dmz_bdev_is_dying(&zmd->dev[i]))
361 void dmz_lock_map(struct dmz_metadata *zmd)
363 mutex_lock(&zmd->map_lock);
366 void dmz_unlock_map(struct dmz_metadata *zmd)
368 mutex_unlock(&zmd->map_lock);
378 void dmz_lock_metadata(struct dmz_metadata *zmd)
380 down_read(&zmd->mblk_sem);
383 void dmz_unlock_metadata(struct dmz_metadata *zmd)
385 up_read(&zmd->mblk_sem);
393 void dmz_lock_flush(struct dmz_metadata *zmd)
395 mutex_lock(&zmd->mblk_flush_lock);
398 void dmz_unlock_flush(struct dmz_metadata *zmd)
400 mutex_unlock(&zmd->mblk_flush_lock);
406 static struct dmz_mblock *dmz_alloc_mblock(struct dmz_metadata *zmd,
412 if (zmd->max_nr_mblks && atomic_read(&zmd->nr_mblks) > zmd->max_nr_mblks) {
413 spin_lock(&zmd->mblk_lock);
414 mblk = list_first_entry_or_null(&zmd->mblk_lru_list,
418 rb_erase(&mblk->node, &zmd->mblk_rbtree);
421 spin_unlock(&zmd->mblk_lock);
444 atomic_inc(&zmd->nr_mblks);
452 static void dmz_free_mblock(struct dmz_metadata *zmd, struct dmz_mblock *mblk)
457 atomic_dec(&zmd->nr_mblks);
463 static void dmz_insert_mblock(struct dmz_metadata *zmd, struct dmz_mblock *mblk)
465 struct rb_root *root = &zmd->mblk_rbtree;
485 static struct dmz_mblock *dmz_get_mblock_fast(struct dmz_metadata *zmd,
488 struct rb_root *root = &zmd->mblk_rbtree;
537 static struct dmz_mblock *dmz_get_mblock_slow(struct dmz_metadata *zmd,
541 sector_t block = zmd->sb[zmd->mblk_primary].block + mblk_no;
542 struct dmz_dev *dev = zmd->sb[zmd->mblk_primary].dev;
549 mblk = dmz_alloc_mblock(zmd, mblk_no);
556 spin_lock(&zmd->mblk_lock);
562 m = dmz_get_mblock_fast(zmd, mblk_no);
564 spin_unlock(&zmd->mblk_lock);
565 dmz_free_mblock(zmd, mblk);
572 dmz_insert_mblock(zmd, mblk);
574 spin_unlock(&zmd->mblk_lock);
589 static unsigned long dmz_shrink_mblock_cache(struct dmz_metadata *zmd,
595 if (!zmd->max_nr_mblks)
598 while (!list_empty(&zmd->mblk_lru_list) &&
599 atomic_read(&zmd->nr_mblks) > zmd->min_nr_mblks &&
601 mblk = list_first_entry(&zmd->mblk_lru_list,
604 rb_erase(&mblk->node, &zmd->mblk_rbtree);
605 dmz_free_mblock(zmd, mblk);
618 struct dmz_metadata *zmd = container_of(shrink, struct dmz_metadata, mblk_shrinker);
620 return atomic_read(&zmd->nr_mblks);
629 struct dmz_metadata *zmd = container_of(shrink, struct dmz_metadata, mblk_shrinker);
632 spin_lock(&zmd->mblk_lock);
633 count = dmz_shrink_mblock_cache(zmd, sc->nr_to_scan);
634 spin_unlock(&zmd->mblk_lock);
642 static void dmz_release_mblock(struct dmz_metadata *zmd,
649 spin_lock(&zmd->mblk_lock);
654 rb_erase(&mblk->node, &zmd->mblk_rbtree);
655 dmz_free_mblock(zmd, mblk);
657 list_add_tail(&mblk->link, &zmd->mblk_lru_list);
658 dmz_shrink_mblock_cache(zmd, 1);
662 spin_unlock(&zmd->mblk_lock);
669 static struct dmz_mblock *dmz_get_mblock(struct dmz_metadata *zmd,
673 struct dmz_dev *dev = zmd->sb[zmd->mblk_primary].dev;
676 spin_lock(&zmd->mblk_lock);
677 mblk = dmz_get_mblock_fast(zmd, mblk_no);
678 spin_unlock(&zmd->mblk_lock);
682 mblk = dmz_get_mblock_slow(zmd, mblk_no);
691 dmz_release_mblock(zmd, mblk);
702 static void dmz_dirty_mblock(struct dmz_metadata *zmd, struct dmz_mblock *mblk)
704 spin_lock(&zmd->mblk_lock);
706 list_add_tail(&mblk->link, &zmd->mblk_dirty_list);
707 spin_unlock(&zmd->mblk_lock);
713 static int dmz_write_mblock(struct dmz_metadata *zmd, struct dmz_mblock *mblk,
716 struct dmz_dev *dev = zmd->sb[set].dev;
717 sector_t block = zmd->sb[set].block + mblk->no;
767 static int dmz_write_sb(struct dmz_metadata *zmd, unsigned int set)
769 struct dmz_mblock *mblk = zmd->sb[set].mblk;
770 struct dmz_super *sb = zmd->sb[set].sb;
771 struct dmz_dev *dev = zmd->sb[set].dev;
773 u64 sb_gen = zmd->sb_gen + 1;
778 sb->version = cpu_to_le32(zmd->sb_version);
779 if (zmd->sb_version > 1) {
781 export_uuid(sb->dmz_uuid, &zmd->uuid);
782 memcpy(sb->dmz_label, zmd->label, BDEVNAME_SIZE);
793 sb_block = zmd->sb[set].zone->id << zmd->zone_nr_blocks_shift;
795 sb->nr_meta_blocks = cpu_to_le32(zmd->nr_meta_blocks);
796 sb->nr_reserved_seq = cpu_to_le32(zmd->nr_reserved_seq);
797 sb->nr_chunks = cpu_to_le32(zmd->nr_chunks);
799 sb->nr_map_blocks = cpu_to_le32(zmd->nr_map_blocks);
800 sb->nr_bitmap_blocks = cpu_to_le32(zmd->nr_bitmap_blocks);
805 ret = dmz_rdwr_block(dev, REQ_OP_WRITE, zmd->sb[set].block,
816 static int dmz_write_dirty_mblocks(struct dmz_metadata *zmd,
821 struct dmz_dev *dev = zmd->sb[set].dev;
828 ret = dmz_write_mblock(zmd, mblk, set);
859 static int dmz_log_dirty_mblocks(struct dmz_metadata *zmd,
862 unsigned int log_set = zmd->mblk_primary ^ 0x1;
866 ret = dmz_write_dirty_mblocks(zmd, write_list, log_set);
874 ret = dmz_write_sb(zmd, log_set);
884 int dmz_flush_metadata(struct dmz_metadata *zmd)
891 if (WARN_ON(!zmd))
901 down_write(&zmd->mblk_sem);
902 dev = zmd->sb[zmd->mblk_primary].dev;
908 dmz_lock_flush(zmd);
916 spin_lock(&zmd->mblk_lock);
917 list_splice_init(&zmd->mblk_dirty_list, &write_list);
918 spin_unlock(&zmd->mblk_lock);
931 ret = dmz_log_dirty_mblocks(zmd, &write_list);
939 ret = dmz_write_dirty_mblocks(zmd, &write_list, zmd->mblk_primary);
943 ret = dmz_write_sb(zmd, zmd->mblk_primary);
951 spin_lock(&zmd->mblk_lock);
954 list_add_tail(&mblk->link, &zmd->mblk_lru_list);
955 spin_unlock(&zmd->mblk_lock);
958 zmd->sb_gen++;
960 dmz_unlock_flush(zmd);
961 up_write(&zmd->mblk_sem);
967 spin_lock(&zmd->mblk_lock);
968 list_splice(&write_list, &zmd->mblk_dirty_list);
969 spin_unlock(&zmd->mblk_lock);
979 static int dmz_check_sb(struct dmz_metadata *zmd, struct dmz_sb *dsb,
994 zmd->sb_version = le32_to_cpu(sb->version);
995 if (zmd->sb_version > DMZ_META_VER) {
997 DMZ_META_VER, zmd->sb_version);
1000 if (zmd->sb_version < 2 && tertiary) {
1016 if (sb_block != (u64)dsb->zone->id << zmd->zone_nr_blocks_shift) {
1018 sb_block, (u64)dsb->zone->id << zmd->zone_nr_blocks_shift);
1021 if (zmd->sb_version > 1) {
1028 } else if (uuid_is_null(&zmd->uuid)) {
1029 uuid_copy(&zmd->uuid, &sb_uuid);
1030 } else if (!uuid_equal(&zmd->uuid, &sb_uuid)) {
1032 &sb_uuid, &zmd->uuid);
1035 if (!strlen(zmd->label))
1036 memcpy(zmd->label, sb->dmz_label, BDEVNAME_SIZE);
1037 else if (memcmp(zmd->label, sb->dmz_label, BDEVNAME_SIZE)) {
1039 sb->dmz_label, zmd->label);
1060 nr_meta_zones = (le32_to_cpu(sb->nr_meta_blocks) + zmd->zone_nr_blocks - 1)
1061 >> zmd->zone_nr_blocks_shift;
1063 (zmd->nr_devs <= 1 && nr_meta_zones >= zmd->nr_rnd_zones) ||
1064 (zmd->nr_devs > 1 && nr_meta_zones >= zmd->nr_cache_zones)) {
1070 le32_to_cpu(sb->nr_reserved_seq) >= (zmd->nr_useable_zones - nr_meta_zones)) {
1075 nr_data_zones = zmd->nr_useable_zones -
1084 zmd->nr_meta_blocks = le32_to_cpu(sb->nr_meta_blocks);
1085 zmd->nr_reserved_seq = le32_to_cpu(sb->nr_reserved_seq);
1086 zmd->nr_chunks = le32_to_cpu(sb->nr_chunks);
1087 zmd->nr_map_blocks = le32_to_cpu(sb->nr_map_blocks);
1088 zmd->nr_bitmap_blocks = le32_to_cpu(sb->nr_bitmap_blocks);
1089 zmd->nr_meta_zones = nr_meta_zones;
1090 zmd->nr_data_zones = nr_data_zones;
1098 static int dmz_read_sb(struct dmz_metadata *zmd, struct dmz_sb *sb, int set)
1100 dmz_zmd_debug(zmd, "read superblock set %d dev %pg block %llu",
1112 static int dmz_lookup_secondary_sb(struct dmz_metadata *zmd)
1114 unsigned int zone_nr_blocks = zmd->zone_nr_blocks;
1116 unsigned int zone_id = zmd->sb[0].zone->id;
1120 mblk = dmz_alloc_mblock(zmd, 0);
1124 zmd->sb[1].mblk = mblk;
1125 zmd->sb[1].sb = mblk->data;
1128 zmd->sb[1].block = zmd->sb[0].block + zone_nr_blocks;
1129 zmd->sb[1].zone = dmz_get(zmd, zone_id + 1);
1130 zmd->sb[1].dev = zmd->sb[0].dev;
1131 for (i = 1; i < zmd->nr_rnd_zones; i++) {
1132 if (dmz_read_sb(zmd, &zmd->sb[1], 1) != 0)
1134 if (le32_to_cpu(zmd->sb[1].sb->magic) == DMZ_MAGIC)
1136 zmd->sb[1].block += zone_nr_blocks;
1137 zmd->sb[1].zone = dmz_get(zmd, zone_id + i);
1140 dmz_free_mblock(zmd, mblk);
1141 zmd->sb[1].mblk = NULL;
1142 zmd->sb[1].zone = NULL;
1143 zmd->sb[1].dev = NULL;
1151 static int dmz_get_sb(struct dmz_metadata *zmd, struct dmz_sb *sb, int set)
1157 mblk = dmz_alloc_mblock(zmd, 0);
1165 ret = dmz_read_sb(zmd, sb, set);
1167 dmz_free_mblock(zmd, mblk);
1178 static int dmz_recover_mblocks(struct dmz_metadata *zmd, unsigned int dst_set)
1184 dmz_dev_warn(zmd->sb[dst_set].dev,
1188 zmd->sb[0].block = dmz_start_block(zmd, zmd->sb[0].zone);
1190 zmd->sb[1].block = dmz_start_block(zmd, zmd->sb[1].zone);
1197 for (i = 1; i < zmd->nr_meta_blocks; i++) {
1198 ret = dmz_rdwr_block(zmd->sb[src_set].dev, REQ_OP_READ,
1199 zmd->sb[src_set].block + i, page);
1202 ret = dmz_rdwr_block(zmd->sb[dst_set].dev, REQ_OP_WRITE,
1203 zmd->sb[dst_set].block + i, page);
1209 if (!zmd->sb[dst_set].mblk) {
1210 zmd->sb[dst_set].mblk = dmz_alloc_mblock(zmd, 0);
1211 if (!zmd->sb[dst_set].mblk) {
1215 zmd->sb[dst_set].sb = zmd->sb[dst_set].mblk->data;
1218 ret = dmz_write_sb(zmd, dst_set);
1228 static int dmz_load_sb(struct dmz_metadata *zmd)
1234 if (!zmd->sb[0].zone) {
1235 dmz_zmd_err(zmd, "Primary super block zone not set");
1240 zmd->sb[0].block = dmz_start_block(zmd, zmd->sb[0].zone);
1241 zmd->sb[0].dev = zmd->sb[0].zone->dev;
1242 ret = dmz_get_sb(zmd, &zmd->sb[0], 0);
1244 dmz_dev_err(zmd->sb[0].dev, "Read primary super block failed");
1248 ret = dmz_check_sb(zmd, &zmd->sb[0], false);
1253 if (!zmd->sb[1].zone) {
1255 zmd->sb[0].zone->id + zmd->nr_meta_zones;
1257 zmd->sb[1].zone = dmz_get(zmd, zone_id);
1259 zmd->sb[1].block = dmz_start_block(zmd, zmd->sb[1].zone);
1260 zmd->sb[1].dev = zmd->sb[0].dev;
1261 ret = dmz_get_sb(zmd, &zmd->sb[1], 1);
1263 ret = dmz_lookup_secondary_sb(zmd);
1266 dmz_dev_err(zmd->sb[1].dev, "Read secondary super block failed");
1270 ret = dmz_check_sb(zmd, &zmd->sb[1], false);
1276 dmz_zmd_err(zmd, "No valid super block found");
1281 sb_gen[0] = le64_to_cpu(zmd->sb[0].sb->gen);
1283 ret = dmz_recover_mblocks(zmd, 0);
1285 dmz_dev_err(zmd->sb[0].dev,
1292 sb_gen[1] = le64_to_cpu(zmd->sb[1].sb->gen);
1294 ret = dmz_recover_mblocks(zmd, 1);
1297 dmz_dev_err(zmd->sb[1].dev,
1304 zmd->sb_gen = sb_gen[0];
1305 zmd->mblk_primary = 0;
1307 zmd->sb_gen = sb_gen[1];
1308 zmd->mblk_primary = 1;
1311 dmz_dev_debug(zmd->sb[zmd->mblk_primary].dev,
1313 zmd->mblk_primary, zmd->sb_gen);
1315 if (zmd->sb_version > 1) {
1322 for (i = 1; i < zmd->nr_devs; i++) {
1324 sb->zone = dmz_get(zmd, zmd->dev[i].zone_offset);
1325 sb->dev = &zmd->dev[i];
1333 ret = dmz_get_sb(zmd, sb, i + 1);
1337 dmz_free_mblock(zmd, sb->mblk);
1340 ret = dmz_check_sb(zmd, sb, true);
1341 dmz_free_mblock(zmd, sb->mblk);
1357 struct dmz_metadata *zmd = dev->metadata;
1361 zone = dmz_insert(zmd, idx, dev);
1365 if (blkz->len != zmd->zone_nr_sectors) {
1366 if (zmd->sb_version > 1) {
1404 zmd->nr_useable_zones++;
1406 zmd->nr_rnd_zones++;
1407 if (zmd->nr_devs == 1 && !zmd->sb[0].zone) {
1409 zmd->sb[0].zone = zone;
1412 if (zmd->nr_devs > 1 && num == 0) {
1424 static int dmz_emulate_zones(struct dmz_metadata *zmd, struct dmz_dev *dev)
1432 zone = dmz_insert(zmd, idx, dev);
1437 zmd->nr_cache_zones++;
1438 zmd->nr_useable_zones++;
1439 if (dev->capacity - zone_offset < zmd->zone_nr_sectors) {
1444 zone_offset += zmd->zone_nr_sectors;
1452 static void dmz_drop_zones(struct dmz_metadata *zmd)
1456 for (idx = 0; idx < zmd->nr_zones; idx++) {
1457 struct dm_zone *zone = xa_load(&zmd->zones, idx);
1460 xa_erase(&zmd->zones, idx);
1462 xa_destroy(&zmd->zones);
1469 static int dmz_init_zones(struct dmz_metadata *zmd)
1472 struct dmz_dev *zoned_dev = &zmd->dev[0];
1475 zmd->zone_nr_sectors = zmd->dev[0].zone_nr_sectors;
1476 zmd->zone_nr_sectors_shift = ilog2(zmd->zone_nr_sectors);
1477 zmd->zone_nr_blocks = dmz_sect2blk(zmd->zone_nr_sectors);
1478 zmd->zone_nr_blocks_shift = ilog2(zmd->zone_nr_blocks);
1479 zmd->zone_bitmap_size = zmd->zone_nr_blocks >> 3;
1480 zmd->zone_nr_bitmap_blocks =
1481 max_t(sector_t, 1, zmd->zone_bitmap_size >> DMZ_BLOCK_SHIFT);
1482 zmd->zone_bits_per_mblk = min_t(sector_t, zmd->zone_nr_blocks,
1486 zmd->nr_zones = 0;
1487 for (i = 0; i < zmd->nr_devs; i++) {
1488 struct dmz_dev *dev = &zmd->dev[i];
1490 dev->metadata = zmd;
1491 zmd->nr_zones += dev->nr_zones;
1502 if (!zmd->nr_zones) {
1503 DMERR("(%s): No zones found", zmd->devname);
1506 xa_init(&zmd->zones);
1509 zmd->devname, sizeof(struct dm_zone) * zmd->nr_zones);
1511 if (zmd->nr_devs > 1) {
1512 ret = dmz_emulate_zones(zmd, &zmd->dev[0]);
1515 zmd->devname, ret);
1516 dmz_drop_zones(zmd);
1524 zmd->sb[0].zone = dmz_get(zmd, 0);
1526 for (i = 1; i < zmd->nr_devs; i++) {
1527 zoned_dev = &zmd->dev[i];
1534 zmd->devname, ret);
1535 dmz_drop_zones(zmd);
1551 zmd->devname, ret);
1552 dmz_drop_zones(zmd);
1581 static int dmz_update_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
1597 ret = blkdev_report_zones(dev->bdev, dmz_start_sect(zmd, zone), 1,
1617 static int dmz_handle_seq_write_err(struct dmz_metadata *zmd,
1625 ret = dmz_update_zone(zmd, zone);
1633 dmz_invalidate_blocks(zmd, zone, zone->wp_block,
1643 static int dmz_reset_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
1660 dmz_start_sect(zmd, zone),
1661 zmd->zone_nr_sectors, GFP_NOIO);
1676 static void dmz_get_zone_weight(struct dmz_metadata *zmd, struct dm_zone *zone);
1681 static int dmz_load_mapping(struct dmz_metadata *zmd)
1691 zmd->map_mblk = kcalloc(zmd->nr_map_blocks,
1693 if (!zmd->map_mblk)
1697 while (chunk < zmd->nr_chunks) {
1700 dmap_mblk = dmz_get_mblock(zmd, i + 1);
1703 zmd->map_mblk[i] = dmap_mblk;
1714 if (dzone_id >= zmd->nr_zones) {
1715 dmz_zmd_err(zmd, "Chunk %u mapping: invalid data zone ID %u",
1720 dzone = dmz_get(zmd, dzone_id);
1722 dmz_zmd_err(zmd, "Chunk %u mapping: data zone %u not present",
1728 dmz_get_zone_weight(zmd, dzone);
1731 list_add_tail(&dzone->link, &zmd->map_cache_list);
1742 if (bzone_id >= zmd->nr_zones) {
1743 dmz_zmd_err(zmd, "Chunk %u mapping: invalid buffer zone ID %u",
1748 bzone = dmz_get(zmd, bzone_id);
1750 dmz_zmd_err(zmd, "Chunk %u mapping: buffer zone %u not present",
1755 dmz_zmd_err(zmd, "Chunk %u mapping: invalid buffer zone %u",
1765 dmz_get_zone_weight(zmd, bzone);
1767 list_add_tail(&bzone->link, &zmd->map_cache_list);
1782 for (i = 0; i < zmd->nr_zones; i++) {
1783 dzone = dmz_get(zmd, i);
1792 zmd->nr_cache++;
1807 list_add_tail(&dzone->link, &zmd->unmap_cache_list);
1808 atomic_inc(&zmd->unmap_nr_cache);
1813 } else if (atomic_read(&zmd->nr_reserved_seq_zones) < zmd->nr_reserved_seq) {
1814 list_add_tail(&dzone->link, &zmd->reserved_seq_zones_list);
1816 atomic_inc(&zmd->nr_reserved_seq_zones);
1831 static void dmz_set_chunk_mapping(struct dmz_metadata *zmd, unsigned int chunk,
1834 struct dmz_mblock *dmap_mblk = zmd->map_mblk[chunk >> DMZ_MAP_ENTRIES_SHIFT];
1840 dmz_dirty_mblock(zmd, dmap_mblk);
1847 static void __dmz_lru_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
1858 list_add_tail(&zone->link, &zmd->map_cache_list);
1869 static void dmz_lru_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
1871 __dmz_lru_zone(zmd, zone);
1873 __dmz_lru_zone(zmd, zone->bzone);
1879 static void dmz_wait_for_free_zones(struct dmz_metadata *zmd)
1883 prepare_to_wait(&zmd->free_wq, &wait, TASK_UNINTERRUPTIBLE);
1884 dmz_unlock_map(zmd);
1885 dmz_unlock_metadata(zmd);
1889 dmz_lock_metadata(zmd);
1890 dmz_lock_map(zmd);
1891 finish_wait(&zmd->free_wq, &wait);
1924 static void dmz_wait_for_reclaim(struct dmz_metadata *zmd, struct dm_zone *zone)
1926 dmz_unlock_map(zmd);
1927 dmz_unlock_metadata(zmd);
1931 dmz_lock_metadata(zmd);
1932 dmz_lock_map(zmd);
1938 static struct dm_zone *dmz_get_rnd_zone_for_reclaim(struct dmz_metadata *zmd,
1946 if (zmd->nr_cache) {
1947 zone_list = &zmd->map_cache_list;
1950 zone_list = &zmd->dev[idx].map_rnd_list;
1952 zone_list = &zmd->dev[idx].map_rnd_list;
1997 static struct dm_zone *dmz_get_seq_zone_for_reclaim(struct dmz_metadata *zmd,
2002 list_for_each_entry(zone, &zmd->dev[idx].map_seq_list, link) {
2015 struct dm_zone *dmz_get_zone_for_reclaim(struct dmz_metadata *zmd,
2028 dmz_lock_map(zmd);
2029 if (list_empty(&zmd->reserved_seq_zones_list))
2030 zone = dmz_get_seq_zone_for_reclaim(zmd, dev_idx);
2032 zone = dmz_get_rnd_zone_for_reclaim(zmd, dev_idx, idle);
2033 dmz_unlock_map(zmd);
2044 struct dm_zone *dmz_get_chunk_mapping(struct dmz_metadata *zmd,
2047 struct dmz_mblock *dmap_mblk = zmd->map_mblk[chunk >> DMZ_MAP_ENTRIES_SHIFT];
2053 int alloc_flags = zmd->nr_cache ? DMZ_ALLOC_CACHE : DMZ_ALLOC_RND;
2055 dmz_lock_map(zmd);
2068 dzone = dmz_alloc_zone(zmd, 0, alloc_flags);
2070 if (dmz_dev_is_dying(zmd)) {
2074 dmz_wait_for_free_zones(zmd);
2078 dmz_map_zone(zmd, dzone, chunk);
2082 dzone = dmz_get(zmd, dzone_id);
2094 ret = dmz_handle_seq_write_err(zmd, dzone);
2109 dmz_wait_for_reclaim(zmd, dzone);
2113 dmz_lru_zone(zmd, dzone);
2115 dmz_unlock_map(zmd);
2126 void dmz_put_chunk_mapping(struct dmz_metadata *zmd, struct dm_zone *dzone)
2130 dmz_lock_map(zmd);
2135 dmz_lru_zone(zmd, bzone);
2138 dmz_unmap_zone(zmd, bzone);
2139 dmz_free_zone(zmd, bzone);
2147 dmz_lru_zone(zmd, dzone);
2150 dmz_unmap_zone(zmd, dzone);
2151 dmz_free_zone(zmd, dzone);
2154 dmz_unlock_map(zmd);
2161 struct dm_zone *dmz_get_chunk_buffer(struct dmz_metadata *zmd,
2165 int alloc_flags = zmd->nr_cache ? DMZ_ALLOC_CACHE : DMZ_ALLOC_RND;
2167 dmz_lock_map(zmd);
2174 bzone = dmz_alloc_zone(zmd, 0, alloc_flags);
2176 if (dmz_dev_is_dying(zmd)) {
2180 dmz_wait_for_free_zones(zmd);
2185 dmz_set_chunk_mapping(zmd, dzone->chunk, dzone->id, bzone->id);
2192 list_add_tail(&bzone->link, &zmd->map_cache_list);
2196 dmz_unlock_map(zmd);
2205 struct dm_zone *dmz_alloc_zone(struct dmz_metadata *zmd, unsigned int dev_idx,
2214 for (i = 0; i < zmd->nr_devs; i++)
2215 dmz_schedule_reclaim(zmd->dev[i].reclaim);
2221 list = &zmd->unmap_cache_list;
2223 list = &zmd->dev[dev_idx].unmap_rnd_list;
2225 list = &zmd->dev[dev_idx].unmap_seq_list;
2236 if (i < zmd->nr_devs) {
2237 dev_idx = (dev_idx + 1) % zmd->nr_devs;
2245 zone = list_first_entry_or_null(&zmd->reserved_seq_zones_list,
2249 atomic_dec(&zmd->nr_reserved_seq_zones);
2258 atomic_dec(&zmd->unmap_nr_cache);
2265 dmz_zmd_warn(zmd, "Zone %u is offline", zone->id);
2270 dmz_zmd_warn(zmd, "Zone %u has metadata", zone->id);
2281 void dmz_free_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
2285 dmz_reset_zone(zmd, zone);
2289 list_add_tail(&zone->link, &zmd->unmap_cache_list);
2290 atomic_inc(&zmd->unmap_nr_cache);
2295 list_add_tail(&zone->link, &zmd->reserved_seq_zones_list);
2296 atomic_inc(&zmd->nr_reserved_seq_zones);
2302 wake_up_all(&zmd->free_wq);
2309 void dmz_map_zone(struct dmz_metadata *zmd, struct dm_zone *dzone,
2313 dmz_set_chunk_mapping(zmd, chunk, dzone->id,
2317 list_add_tail(&dzone->link, &zmd->map_cache_list);
2328 void dmz_unmap_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
2359 dmz_set_chunk_mapping(zmd, chunk, dzone_id, DMZ_MAP_UNMAPPED);
2400 static struct dmz_mblock *dmz_get_bitmap(struct dmz_metadata *zmd,
2404 sector_t bitmap_block = 1 + zmd->nr_map_blocks +
2405 (sector_t)(zone->id * zmd->zone_nr_bitmap_blocks) +
2408 return dmz_get_mblock(zmd, bitmap_block);
2414 int dmz_copy_valid_blocks(struct dmz_metadata *zmd, struct dm_zone *from_zone,
2421 while (chunk_block < zmd->zone_nr_blocks) {
2422 from_mblk = dmz_get_bitmap(zmd, from_zone, chunk_block);
2425 to_mblk = dmz_get_bitmap(zmd, to_zone, chunk_block);
2427 dmz_release_mblock(zmd, from_mblk);
2432 dmz_dirty_mblock(zmd, to_mblk);
2434 dmz_release_mblock(zmd, to_mblk);
2435 dmz_release_mblock(zmd, from_mblk);
2437 chunk_block += zmd->zone_bits_per_mblk;
2449 int dmz_merge_valid_blocks(struct dmz_metadata *zmd, struct dm_zone *from_zone,
2456 while (chunk_block < zmd->zone_nr_blocks) {
2458 ret = dmz_first_valid_block(zmd, from_zone, &chunk_block);
2463 ret = dmz_validate_blocks(zmd, to_zone, chunk_block, nr_blocks);
2476 int dmz_validate_blocks(struct dmz_metadata *zmd, struct dm_zone *zone,
2480 unsigned int zone_nr_blocks = zmd->zone_nr_blocks;
2484 dmz_zmd_debug(zmd, "=> VALIDATE zone %u, block %llu, %u blocks",
2492 mblk = dmz_get_bitmap(zmd, zone, chunk_block);
2498 nr_bits = min(nr_blocks, zmd->zone_bits_per_mblk - bit);
2502 dmz_dirty_mblock(zmd, mblk);
2505 dmz_release_mblock(zmd, mblk);
2514 dmz_zmd_warn(zmd, "Zone %u: weight %u should be <= %u",
2557 int dmz_invalidate_blocks(struct dmz_metadata *zmd, struct dm_zone *zone,
2564 dmz_zmd_debug(zmd, "=> INVALIDATE zone %u, block %llu, %u blocks",
2567 WARN_ON(chunk_block + nr_blocks > zmd->zone_nr_blocks);
2571 mblk = dmz_get_bitmap(zmd, zone, chunk_block);
2577 nr_bits = min(nr_blocks, zmd->zone_bits_per_mblk - bit);
2582 dmz_dirty_mblock(zmd, mblk);
2585 dmz_release_mblock(zmd, mblk);
2594 dmz_zmd_warn(zmd, "Zone %u: weight %u should be >= %u",
2605 static int dmz_test_block(struct dmz_metadata *zmd, struct dm_zone *zone,
2611 WARN_ON(chunk_block >= zmd->zone_nr_blocks);
2614 mblk = dmz_get_bitmap(zmd, zone, chunk_block);
2622 dmz_release_mblock(zmd, mblk);
2631 static int dmz_to_next_set_block(struct dmz_metadata *zmd, struct dm_zone *zone,
2637 unsigned int zone_bits = zmd->zone_bits_per_mblk;
2641 WARN_ON(chunk_block + nr_blocks > zmd->zone_nr_blocks);
2645 mblk = dmz_get_bitmap(zmd, zone, chunk_block);
2657 dmz_release_mblock(zmd, mblk);
2674 int dmz_block_valid(struct dmz_metadata *zmd, struct dm_zone *zone,
2679 valid = dmz_test_block(zmd, zone, chunk_block);
2684 return dmz_to_next_set_block(zmd, zone, chunk_block,
2685 zmd->zone_nr_blocks - chunk_block, 0);
2694 int dmz_first_valid_block(struct dmz_metadata *zmd, struct dm_zone *zone,
2700 ret = dmz_to_next_set_block(zmd, zone, start_block,
2701 zmd->zone_nr_blocks - start_block, 1);
2708 return dmz_to_next_set_block(zmd, zone, start_block,
2709 zmd->zone_nr_blocks - start_block, 0);
2743 static void dmz_get_zone_weight(struct dmz_metadata *zmd, struct dm_zone *zone)
2748 unsigned int nr_blocks = zmd->zone_nr_blocks;
2754 mblk = dmz_get_bitmap(zmd, zone, chunk_block);
2763 nr_bits = min(nr_blocks, zmd->zone_bits_per_mblk - bit);
2766 dmz_release_mblock(zmd, mblk);
2778 static void dmz_cleanup_metadata(struct dmz_metadata *zmd)
2785 if (zmd->map_mblk) {
2786 for (i = 0; i < zmd->nr_map_blocks; i++)
2787 dmz_release_mblock(zmd, zmd->map_mblk[i]);
2788 kfree(zmd->map_mblk);
2789 zmd->map_mblk = NULL;
2794 if (zmd->sb[i].mblk) {
2795 dmz_free_mblock(zmd, zmd->sb[i].mblk);
2796 zmd->sb[i].mblk = NULL;
2801 while (!list_empty(&zmd->mblk_dirty_list)) {
2802 mblk = list_first_entry(&zmd->mblk_dirty_list,
2804 dmz_zmd_warn(zmd, "mblock %llu still in dirty list (ref %u)",
2807 rb_erase(&mblk->node, &zmd->mblk_rbtree);
2808 dmz_free_mblock(zmd, mblk);
2811 while (!list_empty(&zmd->mblk_lru_list)) {
2812 mblk = list_first_entry(&zmd->mblk_lru_list,
2815 rb_erase(&mblk->node, &zmd->mblk_rbtree);
2816 dmz_free_mblock(zmd, mblk);
2820 root = &zmd->mblk_rbtree;
2822 dmz_zmd_warn(zmd, "mblock %llu ref %u still in rbtree",
2825 dmz_free_mblock(zmd, mblk);
2829 dmz_drop_zones(zmd);
2831 mutex_destroy(&zmd->mblk_flush_lock);
2832 mutex_destroy(&zmd->map_lock);
2835 static void dmz_print_dev(struct dmz_metadata *zmd, int num)
2837 struct dmz_dev *dev = &zmd->dev[num];
2845 if (zmd->sb_version > 1) {
2847 dev->zone_offset << zmd->zone_nr_sectors_shift;
2852 dev->nr_zones, (u64)zmd->zone_nr_sectors,
2858 dev->nr_zones, (u64)zmd->zone_nr_sectors);
2869 struct dmz_metadata *zmd;
2874 zmd = kzalloc(sizeof(struct dmz_metadata), GFP_KERNEL);
2875 if (!zmd)
2878 strcpy(zmd->devname, devname);
2879 zmd->dev = dev;
2880 zmd->nr_devs = num_dev;
2881 zmd->mblk_rbtree = RB_ROOT;
2882 init_rwsem(&zmd->mblk_sem);
2883 mutex_init(&zmd->mblk_flush_lock);
2884 spin_lock_init(&zmd->mblk_lock);
2885 INIT_LIST_HEAD(&zmd->mblk_lru_list);
2886 INIT_LIST_HEAD(&zmd->mblk_dirty_list);
2888 mutex_init(&zmd->map_lock);
2890 atomic_set(&zmd->unmap_nr_cache, 0);
2891 INIT_LIST_HEAD(&zmd->unmap_cache_list);
2892 INIT_LIST_HEAD(&zmd->map_cache_list);
2894 atomic_set(&zmd->nr_reserved_seq_zones, 0);
2895 INIT_LIST_HEAD(&zmd->reserved_seq_zones_list);
2897 init_waitqueue_head(&zmd->free_wq);
2900 ret = dmz_init_zones(zmd);
2905 ret = dmz_load_sb(zmd);
2910 for (i = 0; i < zmd->nr_meta_zones << 1; i++) {
2911 zone = dmz_get(zmd, zmd->sb[0].zone->id + i);
2913 dmz_zmd_err(zmd,
2919 dmz_zmd_err(zmd,
2927 ret = dmz_load_mapping(zmd);
2937 zmd->min_nr_mblks = 2 + zmd->nr_map_blocks + zmd->zone_nr_bitmap_blocks * 16;
2938 zmd->max_nr_mblks = zmd->min_nr_mblks + 512;
2939 zmd->mblk_shrinker.count_objects = dmz_mblock_shrinker_count;
2940 zmd->mblk_shrinker.scan_objects = dmz_mblock_shrinker_scan;
2941 zmd->mblk_shrinker.seeks = DEFAULT_SEEKS;
2944 ret = register_shrinker(&zmd->mblk_shrinker, "dm-zoned-meta:(%u:%u)",
2948 dmz_zmd_err(zmd, "Register metadata cache shrinker failed");
2952 dmz_zmd_info(zmd, "DM-Zoned metadata version %d", zmd->sb_version);
2953 for (i = 0; i < zmd->nr_devs; i++)
2954 dmz_print_dev(zmd, i);
2956 dmz_zmd_info(zmd, " %u zones of %llu 512-byte logical sectors",
2957 zmd->nr_zones, (u64)zmd->zone_nr_sectors);
2958 dmz_zmd_debug(zmd, " %u metadata zones",
2959 zmd->nr_meta_zones * 2);
2960 dmz_zmd_debug(zmd, " %u data zones for %u chunks",
2961 zmd->nr_data_zones, zmd->nr_chunks);
2962 dmz_zmd_debug(zmd, " %u cache zones (%u unmapped)",
2963 zmd->nr_cache, atomic_read(&zmd->unmap_nr_cache));
2964 for (i = 0; i < zmd->nr_devs; i++) {
2965 dmz_zmd_debug(zmd, " %u random zones (%u unmapped)",
2966 dmz_nr_rnd_zones(zmd, i),
2967 dmz_nr_unmap_rnd_zones(zmd, i));
2968 dmz_zmd_debug(zmd, " %u sequential zones (%u unmapped)",
2969 dmz_nr_seq_zones(zmd, i),
2970 dmz_nr_unmap_seq_zones(zmd, i));
2972 dmz_zmd_debug(zmd, " %u reserved sequential data zones",
2973 zmd->nr_reserved_seq);
2974 dmz_zmd_debug(zmd, "Format:");
2975 dmz_zmd_debug(zmd, "%u metadata blocks per set (%u max cache)",
2976 zmd->nr_meta_blocks, zmd->max_nr_mblks);
2977 dmz_zmd_debug(zmd, " %u data zone mapping blocks",
2978 zmd->nr_map_blocks);
2979 dmz_zmd_debug(zmd, " %u bitmap blocks",
2980 zmd->nr_bitmap_blocks);
2982 *metadata = zmd;
2986 dmz_cleanup_metadata(zmd);
2987 kfree(zmd);
2996 void dmz_dtr_metadata(struct dmz_metadata *zmd)
2998 unregister_shrinker(&zmd->mblk_shrinker);
2999 dmz_cleanup_metadata(zmd);
3000 kfree(zmd);
3006 int dmz_resume_metadata(struct dmz_metadata *zmd)
3014 for (i = 0; i < zmd->nr_zones; i++) {
3015 zone = dmz_get(zmd, i);
3017 dmz_zmd_err(zmd, "Unable to get zone %u", i);
3022 ret = dmz_update_zone(zmd, zone);
3024 dmz_zmd_err(zmd, "Broken zone %u", i);
3029 dmz_zmd_warn(zmd, "Zone %u is offline", i);
3037 dmz_zmd_err(zmd, "Zone %u: Invalid wp (%llu / %llu)",
3040 dmz_invalidate_blocks(zmd, zone, zone->wp_block,
3041 zmd->zone_nr_blocks - zone->wp_block);