Lines Matching defs:dev
39 superblock_region_size(struct spdk_ftl_dev *dev)
41 const struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(dev->base_bdev_desc);
52 superblock_region_blocks(struct spdk_ftl_dev *dev)
54 return superblock_region_size(dev) / FTL_BLOCK_SIZE;
58 ftl_md_region_blocks(struct spdk_ftl_dev *dev, uint64_t bytes)
60 const uint64_t alignment = superblock_region_size(dev);
71 ftl_md_region_align_blocks(struct spdk_ftl_dev *dev, uint64_t blocks)
73 const uint64_t alignment = superblock_region_blocks(dev);
121 dump_region(struct spdk_ftl_dev *dev, struct ftl_layout_region *region)
127 assert(!(region->current.offset % superblock_region_blocks(dev)));
128 assert(!(region->current.blocks % superblock_region_blocks(dev)));
130 FTL_NOTICELOG(dev, "Region %s\n", region->name);
131 FTL_NOTICELOG(dev, " offset: %.2f MiB\n",
133 FTL_NOTICELOG(dev, " blocks: %.2f MiB\n",
138 ftl_validate_regions(struct spdk_ftl_dev *dev, struct ftl_layout *layout)
144 struct ftl_layout_region *r1 = ftl_layout_region_get(dev, i);
151 struct ftl_layout_region *r2 = ftl_layout_region_get(dev, j);
171 FTL_ERRLOG(dev, "Layout initialization ERROR, two regions overlap, "
182 get_num_user_lbas(struct spdk_ftl_dev *dev)
186 blocks = dev->num_bands * ftl_get_num_blocks_in_band(dev);
187 blocks = (blocks * (100 - dev->conf.overprovisioning)) / 100;
193 ftl_layout_region_get(struct spdk_ftl_dev *dev, enum ftl_layout_region_type reg_type)
195 struct ftl_layout_region *reg = &dev->layout.region[reg_type];
202 ftl_layout_base_offset(struct spdk_ftl_dev *dev)
204 return dev->num_bands * ftl_get_num_blocks_in_band(dev);
208 layout_region_create_nvc(struct spdk_ftl_dev *dev, enum ftl_layout_region_type reg_type,
211 const struct ftl_md_layout_ops *md_ops = &dev->nv_cache.nvc_type->ops.md_layout_ops;
212 size_t reg_blks = ftl_md_region_blocks(dev, entry_count * entry_size);
214 if (md_ops->region_create(dev, reg_type, reg_version, reg_blks)) {
217 if (md_ops->region_open(dev, reg_type, reg_version, entry_size, entry_count,
218 &dev->layout.region[reg_type])) {
225 layout_region_create_base(struct spdk_ftl_dev *dev, enum ftl_layout_region_type reg_type,
228 const struct ftl_md_layout_ops *md_ops = &dev->base_type->ops.md_layout_ops;
229 size_t reg_blks = ftl_md_region_blocks(dev, entry_count * entry_size);
231 if (md_ops->region_create(dev, reg_type, reg_version, reg_blks)) {
234 if (md_ops->region_open(dev, reg_type, reg_version, entry_size, entry_count,
235 &dev->layout.region[reg_type])) {
263 legacy_layout_region_open_nvc(struct spdk_ftl_dev *dev, enum ftl_layout_region_type reg_type,
266 struct ftl_layout_region *reg = &dev->layout.region[reg_type];
267 const struct ftl_md_layout_ops *md_ops = &dev->nv_cache.nvc_type->ops.md_layout_ops;
269 legacy_layout_verify_region(dev->nvc_layout_tracker, reg_type, reg_version);
270 return md_ops->region_open(dev, reg_type, reg_version, entry_size, entry_count, reg);
274 legacy_layout_region_open_base(struct spdk_ftl_dev *dev, enum ftl_layout_region_type reg_type,
277 struct ftl_layout_region *reg = &dev->layout.region[reg_type];
278 const struct ftl_md_layout_ops *md_ops = &dev->base_type->ops.md_layout_ops;
280 legacy_layout_verify_region(dev->nvc_layout_tracker, reg_type, reg_version);
281 return md_ops->region_open(dev, reg_type, reg_version, entry_size, entry_count, reg);
285 layout_setup_legacy_default_nvc(struct spdk_ftl_dev *dev)
289 struct ftl_layout *layout = &dev->layout;
293 blocks = ftl_md_region_blocks(dev, layout->l2p.addr_size * dev->num_lbas);
294 if (legacy_layout_region_open_nvc(dev, FTL_LAYOUT_REGION_TYPE_L2P, 0, FTL_BLOCK_SIZE,
300 if (legacy_layout_region_open_nvc(dev, FTL_LAYOUT_REGION_TYPE_BAND_MD, FTL_BAND_VERSION_1,
301 sizeof(struct ftl_band_md), ftl_get_num_bands(dev))) {
306 if (legacy_layout_region_open_nvc(dev, FTL_LAYOUT_REGION_TYPE_BAND_MD_MIRROR, FTL_BAND_VERSION_1,
307 sizeof(struct ftl_band_md), ftl_get_num_bands(dev))) {
321 ftl_layout_tracker_bdev_find_next_region(dev->nvc_layout_tracker, region_type, ®_search_ctx);
327 if (legacy_layout_region_open_nvc(dev, region_type, FTL_P2L_VERSION_1, FTL_BLOCK_SIZE, blocks)) {
336 if (legacy_layout_region_open_nvc(dev, FTL_LAYOUT_REGION_TYPE_TRIM_MD, 0, sizeof(uint64_t),
342 if (legacy_layout_region_open_nvc(dev, FTL_LAYOUT_REGION_TYPE_TRIM_MD_MIRROR, 0, sizeof(uint64_t),
349 ftl_layout_tracker_bdev_find_next_region(dev->nvc_layout_tracker, FTL_LAYOUT_REGION_TYPE_DATA_NVC,
355 chunk_count = blocks / ftl_get_num_blocks_in_band(dev);
363 if (legacy_layout_region_open_nvc(dev, FTL_LAYOUT_REGION_TYPE_NVC_MD, FTL_NVC_VERSION_1,
371 if (legacy_layout_region_open_nvc(dev, FTL_LAYOUT_REGION_TYPE_NVC_MD_MIRROR, FTL_NVC_VERSION_1,
380 if (legacy_layout_region_open_nvc(dev, FTL_LAYOUT_REGION_TYPE_DATA_NVC, 0,
386 ftl_layout_upgrade_add_region_placeholder(dev, dev->nvc_layout_tracker,
388 ftl_layout_upgrade_add_region_placeholder(dev, dev->nvc_layout_tracker,
394 FTL_ERRLOG(dev, "Invalid legacy NV Cache metadata layout\n");
399 layout_setup_legacy_default_base(struct spdk_ftl_dev *dev)
401 struct ftl_layout *layout = &dev->layout;
408 if (layout_region_create_base(dev, FTL_LAYOUT_REGION_TYPE_DATA_BASE, 0, FTL_BLOCK_SIZE,
409 ftl_layout_base_offset(dev))) {
413 if (legacy_layout_region_open_base(dev, FTL_LAYOUT_REGION_TYPE_VALID_MAP, 0, FTL_BLOCK_SIZE,
414 ftl_md_region_blocks(dev, spdk_divide_round_up(layout->base.total_blocks + layout->nvc.total_blocks,
423 layout_setup_legacy_default(struct spdk_ftl_dev *dev)
425 if (layout_setup_legacy_default_nvc(dev) || layout_setup_legacy_default_base(dev)) {
432 layout_setup_default_nvc(struct spdk_ftl_dev *dev)
436 struct ftl_layout *layout = &dev->layout;
439 blocks = ftl_md_region_blocks(dev, layout->l2p.addr_size * dev->num_lbas);
440 if (layout_region_create_nvc(dev, FTL_LAYOUT_REGION_TYPE_L2P, 0, FTL_BLOCK_SIZE, blocks)) {
445 if (layout_region_create_nvc(dev, FTL_LAYOUT_REGION_TYPE_BAND_MD, FTL_BAND_VERSION_CURRENT,
446 sizeof(struct ftl_band_md), ftl_get_num_bands(dev))) {
451 if (layout_region_create_nvc(dev, FTL_LAYOUT_REGION_TYPE_BAND_MD_MIRROR, FTL_BAND_VERSION_CURRENT,
452 sizeof(struct ftl_band_md), ftl_get_num_bands(dev))) {
463 if (layout_region_create_nvc(dev, region_type, FTL_P2L_VERSION_CURRENT, FTL_BLOCK_SIZE,
474 if (layout_region_create_nvc(dev, FTL_LAYOUT_REGION_TYPE_TRIM_MD, 0, FTL_BLOCK_SIZE, blocks)) {
479 if (layout_region_create_nvc(dev, FTL_LAYOUT_REGION_TYPE_TRIM_MD_MIRROR, 0, FTL_BLOCK_SIZE,
488 if (layout_region_create_nvc(dev, FTL_LAYOUT_REGION_TYPE_TRIM_LOG, FTL_TRIM_LOG_VERSION_CURRENT,
494 if (layout_region_create_nvc(dev, FTL_LAYOUT_REGION_TYPE_TRIM_LOG_MIRROR,
508 if (layout_region_create_nvc(dev, FTL_LAYOUT_REGION_TYPE_NVC_MD, FTL_NVC_VERSION_CURRENT,
516 if (layout_region_create_nvc(dev, FTL_LAYOUT_REGION_TYPE_NVC_MD_MIRROR, FTL_NVC_VERSION_CURRENT,
522 if (dev->nv_cache.nvc_type->ops.setup_layout) {
523 return dev->nv_cache.nvc_type->ops.setup_layout(dev);
529 FTL_ERRLOG(dev, "Insufficient NV Cache capacity to preserve metadata\n");
534 layout_setup_default_base(struct spdk_ftl_dev *dev)
536 struct ftl_layout *layout = &dev->layout;
544 if (layout_region_create_base(dev, FTL_LAYOUT_REGION_TYPE_DATA_BASE, 0, FTL_BLOCK_SIZE,
545 ftl_layout_base_offset(dev))) {
550 if (layout_region_create_base(dev, FTL_LAYOUT_REGION_TYPE_VALID_MAP, 0, FTL_BLOCK_SIZE,
551 ftl_md_region_blocks(dev, valid_map_size))) {
559 layout_setup_default(struct spdk_ftl_dev *dev)
561 if (layout_setup_default_nvc(dev) || layout_setup_default_base(dev)) {
568 layout_load(struct spdk_ftl_dev *dev)
570 if (ftl_superblock_load_blob_area(dev)) {
573 if (ftl_superblock_md_layout_apply(dev)) {
580 ftl_layout_setup(struct spdk_ftl_dev *dev)
582 struct ftl_layout *layout = &dev->layout;
606 if (dev->conf.mode & SPDK_FTL_MODE_CREATE) {
608 } else if (ftl_superblock_is_blob_area_empty(dev->sb)) {
613 FTL_NOTICELOG(dev, "FTL layout setup mode %d\n", (int)setup_mode);
630 num_lbas = get_num_user_lbas(dev);
631 if (dev->num_lbas == 0) {
632 assert(dev->conf.mode & SPDK_FTL_MODE_CREATE);
633 dev->num_lbas = num_lbas;
634 dev->sb->lba_cnt = num_lbas;
635 } else if (dev->num_lbas != num_lbas) {
636 FTL_ERRLOG(dev, "Mismatched FTL num_lbas\n");
644 layout->p2l.pages_per_xfer = spdk_divide_round_up(dev->xfer_size, FTL_NUM_P2L_ENTRIES_NO_VSS);
645 layout->p2l.ckpt_pages = spdk_divide_round_up(ftl_get_num_blocks_in_band(dev),
646 dev->xfer_size) * layout->p2l.pages_per_xfer;
648 layout->nvc.chunk_data_blocks = ftl_get_num_blocks_in_band(dev);
649 layout->nvc.chunk_count = layout->nvc.total_blocks / ftl_get_num_blocks_in_band(dev);
650 layout->nvc.chunk_tail_md_num_blocks = ftl_nv_cache_chunk_tail_md_num_blocks(&dev->nv_cache);
652 layout->base.num_usable_blocks = ftl_get_num_blocks_in_band(dev);
653 layout->base.user_blocks = ftl_band_user_blocks(dev->bands);
657 if (layout_setup_legacy_default(dev)) {
663 if (layout_load(dev)) {
669 if (layout_setup_default(dev)) {
679 if (ftl_validate_regions(dev, layout)) {
683 rc = ftl_superblock_store_blob_area(dev);
685 FTL_NOTICELOG(dev, "Base device capacity: %.2f MiB\n",
687 FTL_NOTICELOG(dev, "NV cache device capacity: %.2f MiB\n",
689 FTL_NOTICELOG(dev, "L2P entries: %"PRIu64"\n", dev->num_lbas);
690 FTL_NOTICELOG(dev, "L2P address size: %"PRIu64"\n", layout->l2p.addr_size);
691 FTL_NOTICELOG(dev, "P2L checkpoint pages: %"PRIu64"\n", layout->p2l.ckpt_pages);
692 FTL_NOTICELOG(dev, "NV cache chunk count %"PRIu64"\n", dev->layout.nvc.chunk_count);
698 ftl_layout_setup_superblock(struct spdk_ftl_dev *dev)
701 struct ftl_layout *layout = &dev->layout;
707 bdev = spdk_bdev_desc_get_bdev(dev->base_bdev_desc);
710 bdev = spdk_bdev_desc_get_bdev(dev->nv_cache.bdev_desc);
714 if (layout_region_create_nvc(dev, FTL_LAYOUT_REGION_TYPE_SB, FTL_SB_VERSION_CURRENT,
715 superblock_region_size(dev), 1)) {
716 FTL_ERRLOG(dev, "Error when setting up primary super block\n");
724 if (layout_region_create_base(dev, FTL_LAYOUT_REGION_TYPE_SB_BASE, FTL_SB_VERSION_CURRENT,
725 superblock_region_size(dev), 1)) {
726 FTL_ERRLOG(dev, "Error when setting up secondary super block\n");
736 spdk_bdev_desc_get_bdev(dev->base_bdev_desc));
740 FTL_ERRLOG(dev, "Error when setup base device super block\n");
748 ftl_layout_clear_superblock(struct spdk_ftl_dev *dev)
752 rc = ftl_layout_tracker_bdev_rm_region(dev->nvc_layout_tracker, FTL_LAYOUT_REGION_TYPE_SB,
758 return ftl_layout_tracker_bdev_rm_region(dev->base_layout_tracker, FTL_LAYOUT_REGION_TYPE_SB_BASE,
763 ftl_layout_dump(struct spdk_ftl_dev *dev)
768 FTL_NOTICELOG(dev, "NV cache layout:\n");
770 reg = ftl_layout_region_get(dev, i);
771 if (reg && reg->bdev_desc == dev->nv_cache.bdev_desc) {
772 dump_region(dev, reg);
775 FTL_NOTICELOG(dev, "Base device layout:\n");
777 reg = ftl_layout_region_get(dev, i);
778 if (reg && reg->bdev_desc == dev->base_bdev_desc) {
779 dump_region(dev, reg);
785 ftl_layout_base_md_blocks(struct spdk_ftl_dev *dev)
790 bdev = spdk_bdev_desc_get_bdev(dev->base_bdev_desc);
793 bdev = spdk_bdev_desc_get_bdev(dev->nv_cache.bdev_desc);
797 md_blocks += ftl_md_region_blocks(dev, spdk_divide_round_up(total_blocks, 8));
800 md_blocks += superblock_region_blocks(dev);
811 ftl_layout_blob_store(struct spdk_ftl_dev *dev, void *blob_buf, size_t blob_buf_sz)
823 reg = &dev->layout.region[reg_type];
836 ftl_layout_blob_load(struct spdk_ftl_dev *dev, void *blob_buf, size_t blob_sz)
855 reg = &dev->layout.region[blob_entry->type];
864 ftl_layout_upgrade_add_region_placeholder(struct spdk_ftl_dev *dev,
874 dev->layout.region[reg_type].type = reg_type;
875 dev->layout.region[reg_type].current.version = 0;
876 dev->layout.region[reg_type].current.offset = UINT64_MAX;
877 dev->layout.region[reg_type].current.blocks = 0;