Lines Matching refs: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);
555 dmz_free_mblock(zmd, mblk);
559 spin_lock(&zmd->mblk_lock);
565 m = dmz_get_mblock_fast(zmd, mblk_no);
567 spin_unlock(&zmd->mblk_lock);
568 dmz_free_mblock(zmd, mblk);
575 dmz_insert_mblock(zmd, mblk);
577 spin_unlock(&zmd->mblk_lock);
594 static unsigned long dmz_shrink_mblock_cache(struct dmz_metadata *zmd,
600 if (!zmd->max_nr_mblks)
603 while (!list_empty(&zmd->mblk_lru_list) &&
604 atomic_read(&zmd->nr_mblks) > zmd->min_nr_mblks &&
606 mblk = list_first_entry(&zmd->mblk_lru_list,
609 rb_erase(&mblk->node, &zmd->mblk_rbtree);
610 dmz_free_mblock(zmd, mblk);
623 struct dmz_metadata *zmd = container_of(shrink, struct dmz_metadata, mblk_shrinker);
625 return atomic_read(&zmd->nr_mblks);
634 struct dmz_metadata *zmd = container_of(shrink, struct dmz_metadata, mblk_shrinker);
637 spin_lock(&zmd->mblk_lock);
638 count = dmz_shrink_mblock_cache(zmd, sc->nr_to_scan);
639 spin_unlock(&zmd->mblk_lock);
647 static void dmz_release_mblock(struct dmz_metadata *zmd,
654 spin_lock(&zmd->mblk_lock);
659 rb_erase(&mblk->node, &zmd->mblk_rbtree);
660 dmz_free_mblock(zmd, mblk);
662 list_add_tail(&mblk->link, &zmd->mblk_lru_list);
663 dmz_shrink_mblock_cache(zmd, 1);
667 spin_unlock(&zmd->mblk_lock);
674 static struct dmz_mblock *dmz_get_mblock(struct dmz_metadata *zmd,
678 struct dmz_dev *dev = zmd->sb[zmd->mblk_primary].dev;
681 spin_lock(&zmd->mblk_lock);
682 mblk = dmz_get_mblock_fast(zmd, mblk_no);
683 spin_unlock(&zmd->mblk_lock);
687 mblk = dmz_get_mblock_slow(zmd, mblk_no);
696 dmz_release_mblock(zmd, mblk);
707 static void dmz_dirty_mblock(struct dmz_metadata *zmd, struct dmz_mblock *mblk)
709 spin_lock(&zmd->mblk_lock);
711 list_add_tail(&mblk->link, &zmd->mblk_dirty_list);
712 spin_unlock(&zmd->mblk_lock);
718 static int dmz_write_mblock(struct dmz_metadata *zmd, struct dmz_mblock *mblk,
721 struct dmz_dev *dev = zmd->sb[set].dev;
722 sector_t block = zmd->sb[set].block + mblk->no;
781 static int dmz_write_sb(struct dmz_metadata *zmd, unsigned int set)
783 struct dmz_mblock *mblk = zmd->sb[set].mblk;
784 struct dmz_super *sb = zmd->sb[set].sb;
785 struct dmz_dev *dev = zmd->sb[set].dev;
787 u64 sb_gen = zmd->sb_gen + 1;
792 sb->version = cpu_to_le32(zmd->sb_version);
793 if (zmd->sb_version > 1) {
795 export_uuid(sb->dmz_uuid, &zmd->uuid);
796 memcpy(sb->dmz_label, zmd->label, BDEVNAME_SIZE);
807 sb_block = zmd->sb[set].zone->id << zmd->zone_nr_blocks_shift;
809 sb->nr_meta_blocks = cpu_to_le32(zmd->nr_meta_blocks);
810 sb->nr_reserved_seq = cpu_to_le32(zmd->nr_reserved_seq);
811 sb->nr_chunks = cpu_to_le32(zmd->nr_chunks);
813 sb->nr_map_blocks = cpu_to_le32(zmd->nr_map_blocks);
814 sb->nr_bitmap_blocks = cpu_to_le32(zmd->nr_bitmap_blocks);
819 ret = dmz_rdwr_block(dev, REQ_OP_WRITE, zmd->sb[set].block,
830 static int dmz_write_dirty_mblocks(struct dmz_metadata *zmd,
835 struct dmz_dev *dev = zmd->sb[set].dev;
842 ret = dmz_write_mblock(zmd, mblk, set);
873 static int dmz_log_dirty_mblocks(struct dmz_metadata *zmd,
876 unsigned int log_set = zmd->mblk_primary ^ 0x1;
880 ret = dmz_write_dirty_mblocks(zmd, write_list, log_set);
888 ret = dmz_write_sb(zmd, log_set);
898 int dmz_flush_metadata(struct dmz_metadata *zmd)
905 if (WARN_ON(!zmd))
915 down_write(&zmd->mblk_sem);
916 dev = zmd->sb[zmd->mblk_primary].dev;
922 dmz_lock_flush(zmd);
930 spin_lock(&zmd->mblk_lock);
931 list_splice_init(&zmd->mblk_dirty_list, &write_list);
932 spin_unlock(&zmd->mblk_lock);
945 ret = dmz_log_dirty_mblocks(zmd, &write_list);
953 ret = dmz_write_dirty_mblocks(zmd, &write_list, zmd->mblk_primary);
957 ret = dmz_write_sb(zmd, zmd->mblk_primary);
965 spin_lock(&zmd->mblk_lock);
968 list_add_tail(&mblk->link, &zmd->mblk_lru_list);
969 spin_unlock(&zmd->mblk_lock);
972 zmd->sb_gen++;
974 dmz_unlock_flush(zmd);
975 up_write(&zmd->mblk_sem);
981 spin_lock(&zmd->mblk_lock);
982 list_splice(&write_list, &zmd->mblk_dirty_list);
983 spin_unlock(&zmd->mblk_lock);
993 static int dmz_check_sb(struct dmz_metadata *zmd, struct dmz_sb *dsb,
1008 zmd->sb_version = le32_to_cpu(sb->version);
1009 if (zmd->sb_version > DMZ_META_VER) {
1011 DMZ_META_VER, zmd->sb_version);
1014 if (zmd->sb_version < 2 && tertiary) {
1030 if (sb_block != (u64)dsb->zone->id << zmd->zone_nr_blocks_shift ) {
1034 (u64)dsb->zone->id << zmd->zone_nr_blocks_shift);
1037 if (zmd->sb_version > 1) {
1044 } else if (uuid_is_null(&zmd->uuid)) {
1045 uuid_copy(&zmd->uuid, &sb_uuid);
1046 } else if (!uuid_equal(&zmd->uuid, &sb_uuid)) {
1049 &sb_uuid, &zmd->uuid);
1052 if (!strlen(zmd->label))
1053 memcpy(zmd->label, sb->dmz_label, BDEVNAME_SIZE);
1054 else if (memcmp(zmd->label, sb->dmz_label, BDEVNAME_SIZE)) {
1057 sb->dmz_label, zmd->label);
1078 nr_meta_zones = (le32_to_cpu(sb->nr_meta_blocks) + zmd->zone_nr_blocks - 1)
1079 >> zmd->zone_nr_blocks_shift;
1081 (zmd->nr_devs <= 1 && nr_meta_zones >= zmd->nr_rnd_zones) ||
1082 (zmd->nr_devs > 1 && nr_meta_zones >= zmd->nr_cache_zones)) {
1088 le32_to_cpu(sb->nr_reserved_seq) >= (zmd->nr_useable_zones - nr_meta_zones)) {
1093 nr_data_zones = zmd->nr_useable_zones -
1102 zmd->nr_meta_blocks = le32_to_cpu(sb->nr_meta_blocks);
1103 zmd->nr_reserved_seq = le32_to_cpu(sb->nr_reserved_seq);
1104 zmd->nr_chunks = le32_to_cpu(sb->nr_chunks);
1105 zmd->nr_map_blocks = le32_to_cpu(sb->nr_map_blocks);
1106 zmd->nr_bitmap_blocks = le32_to_cpu(sb->nr_bitmap_blocks);
1107 zmd->nr_meta_zones = nr_meta_zones;
1108 zmd->nr_data_zones = nr_data_zones;
1116 static int dmz_read_sb(struct dmz_metadata *zmd, struct dmz_sb *sb, int set)
1118 dmz_zmd_debug(zmd, "read superblock set %d dev %s block %llu",
1130 static int dmz_lookup_secondary_sb(struct dmz_metadata *zmd)
1132 unsigned int zone_nr_blocks = zmd->zone_nr_blocks;
1134 unsigned int zone_id = zmd->sb[0].zone->id;
1138 mblk = dmz_alloc_mblock(zmd, 0);
1142 zmd->sb[1].mblk = mblk;
1143 zmd->sb[1].sb = mblk->data;
1146 zmd->sb[1].block = zmd->sb[0].block + zone_nr_blocks;
1147 zmd->sb[1].zone = dmz_get(zmd, zone_id + 1);
1148 zmd->sb[1].dev = zmd->sb[0].dev;
1149 for (i = 1; i < zmd->nr_rnd_zones; i++) {
1150 if (dmz_read_sb(zmd, &zmd->sb[1], 1) != 0)
1152 if (le32_to_cpu(zmd->sb[1].sb->magic) == DMZ_MAGIC)
1154 zmd->sb[1].block += zone_nr_blocks;
1155 zmd->sb[1].zone = dmz_get(zmd, zone_id + i);
1158 dmz_free_mblock(zmd, mblk);
1159 zmd->sb[1].mblk = NULL;
1160 zmd->sb[1].zone = NULL;
1161 zmd->sb[1].dev = NULL;
1169 static int dmz_get_sb(struct dmz_metadata *zmd, struct dmz_sb *sb, int set)
1175 mblk = dmz_alloc_mblock(zmd, 0);
1183 ret = dmz_read_sb(zmd, sb, set);
1185 dmz_free_mblock(zmd, mblk);
1196 static int dmz_recover_mblocks(struct dmz_metadata *zmd, unsigned int dst_set)
1202 dmz_dev_warn(zmd->sb[dst_set].dev,
1206 zmd->sb[0].block = dmz_start_block(zmd, zmd->sb[0].zone);
1208 zmd->sb[1].block = dmz_start_block(zmd, zmd->sb[1].zone);
1215 for (i = 1; i < zmd->nr_meta_blocks; i++) {
1216 ret = dmz_rdwr_block(zmd->sb[src_set].dev, REQ_OP_READ,
1217 zmd->sb[src_set].block + i, page);
1220 ret = dmz_rdwr_block(zmd->sb[dst_set].dev, REQ_OP_WRITE,
1221 zmd->sb[dst_set].block + i, page);
1227 if (!zmd->sb[dst_set].mblk) {
1228 zmd->sb[dst_set].mblk = dmz_alloc_mblock(zmd, 0);
1229 if (!zmd->sb[dst_set].mblk) {
1233 zmd->sb[dst_set].sb = zmd->sb[dst_set].mblk->data;
1236 ret = dmz_write_sb(zmd, dst_set);
1246 static int dmz_load_sb(struct dmz_metadata *zmd)
1252 if (!zmd->sb[0].zone) {
1253 dmz_zmd_err(zmd, "Primary super block zone not set");
1258 zmd->sb[0].block = dmz_start_block(zmd, zmd->sb[0].zone);
1259 zmd->sb[0].dev = zmd->sb[0].zone->dev;
1260 ret = dmz_get_sb(zmd, &zmd->sb[0], 0);
1262 dmz_dev_err(zmd->sb[0].dev, "Read primary super block failed");
1266 ret = dmz_check_sb(zmd, &zmd->sb[0], false);
1271 if (!zmd->sb[1].zone) {
1273 zmd->sb[0].zone->id + zmd->nr_meta_zones;
1275 zmd->sb[1].zone = dmz_get(zmd, zone_id);
1277 zmd->sb[1].block = dmz_start_block(zmd, zmd->sb[1].zone);
1278 zmd->sb[1].dev = zmd->sb[0].dev;
1279 ret = dmz_get_sb(zmd, &zmd->sb[1], 1);
1281 ret = dmz_lookup_secondary_sb(zmd);
1284 dmz_dev_err(zmd->sb[1].dev, "Read secondary super block failed");
1288 ret = dmz_check_sb(zmd, &zmd->sb[1], false);
1294 dmz_zmd_err(zmd, "No valid super block found");
1299 sb_gen[0] = le64_to_cpu(zmd->sb[0].sb->gen);
1301 ret = dmz_recover_mblocks(zmd, 0);
1303 dmz_dev_err(zmd->sb[0].dev,
1310 sb_gen[1] = le64_to_cpu(zmd->sb[1].sb->gen);
1312 ret = dmz_recover_mblocks(zmd, 1);
1315 dmz_dev_err(zmd->sb[1].dev,
1322 zmd->sb_gen = sb_gen[0];
1323 zmd->mblk_primary = 0;
1325 zmd->sb_gen = sb_gen[1];
1326 zmd->mblk_primary = 1;
1329 dmz_dev_debug(zmd->sb[zmd->mblk_primary].dev,
1331 zmd->mblk_primary, zmd->sb_gen);
1333 if (zmd->sb_version > 1) {
1340 for (i = 1; i < zmd->nr_devs; i++) {
1342 sb->zone = dmz_get(zmd, zmd->dev[i].zone_offset);
1343 sb->dev = &zmd->dev[i];
1351 ret = dmz_get_sb(zmd, sb, i + 1);
1355 dmz_free_mblock(zmd, sb->mblk);
1358 ret = dmz_check_sb(zmd, sb, true);
1359 dmz_free_mblock(zmd, sb->mblk);
1375 struct dmz_metadata *zmd = dev->metadata;
1379 zone = dmz_insert(zmd, idx, dev);
1383 if (blkz->len != zmd->zone_nr_sectors) {
1384 if (zmd->sb_version > 1) {
1422 zmd->nr_useable_zones++;
1424 zmd->nr_rnd_zones++;
1425 if (zmd->nr_devs == 1 && !zmd->sb[0].zone) {
1427 zmd->sb[0].zone = zone;
1430 if (zmd->nr_devs > 1 && num == 0) {
1442 static int dmz_emulate_zones(struct dmz_metadata *zmd, struct dmz_dev *dev)
1450 zone = dmz_insert(zmd, idx, dev);
1455 zmd->nr_cache_zones++;
1456 zmd->nr_useable_zones++;
1457 if (dev->capacity - zone_offset < zmd->zone_nr_sectors) {
1462 zone_offset += zmd->zone_nr_sectors;
1470 static void dmz_drop_zones(struct dmz_metadata *zmd)
1474 for(idx = 0; idx < zmd->nr_zones; idx++) {
1475 struct dm_zone *zone = xa_load(&zmd->zones, idx);
1478 xa_erase(&zmd->zones, idx);
1480 xa_destroy(&zmd->zones);
1487 static int dmz_init_zones(struct dmz_metadata *zmd)
1490 struct dmz_dev *zoned_dev = &zmd->dev[0];
1493 zmd->zone_nr_sectors = zmd->dev[0].zone_nr_sectors;
1494 zmd->zone_nr_sectors_shift = ilog2(zmd->zone_nr_sectors);
1495 zmd->zone_nr_blocks = dmz_sect2blk(zmd->zone_nr_sectors);
1496 zmd->zone_nr_blocks_shift = ilog2(zmd->zone_nr_blocks);
1497 zmd->zone_bitmap_size = zmd->zone_nr_blocks >> 3;
1498 zmd->zone_nr_bitmap_blocks =
1499 max_t(sector_t, 1, zmd->zone_bitmap_size >> DMZ_BLOCK_SHIFT);
1500 zmd->zone_bits_per_mblk = min_t(sector_t, zmd->zone_nr_blocks,
1504 zmd->nr_zones = 0;
1505 for (i = 0; i < zmd->nr_devs; i++) {
1506 struct dmz_dev *dev = &zmd->dev[i];
1508 dev->metadata = zmd;
1509 zmd->nr_zones += dev->nr_zones;
1520 if (!zmd->nr_zones) {
1521 DMERR("(%s): No zones found", zmd->devname);
1524 xa_init(&zmd->zones);
1527 zmd->devname, sizeof(struct dm_zone) * zmd->nr_zones);
1529 if (zmd->nr_devs > 1) {
1530 ret = dmz_emulate_zones(zmd, &zmd->dev[0]);
1533 zmd->devname, ret);
1534 dmz_drop_zones(zmd);
1542 zmd->sb[0].zone = dmz_get(zmd, 0);
1544 for (i = 1; i < zmd->nr_devs; i++) {
1545 zoned_dev = &zmd->dev[i];
1552 zmd->devname, ret);
1553 dmz_drop_zones(zmd);
1569 zmd->devname, ret);
1570 dmz_drop_zones(zmd);
1599 static int dmz_update_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
1615 ret = blkdev_report_zones(dev->bdev, dmz_start_sect(zmd, zone), 1,
1635 static int dmz_handle_seq_write_err(struct dmz_metadata *zmd,
1643 ret = dmz_update_zone(zmd, zone);
1651 dmz_invalidate_blocks(zmd, zone, zone->wp_block,
1661 static int dmz_reset_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
1678 dmz_start_sect(zmd, zone),
1679 zmd->zone_nr_sectors, GFP_NOIO);
1694 static void dmz_get_zone_weight(struct dmz_metadata *zmd, struct dm_zone *zone);
1699 static int dmz_load_mapping(struct dmz_metadata *zmd)
1709 zmd->map_mblk = kcalloc(zmd->nr_map_blocks,
1711 if (!zmd->map_mblk)
1715 while (chunk < zmd->nr_chunks) {
1718 dmap_mblk = dmz_get_mblock(zmd, i + 1);
1721 zmd->map_mblk[i] = dmap_mblk;
1732 if (dzone_id >= zmd->nr_zones) {
1733 dmz_zmd_err(zmd, "Chunk %u mapping: invalid data zone ID %u",
1738 dzone = dmz_get(zmd, dzone_id);
1740 dmz_zmd_err(zmd, "Chunk %u mapping: data zone %u not present",
1746 dmz_get_zone_weight(zmd, dzone);
1749 list_add_tail(&dzone->link, &zmd->map_cache_list);
1760 if (bzone_id >= zmd->nr_zones) {
1761 dmz_zmd_err(zmd, "Chunk %u mapping: invalid buffer zone ID %u",
1766 bzone = dmz_get(zmd, bzone_id);
1768 dmz_zmd_err(zmd, "Chunk %u mapping: buffer zone %u not present",
1773 dmz_zmd_err(zmd, "Chunk %u mapping: invalid buffer zone %u",
1783 dmz_get_zone_weight(zmd, bzone);
1785 list_add_tail(&bzone->link, &zmd->map_cache_list);
1800 for (i = 0; i < zmd->nr_zones; i++) {
1801 dzone = dmz_get(zmd, i);
1810 zmd->nr_cache++;
1825 list_add_tail(&dzone->link, &zmd->unmap_cache_list);
1826 atomic_inc(&zmd->unmap_nr_cache);
1831 } else if (atomic_read(&zmd->nr_reserved_seq_zones) < zmd->nr_reserved_seq) {
1832 list_add_tail(&dzone->link, &zmd->reserved_seq_zones_list);
1834 atomic_inc(&zmd->nr_reserved_seq_zones);
1849 static void dmz_set_chunk_mapping(struct dmz_metadata *zmd, unsigned int chunk,
1852 struct dmz_mblock *dmap_mblk = zmd->map_mblk[chunk >> DMZ_MAP_ENTRIES_SHIFT];
1858 dmz_dirty_mblock(zmd, dmap_mblk);
1865 static void __dmz_lru_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
1876 list_add_tail(&zone->link, &zmd->map_cache_list);
1887 static void dmz_lru_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
1889 __dmz_lru_zone(zmd, zone);
1891 __dmz_lru_zone(zmd, zone->bzone);
1897 static void dmz_wait_for_free_zones(struct dmz_metadata *zmd)
1901 prepare_to_wait(&zmd->free_wq, &wait, TASK_UNINTERRUPTIBLE);
1902 dmz_unlock_map(zmd);
1903 dmz_unlock_metadata(zmd);
1907 dmz_lock_metadata(zmd);
1908 dmz_lock_map(zmd);
1909 finish_wait(&zmd->free_wq, &wait);
1942 static void dmz_wait_for_reclaim(struct dmz_metadata *zmd, struct dm_zone *zone)
1944 dmz_unlock_map(zmd);
1945 dmz_unlock_metadata(zmd);
1949 dmz_lock_metadata(zmd);
1950 dmz_lock_map(zmd);
1956 static struct dm_zone *dmz_get_rnd_zone_for_reclaim(struct dmz_metadata *zmd,
1964 if (zmd->nr_cache) {
1965 zone_list = &zmd->map_cache_list;
1968 zone_list = &zmd->dev[idx].map_rnd_list;
1970 zone_list = &zmd->dev[idx].map_rnd_list;
2015 static struct dm_zone *dmz_get_seq_zone_for_reclaim(struct dmz_metadata *zmd,
2020 list_for_each_entry(zone, &zmd->dev[idx].map_seq_list, link) {
2033 struct dm_zone *dmz_get_zone_for_reclaim(struct dmz_metadata *zmd,
2046 dmz_lock_map(zmd);
2047 if (list_empty(&zmd->reserved_seq_zones_list))
2048 zone = dmz_get_seq_zone_for_reclaim(zmd, dev_idx);
2050 zone = dmz_get_rnd_zone_for_reclaim(zmd, dev_idx, idle);
2051 dmz_unlock_map(zmd);
2062 struct dm_zone *dmz_get_chunk_mapping(struct dmz_metadata *zmd, unsigned int chunk, int op)
2064 struct dmz_mblock *dmap_mblk = zmd->map_mblk[chunk >> DMZ_MAP_ENTRIES_SHIFT];
2070 int alloc_flags = zmd->nr_cache ? DMZ_ALLOC_CACHE : DMZ_ALLOC_RND;
2072 dmz_lock_map(zmd);
2085 dzone = dmz_alloc_zone(zmd, 0, alloc_flags);
2087 if (dmz_dev_is_dying(zmd)) {
2091 dmz_wait_for_free_zones(zmd);
2095 dmz_map_zone(zmd, dzone, chunk);
2099 dzone = dmz_get(zmd, dzone_id);
2111 ret = dmz_handle_seq_write_err(zmd, dzone);
2126 dmz_wait_for_reclaim(zmd, dzone);
2130 dmz_lru_zone(zmd, dzone);
2132 dmz_unlock_map(zmd);
2143 void dmz_put_chunk_mapping(struct dmz_metadata *zmd, struct dm_zone *dzone)
2147 dmz_lock_map(zmd);
2152 dmz_lru_zone(zmd, bzone);
2155 dmz_unmap_zone(zmd, bzone);
2156 dmz_free_zone(zmd, bzone);
2164 dmz_lru_zone(zmd, dzone);
2167 dmz_unmap_zone(zmd, dzone);
2168 dmz_free_zone(zmd, dzone);
2171 dmz_unlock_map(zmd);
2178 struct dm_zone *dmz_get_chunk_buffer(struct dmz_metadata *zmd,
2182 int alloc_flags = zmd->nr_cache ? DMZ_ALLOC_CACHE : DMZ_ALLOC_RND;
2184 dmz_lock_map(zmd);
2191 bzone = dmz_alloc_zone(zmd, 0, alloc_flags);
2193 if (dmz_dev_is_dying(zmd)) {
2197 dmz_wait_for_free_zones(zmd);
2202 dmz_set_chunk_mapping(zmd, dzone->chunk, dzone->id, bzone->id);
2209 list_add_tail(&bzone->link, &zmd->map_cache_list);
2213 dmz_unlock_map(zmd);
2222 struct dm_zone *dmz_alloc_zone(struct dmz_metadata *zmd, unsigned int dev_idx,
2231 for (i = 0; i < zmd->nr_devs; i++)
2232 dmz_schedule_reclaim(zmd->dev[i].reclaim);
2238 list = &zmd->unmap_cache_list;
2240 list = &zmd->dev[dev_idx].unmap_rnd_list;
2242 list = &zmd->dev[dev_idx].unmap_seq_list;
2253 if (i < zmd->nr_devs) {
2254 dev_idx = (dev_idx + 1) % zmd->nr_devs;
2262 zone = list_first_entry_or_null(&zmd->reserved_seq_zones_list,
2266 atomic_dec(&zmd->nr_reserved_seq_zones);
2275 atomic_dec(&zmd->unmap_nr_cache);
2282 dmz_zmd_warn(zmd, "Zone %u is offline", zone->id);
2287 dmz_zmd_warn(zmd, "Zone %u has metadata", zone->id);
2298 void dmz_free_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
2302 dmz_reset_zone(zmd, zone);
2306 list_add_tail(&zone->link, &zmd->unmap_cache_list);
2307 atomic_inc(&zmd->unmap_nr_cache);
2312 list_add_tail(&zone->link, &zmd->reserved_seq_zones_list);
2313 atomic_inc(&zmd->nr_reserved_seq_zones);
2319 wake_up_all(&zmd->free_wq);
2326 void dmz_map_zone(struct dmz_metadata *zmd, struct dm_zone *dzone,
2330 dmz_set_chunk_mapping(zmd, chunk, dzone->id,
2334 list_add_tail(&dzone->link, &zmd->map_cache_list);
2345 void dmz_unmap_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
2376 dmz_set_chunk_mapping(zmd, chunk, dzone_id, DMZ_MAP_UNMAPPED);
2417 static struct dmz_mblock *dmz_get_bitmap(struct dmz_metadata *zmd,
2421 sector_t bitmap_block = 1 + zmd->nr_map_blocks +
2422 (sector_t)(zone->id * zmd->zone_nr_bitmap_blocks) +
2425 return dmz_get_mblock(zmd, bitmap_block);
2431 int dmz_copy_valid_blocks(struct dmz_metadata *zmd, struct dm_zone *from_zone,
2438 while (chunk_block < zmd->zone_nr_blocks) {
2439 from_mblk = dmz_get_bitmap(zmd, from_zone, chunk_block);
2442 to_mblk = dmz_get_bitmap(zmd, to_zone, chunk_block);
2444 dmz_release_mblock(zmd, from_mblk);
2449 dmz_dirty_mblock(zmd, to_mblk);
2451 dmz_release_mblock(zmd, to_mblk);
2452 dmz_release_mblock(zmd, from_mblk);
2454 chunk_block += zmd->zone_bits_per_mblk;
2466 int dmz_merge_valid_blocks(struct dmz_metadata *zmd, struct dm_zone *from_zone,
2473 while (chunk_block < zmd->zone_nr_blocks) {
2475 ret = dmz_first_valid_block(zmd, from_zone, &chunk_block);
2480 ret = dmz_validate_blocks(zmd, to_zone, chunk_block, nr_blocks);
2493 int dmz_validate_blocks(struct dmz_metadata *zmd, struct dm_zone *zone,
2497 unsigned int zone_nr_blocks = zmd->zone_nr_blocks;
2501 dmz_zmd_debug(zmd, "=> VALIDATE zone %u, block %llu, %u blocks",
2509 mblk = dmz_get_bitmap(zmd, zone, chunk_block);
2515 nr_bits = min(nr_blocks, zmd->zone_bits_per_mblk - bit);
2519 dmz_dirty_mblock(zmd, mblk);
2522 dmz_release_mblock(zmd, mblk);
2531 dmz_zmd_warn(zmd, "Zone %u: weight %u should be <= %u",
2574 int dmz_invalidate_blocks(struct dmz_metadata *zmd, struct dm_zone *zone,
2581 dmz_zmd_debug(zmd, "=> INVALIDATE zone %u, block %llu, %u blocks",
2584 WARN_ON(chunk_block + nr_blocks > zmd->zone_nr_blocks);
2588 mblk = dmz_get_bitmap(zmd, zone, chunk_block);
2594 nr_bits = min(nr_blocks, zmd->zone_bits_per_mblk - bit);
2599 dmz_dirty_mblock(zmd, mblk);
2602 dmz_release_mblock(zmd, mblk);
2611 dmz_zmd_warn(zmd, "Zone %u: weight %u should be >= %u",
2622 static int dmz_test_block(struct dmz_metadata *zmd, struct dm_zone *zone,
2628 WARN_ON(chunk_block >= zmd->zone_nr_blocks);
2631 mblk = dmz_get_bitmap(zmd, zone, chunk_block);
2639 dmz_release_mblock(zmd, mblk);
2648 static int dmz_to_next_set_block(struct dmz_metadata *zmd, struct dm_zone *zone,
2654 unsigned int zone_bits = zmd->zone_bits_per_mblk;
2658 WARN_ON(chunk_block + nr_blocks > zmd->zone_nr_blocks);
2662 mblk = dmz_get_bitmap(zmd, zone, chunk_block);
2674 dmz_release_mblock(zmd, mblk);
2691 int dmz_block_valid(struct dmz_metadata *zmd, struct dm_zone *zone,
2696 valid = dmz_test_block(zmd, zone, chunk_block);
2701 return dmz_to_next_set_block(zmd, zone, chunk_block,
2702 zmd->zone_nr_blocks - chunk_block, 0);
2711 int dmz_first_valid_block(struct dmz_metadata *zmd, struct dm_zone *zone,
2717 ret = dmz_to_next_set_block(zmd, zone, start_block,
2718 zmd->zone_nr_blocks - start_block, 1);
2725 return dmz_to_next_set_block(zmd, zone, start_block,
2726 zmd->zone_nr_blocks - start_block, 0);
2760 static void dmz_get_zone_weight(struct dmz_metadata *zmd, struct dm_zone *zone)
2765 unsigned int nr_blocks = zmd->zone_nr_blocks;
2771 mblk = dmz_get_bitmap(zmd, zone, chunk_block);
2780 nr_bits = min(nr_blocks, zmd->zone_bits_per_mblk - bit);
2783 dmz_release_mblock(zmd, mblk);
2795 static void dmz_cleanup_metadata(struct dmz_metadata *zmd)
2802 if (zmd->map_mblk) {
2803 for (i = 0; i < zmd->nr_map_blocks; i++)
2804 dmz_release_mblock(zmd, zmd->map_mblk[i]);
2805 kfree(zmd->map_mblk);
2806 zmd->map_mblk = NULL;
2811 if (zmd->sb[i].mblk) {
2812 dmz_free_mblock(zmd, zmd->sb[i].mblk);
2813 zmd->sb[i].mblk = NULL;
2818 while (!list_empty(&zmd->mblk_dirty_list)) {
2819 mblk = list_first_entry(&zmd->mblk_dirty_list,
2821 dmz_zmd_warn(zmd, "mblock %llu still in dirty list (ref %u)",
2824 rb_erase(&mblk->node, &zmd->mblk_rbtree);
2825 dmz_free_mblock(zmd, mblk);
2828 while (!list_empty(&zmd->mblk_lru_list)) {
2829 mblk = list_first_entry(&zmd->mblk_lru_list,
2832 rb_erase(&mblk->node, &zmd->mblk_rbtree);
2833 dmz_free_mblock(zmd, mblk);
2837 root = &zmd->mblk_rbtree;
2839 dmz_zmd_warn(zmd, "mblock %llu ref %u still in rbtree",
2842 dmz_free_mblock(zmd, mblk);
2846 dmz_drop_zones(zmd);
2848 mutex_destroy(&zmd->mblk_flush_lock);
2849 mutex_destroy(&zmd->map_lock);
2852 static void dmz_print_dev(struct dmz_metadata *zmd, int num)
2854 struct dmz_dev *dev = &zmd->dev[num];
2862 if (zmd->sb_version > 1) {
2864 dev->zone_offset << zmd->zone_nr_sectors_shift;
2869 dev->nr_zones, (u64)zmd->zone_nr_sectors,
2875 dev->nr_zones, (u64)zmd->zone_nr_sectors);
2886 struct dmz_metadata *zmd;
2891 zmd = kzalloc(sizeof(struct dmz_metadata), GFP_KERNEL);
2892 if (!zmd)
2895 strcpy(zmd->devname, devname);
2896 zmd->dev = dev;
2897 zmd->nr_devs = num_dev;
2898 zmd->mblk_rbtree = RB_ROOT;
2899 init_rwsem(&zmd->mblk_sem);
2900 mutex_init(&zmd->mblk_flush_lock);
2901 spin_lock_init(&zmd->mblk_lock);
2902 INIT_LIST_HEAD(&zmd->mblk_lru_list);
2903 INIT_LIST_HEAD(&zmd->mblk_dirty_list);
2905 mutex_init(&zmd->map_lock);
2907 atomic_set(&zmd->unmap_nr_cache, 0);
2908 INIT_LIST_HEAD(&zmd->unmap_cache_list);
2909 INIT_LIST_HEAD(&zmd->map_cache_list);
2911 atomic_set(&zmd->nr_reserved_seq_zones, 0);
2912 INIT_LIST_HEAD(&zmd->reserved_seq_zones_list);
2914 init_waitqueue_head(&zmd->free_wq);
2917 ret = dmz_init_zones(zmd);
2922 ret = dmz_load_sb(zmd);
2927 for (i = 0; i < zmd->nr_meta_zones << 1; i++) {
2928 zone = dmz_get(zmd, zmd->sb[0].zone->id + i);
2930 dmz_zmd_err(zmd,
2936 dmz_zmd_err(zmd,
2944 ret = dmz_load_mapping(zmd);
2954 zmd->min_nr_mblks = 2 + zmd->nr_map_blocks + zmd->zone_nr_bitmap_blocks * 16;
2955 zmd->max_nr_mblks = zmd->min_nr_mblks + 512;
2956 zmd->mblk_shrinker.count_objects = dmz_mblock_shrinker_count;
2957 zmd->mblk_shrinker.scan_objects = dmz_mblock_shrinker_scan;
2958 zmd->mblk_shrinker.seeks = DEFAULT_SEEKS;
2961 ret = register_shrinker(&zmd->mblk_shrinker);
2963 dmz_zmd_err(zmd, "Register metadata cache shrinker failed");
2967 dmz_zmd_info(zmd, "DM-Zoned metadata version %d", zmd->sb_version);
2968 for (i = 0; i < zmd->nr_devs; i++)
2969 dmz_print_dev(zmd, i);
2971 dmz_zmd_info(zmd, " %u zones of %llu 512-byte logical sectors",
2972 zmd->nr_zones, (u64)zmd->zone_nr_sectors);
2973 dmz_zmd_debug(zmd, " %u metadata zones",
2974 zmd->nr_meta_zones * 2);
2975 dmz_zmd_debug(zmd, " %u data zones for %u chunks",
2976 zmd->nr_data_zones, zmd->nr_chunks);
2977 dmz_zmd_debug(zmd, " %u cache zones (%u unmapped)",
2978 zmd->nr_cache, atomic_read(&zmd->unmap_nr_cache));
2979 for (i = 0; i < zmd->nr_devs; i++) {
2980 dmz_zmd_debug(zmd, " %u random zones (%u unmapped)",
2981 dmz_nr_rnd_zones(zmd, i),
2982 dmz_nr_unmap_rnd_zones(zmd, i));
2983 dmz_zmd_debug(zmd, " %u sequential zones (%u unmapped)",
2984 dmz_nr_seq_zones(zmd, i),
2985 dmz_nr_unmap_seq_zones(zmd, i));
2987 dmz_zmd_debug(zmd, " %u reserved sequential data zones",
2988 zmd->nr_reserved_seq);
2989 dmz_zmd_debug(zmd, "Format:");
2990 dmz_zmd_debug(zmd, "%u metadata blocks per set (%u max cache)",
2991 zmd->nr_meta_blocks, zmd->max_nr_mblks);
2992 dmz_zmd_debug(zmd, " %u data zone mapping blocks",
2993 zmd->nr_map_blocks);
2994 dmz_zmd_debug(zmd, " %u bitmap blocks",
2995 zmd->nr_bitmap_blocks);
2997 *metadata = zmd;
3001 dmz_cleanup_metadata(zmd);
3002 kfree(zmd);
3011 void dmz_dtr_metadata(struct dmz_metadata *zmd)
3013 unregister_shrinker(&zmd->mblk_shrinker);
3014 dmz_cleanup_metadata(zmd);
3015 kfree(zmd);
3021 int dmz_resume_metadata(struct dmz_metadata *zmd)
3029 for (i = 0; i < zmd->nr_zones; i++) {
3030 zone = dmz_get(zmd, i);
3032 dmz_zmd_err(zmd, "Unable to get zone %u", i);
3037 ret = dmz_update_zone(zmd, zone);
3039 dmz_zmd_err(zmd, "Broken zone %u", i);
3044 dmz_zmd_warn(zmd, "Zone %u is offline", i);
3052 dmz_zmd_err(zmd, "Zone %u: Invalid wp (%llu / %llu)",
3055 dmz_invalidate_blocks(zmd, zone, zone->wp_block,
3056 zmd->zone_nr_blocks - zone->wp_block);