Commit 748785c2 authored by Wojciech Malikowski's avatar Wojciech Malikowski Committed by Tomasz Zawadzki
Browse files

lib/ftl: Change ftl_ppa fields to be zone specific 



Remove some Open Channel dependencies from ftl_ppa struct.

Change-Id: Ic088b84c56a928906c6c01c6ef74e69be6d0107f
Signed-off-by: default avatarWojciech Malikowski <wojciech.malikowski@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/479549


Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarKonrad Sztyber <konrad.sztyber@intel.com>
Reviewed-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Community-CI: SPDK CI Jenkins <sys_sgci@intel.com>
Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
parent 7083fa3e

lib/ftl/ftl_anm.c

+2 −2
Original line number Diff line number Diff line
@@ -172,7 +172,7 @@ ftl_anm_process_log(struct ftl_anm_poller *poller, 
		}



		poller->fn(event);

		ppa.chk++;

		ppa.zone_id++;

	}



	return 0;
@@ -186,7 +186,7 @@ ftl_anm_in_poller_range(struct ftl_anm_poller *poller, 
	struct ftl_ppa ppa = ftl_ppa_addr_unpack(dev, log->lba);

	char buf[128];



	if (ppa.chk >= ftl_dev_num_bands(dev)) {

	if (ppa.zone_id >= ftl_dev_num_bands(dev)) {

		SPDK_ERRLOG("ANM log contains invalid @ppa: %s\n",

			    ftl_ppa2str(ppa, buf, sizeof(buf)));

		return false;

lib/ftl/ftl_band.c

+22 −22
Original line number Diff line number Diff line
@@ -404,8 +404,8 @@ ftl_band_tail_md_ppa(struct ftl_band *band) 
		zone = ftl_band_next_zone(band, zone);

	}



	ppa.lbk = (num_req / band->num_zones) * xfer_size;

	ppa.chk = band->id;

	ppa.offset = (num_req / band->num_zones) * xfer_size;

	ppa.zone_id = band->id;

	ppa.pu = zone->punit->start_ppa.pu;



	return ppa;
@@ -421,7 +421,7 @@ ftl_band_head_md_ppa(struct ftl_band *band) 
	}



	ppa = CIRCLEQ_FIRST(&band->zones)->punit->start_ppa;

	ppa.chk = band->id;

	ppa.zone_id = band->id;



	return ppa;

}
@@ -511,8 +511,8 @@ ftl_band_user_lbks(const struct ftl_band *band) 
struct ftl_band *

ftl_band_from_ppa(struct spdk_ftl_dev *dev, struct ftl_ppa ppa)

{

	assert(ppa.chk < ftl_dev_num_bands(dev));

	return &dev->bands[ppa.chk];

	assert(ppa.zone_id < ftl_dev_num_bands(dev));

	return &dev->bands[ppa.zone_id];

}



struct ftl_zone *
@@ -534,9 +534,9 @@ ftl_band_lbkoff_from_ppa(struct ftl_band *band, struct ftl_ppa ppa) 
	unsigned int punit;



	punit = ftl_ppa_flatten_punit(dev, ppa);

	assert(ppa.chk == band->id);

	assert(ppa.zone_id == band->id);



	return punit * ftl_dev_lbks_in_zone(dev) + ppa.lbk;

	return punit * ftl_dev_lbks_in_zone(dev) + ppa.offset;

}



struct ftl_ppa
@@ -547,13 +547,13 @@ ftl_band_next_xfer_ppa(struct ftl_band *band, struct ftl_ppa ppa, size_t num_lbk 
	unsigned int punit_num;

	size_t num_xfers, num_stripes;



	assert(ppa.chk == band->id);

	assert(ppa.zone_id == band->id);



	punit_num = ftl_ppa_flatten_punit(dev, ppa);

	zone = &band->zone_buf[punit_num];



	num_lbks += (ppa.lbk % dev->xfer_size);

	ppa.lbk  -= (ppa.lbk % dev->xfer_size);

	num_lbks += (ppa.offset % dev->xfer_size);

	ppa.offset  -= (ppa.offset % dev->xfer_size);



#if defined(DEBUG)

	/* Check that the number of zones has not been changed */
@@ -568,10 +568,10 @@ ftl_band_next_xfer_ppa(struct ftl_band *band, struct ftl_ppa ppa, size_t num_lbk 
#endif

	assert(band->num_zones != 0);

	num_stripes = (num_lbks / dev->xfer_size) / band->num_zones;

	ppa.lbk  += num_stripes * dev->xfer_size;

	ppa.offset  += num_stripes * dev->xfer_size;

	num_lbks -= num_stripes * dev->xfer_size * band->num_zones;



	if (ppa.lbk > ftl_dev_lbks_in_zone(dev)) {

	if (ppa.offset > ftl_dev_lbks_in_zone(dev)) {

		return ftl_to_ppa(FTL_PPA_INVALID);

	}
@@ -580,8 +580,8 @@ ftl_band_next_xfer_ppa(struct ftl_band *band, struct ftl_ppa ppa, size_t num_lbk 
		/* When the last zone is reached the lbk part of the address */

		/* needs to be increased by xfer_size */

		if (ftl_band_zone_is_last(band, zone)) {

			ppa.lbk += dev->xfer_size;

			if (ppa.lbk > ftl_dev_lbks_in_zone(dev)) {

			ppa.offset += dev->xfer_size;

			if (ppa.offset > ftl_dev_lbks_in_zone(dev)) {

				return ftl_to_ppa(FTL_PPA_INVALID);

			}

		}
@@ -594,8 +594,8 @@ ftl_band_next_xfer_ppa(struct ftl_band *band, struct ftl_ppa ppa, size_t num_lbk 
	}



	if (num_lbks) {

		ppa.lbk += num_lbks;

		if (ppa.lbk > ftl_dev_lbks_in_zone(dev)) {

		ppa.offset += num_lbks;

		if (ppa.offset > ftl_dev_lbks_in_zone(dev)) {

			return ftl_to_ppa(FTL_PPA_INVALID);

		}

	}
@@ -610,10 +610,10 @@ ftl_xfer_offset_from_ppa(struct ftl_band *band, struct ftl_ppa ppa) 
	unsigned int punit_offset = 0;

	size_t off, num_stripes, xfer_size = band->dev->xfer_size;



	assert(ppa.chk == band->id);

	assert(ppa.zone_id == band->id);



	num_stripes = (ppa.lbk / xfer_size) * band->num_zones;

	off = ppa.lbk % xfer_size;

	num_stripes = (ppa.offset / xfer_size) * band->num_zones;

	off = ppa.offset % xfer_size;



	current_zone = ftl_band_zone_from_ppa(band, ppa);

	CIRCLEQ_FOREACH(zone, &band->zones, circleq) {
@@ -629,14 +629,14 @@ ftl_xfer_offset_from_ppa(struct ftl_band *band, struct ftl_ppa ppa) 
struct ftl_ppa

ftl_band_ppa_from_lbkoff(struct ftl_band *band, uint64_t lbkoff)

{

	struct ftl_ppa ppa = { .ppa = 0 };

	struct ftl_ppa ppa = { .addr = 0 };

	struct spdk_ftl_dev *dev = band->dev;

	uint64_t punit;



	punit = lbkoff / ftl_dev_lbks_in_zone(dev) + dev->range.begin;



	ppa.lbk = lbkoff % ftl_dev_lbks_in_zone(dev);

	ppa.chk = band->id;

	ppa.offset = lbkoff % ftl_dev_lbks_in_zone(dev);

	ppa.zone_id = band->id;

	ppa.pu = punit;



	return ppa;

lib/ftl/ftl_core.c

+21 −21
Original line number Diff line number Diff line
@@ -297,9 +297,9 @@ ftl_ppa_read_next_ppa(struct ftl_io *io, struct ftl_ppa *ppa) 
	/* Metadata has to be read in the way it's written (jumping across */

	/* the zones in xfer_size increments) */

	if (io->flags & FTL_IO_MD) {

		max_lbks = dev->xfer_size - (ppa->lbk % dev->xfer_size);

		max_lbks = dev->xfer_size - (ppa->offset % dev->xfer_size);

		lbk_cnt = spdk_min(ftl_io_iovec_len_left(io), max_lbks);

		assert(ppa->lbk / dev->xfer_size == (ppa->lbk + lbk_cnt - 1) / dev->xfer_size);

		assert(ppa->offset / dev->xfer_size == (ppa->offset + lbk_cnt - 1) / dev->xfer_size);

	} else {

		lbk_cnt = ftl_io_iovec_len_left(io);

	}
@@ -351,7 +351,7 @@ ftl_submit_erase(struct ftl_io *io) 
			ppa = zone->start_ppa;

		}



		assert(ppa.lbk == 0);

		assert(ppa.offset == 0);

		ppa_packed = ftl_ppa_addr_pack(dev, ppa);



		ftl_trace_submission(dev, io, ppa, 1);
@@ -586,7 +586,7 @@ ftl_wptr_advance(struct ftl_wptr *wptr, size_t xfer_size) 
	assert(!ftl_ppa_invalid(wptr->ppa));



	SPDK_DEBUGLOG(SPDK_LOG_FTL_CORE, "wptr: pu:%d zone:%d, lbk:%u\n",

		      wptr->ppa.pu, wptr->ppa.chk, wptr->ppa.lbk);

		      wptr->ppa.pu, wptr->ppa.zone_id, wptr->ppa.offset);



	if (wptr->offset >= next_thld && !dev->next_band) {

		dev->next_band = ftl_next_write_band(dev);
@@ -689,7 +689,7 @@ ftl_cache_lba_valid(struct spdk_ftl_dev *dev, struct ftl_rwb_entry *entry) 
	}



	ppa = ftl_l2p_get(dev, entry->lba);

	if (!(ftl_ppa_cached(ppa) && ppa.offset == entry->pos)) {

	if (!(ftl_ppa_cached(ppa) && ppa.cache_offset == entry->pos)) {

		return false;

	}
@@ -908,11 +908,11 @@ ftl_ppa_cache_read(struct ftl_io *io, uint64_t lba, 
	struct ftl_ppa nppa;

	int rc = 0;



	entry = ftl_rwb_entry_from_offset(rwb, ppa.offset);

	entry = ftl_rwb_entry_from_offset(rwb, ppa.cache_offset);

	pthread_spin_lock(&entry->lock);



	nppa = ftl_l2p_get(io->dev, lba);

	if (ppa.ppa != nppa.ppa) {

	if (ppa.addr != nppa.addr) {

		rc = -1;

		goto out;

	}
@@ -933,7 +933,7 @@ ftl_lba_read_next_ppa(struct ftl_io *io, struct ftl_ppa *ppa) 
	*ppa = ftl_l2p_get(dev, ftl_io_current_lba(io));



	SPDK_DEBUGLOG(SPDK_LOG_FTL_CORE, "Read ppa:%lx, lba:%lu\n",

		      ppa->ppa, ftl_io_current_lba(io));

		      ppa->addr, ftl_io_current_lba(io));



	/* If the PPA is invalid, skip it (the buffer should already be zero'ed) */

	if (ftl_ppa_invalid(*ppa)) {
@@ -1148,7 +1148,7 @@ ftl_nv_cache_submit_cb(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 
	struct ftl_nv_cache *nv_cache = &io->dev->nv_cache;



	if (spdk_unlikely(!success)) {

		SPDK_ERRLOG("Non-volatile cache write failed at %"PRIx64"\n", io->ppa.ppa);

		SPDK_ERRLOG("Non-volatile cache write failed at %"PRIx64"\n", io->ppa.addr);

		io->status = -EIO;

	}
@@ -1175,14 +1175,14 @@ ftl_submit_nv_cache(void *ctx) 
	thread = spdk_io_channel_get_thread(io->ioch);



	rc = spdk_bdev_write_blocks_with_md(nv_cache->bdev_desc, ioch->cache_ioch,

					    ftl_io_iovec_addr(io), io->md, io->ppa.ppa,

					    ftl_io_iovec_addr(io), io->md, io->ppa.addr,

					    io->lbk_cnt, ftl_nv_cache_submit_cb, io);

	if (rc == -ENOMEM) {

		spdk_thread_send_msg(thread, ftl_submit_nv_cache, io);

		return;

	} else if (rc) {

		SPDK_ERRLOG("Write to persistent cache failed: %s (%"PRIu64", %"PRIu64")\n",

			    spdk_strerror(-rc), io->ppa.ppa, io->lbk_cnt);

			    spdk_strerror(-rc), io->ppa.addr, io->lbk_cnt);

		spdk_mempool_put(nv_cache->md_pool, io->md);

		io->status = -EIO;

		ftl_io_complete(io);
@@ -1238,8 +1238,8 @@ _ftl_write_nv_cache(void *ctx) 
		}



		/* Reserve area on the write buffer cache */

		child->ppa.ppa = ftl_reserve_nv_cache(&dev->nv_cache, &num_lbks, &phase);

		if (child->ppa.ppa == FTL_LBA_INVALID) {

		child->ppa.addr = ftl_reserve_nv_cache(&dev->nv_cache, &num_lbks, &phase);

		if (child->ppa.addr == FTL_LBA_INVALID) {

			spdk_mempool_put(dev->nv_cache.md_pool, child->md);

			ftl_io_free(child);

			spdk_thread_send_msg(thread, _ftl_write_nv_cache, io);
@@ -1362,7 +1362,7 @@ ftl_write_cb(struct ftl_io *io, void *arg, int status) 
		}



		SPDK_DEBUGLOG(SPDK_LOG_FTL_CORE, "Write ppa:%lu, lba:%lu\n",

			      entry->ppa.ppa, entry->lba);

			      entry->ppa.addr, entry->lba);

	}



	ftl_process_flush(dev, batch);
@@ -1401,7 +1401,7 @@ ftl_update_l2p(struct spdk_ftl_dev *dev, const struct ftl_rwb_entry *entry, 


	if (ftl_ppa_cached(prev_ppa)) {

		assert(!ftl_rwb_entry_weak(entry));

		prev = ftl_rwb_entry_from_offset(dev->rwb, prev_ppa.offset);

		prev = ftl_rwb_entry_from_offset(dev->rwb, prev_ppa.cache_offset);

		pthread_spin_lock(&prev->lock);



		/* Re-read the L2P under the lock to protect against updates */
@@ -1503,7 +1503,7 @@ ftl_submit_child_write(struct ftl_wptr *wptr, struct ftl_io *io, int lbk_cnt) 
		ppa = wptr->ppa;

	} else {

		assert(io->flags & FTL_IO_DIRECT_ACCESS);

		assert(io->ppa.chk == wptr->band->id);

		assert(io->ppa.zone_id == wptr->band->id);

		ppa = io->ppa;

	}
@@ -1524,7 +1524,7 @@ ftl_submit_child_write(struct ftl_wptr *wptr, struct ftl_io *io, int lbk_cnt) 
		ftl_io_fail(child, rc);

		ftl_io_complete(child);

		SPDK_ERRLOG("spdk_nvme_ns_cmd_write_with_md failed with status:%d, ppa:%lu\n",

			    rc, ppa.ppa);

			    rc, ppa.addr);

		return -EIO;

	}
@@ -1658,7 +1658,7 @@ ftl_wptr_process_writes(struct ftl_wptr *wptr) 
			prev_ppa = ftl_l2p_get(dev, entry->lba);



			/* If the l2p was updated in the meantime, don't update band's metadata */

			if (ftl_ppa_cached(prev_ppa) && prev_ppa.offset == entry->pos) {

			if (ftl_ppa_cached(prev_ppa) && prev_ppa.cache_offset == entry->pos) {

				/* Setting entry's cache bit needs to be done after metadata */

				/* within the band is updated to make sure that writes */

				/* invalidating the entry clear the metadata as well */
@@ -1674,7 +1674,7 @@ ftl_wptr_process_writes(struct ftl_wptr *wptr) 
		ppa = ftl_band_next_ppa(wptr->band, ppa, 1);

	}



	SPDK_DEBUGLOG(SPDK_LOG_FTL_CORE, "Write ppa:%lx, %lx\n", wptr->ppa.ppa,

	SPDK_DEBUGLOG(SPDK_LOG_FTL_CORE, "Write ppa:%lx, %lx\n", wptr->ppa.addr,

		      ftl_ppa_addr_pack(dev, wptr->ppa));



	if (ftl_submit_write(wptr, io)) {
@@ -1756,7 +1756,7 @@ ftl_rwb_fill(struct ftl_io *io) 


		ftl_rwb_entry_fill(entry, io);



		ppa.offset = entry->pos;

		ppa.cache_offset = entry->pos;



		ftl_trace_rwb_fill(dev, io);

		ftl_update_l2p(dev, entry, ppa);
@@ -2151,7 +2151,7 @@ ftl_ppa_is_written(struct ftl_band *band, struct ftl_ppa ppa) 
{

	struct ftl_zone *zone = ftl_band_zone_from_ppa(band, ppa);



	return ppa.lbk < zone->write_offset;

	return ppa.offset < zone->write_offset;

}



static void

lib/ftl/ftl_core.h

+17 −17
Original line number Diff line number Diff line
@@ -303,11 +303,11 @@ int ftl_nv_cache_scrub(struct ftl_nv_cache *nv_cache, spdk_bdev_io_completion_cb 
struct spdk_io_channel *

ftl_get_io_channel(const struct spdk_ftl_dev *dev);



#define ftl_to_ppa(addr) \

	(struct ftl_ppa) { .ppa = (uint64_t)(addr) }

#define ftl_to_ppa(address) \

	(struct ftl_ppa) { .addr = (uint64_t)(address) }



#define ftl_to_ppa_packed(addr) \

	(struct ftl_ppa) { .pack.ppa = (uint32_t)(addr) }

#define ftl_to_ppa_packed(address) \

	(struct ftl_ppa) { .pack.addr = (uint32_t)(address) }



static inline struct spdk_thread *

ftl_get_core_thread(const struct spdk_ftl_dev *dev)
@@ -342,7 +342,7 @@ ftl_ppa_packed(const struct spdk_ftl_dev *dev) 
static inline int

ftl_ppa_invalid(struct ftl_ppa ppa)

{

	return ppa.ppa == ftl_to_ppa(FTL_PPA_INVALID).ppa;

	return ppa.addr == ftl_to_ppa(FTL_PPA_INVALID).addr;

}



static inline int
@@ -356,8 +356,8 @@ ftl_ppa_addr_pack(const struct spdk_ftl_dev *dev, struct ftl_ppa ppa) 
{

	uint64_t lbk, chk, pu, grp;



	lbk = ppa.lbk;

	chk = ppa.chk;

	lbk = ppa.offset;

	chk = ppa.zone_id;

	pu = ppa.pu / dev->geo.num_grp;

	grp = ppa.pu % dev->geo.num_grp;
@@ -373,8 +373,8 @@ ftl_ppa_addr_unpack(const struct spdk_ftl_dev *dev, uint64_t ppa) 
	struct ftl_ppa res = {};

	unsigned int pu, grp;



	res.lbk = (ppa >> dev->ppaf.lbk_offset) & dev->ppaf.lbk_mask;

	res.chk = (ppa >> dev->ppaf.chk_offset) & dev->ppaf.chk_mask;

	res.offset = (ppa >> dev->ppaf.lbk_offset) & dev->ppaf.lbk_mask;

	res.zone_id = (ppa >> dev->ppaf.chk_offset) & dev->ppaf.chk_mask;

	pu  = (ppa >> dev->ppaf.pu_offset)  & dev->ppaf.pu_mask;

	grp = (ppa >> dev->ppaf.grp_offset) & dev->ppaf.grp_mask;

	res.pu = grp * dev->geo.num_pu + pu;
@@ -391,9 +391,9 @@ ftl_ppa_to_packed(const struct spdk_ftl_dev *dev, struct ftl_ppa ppa) 
		p = ftl_to_ppa_packed(FTL_PPA_INVALID);

	} else if (ftl_ppa_cached(ppa)) {

		p.pack.cached = 1;

		p.pack.offset = (uint32_t) ppa.offset;

		p.pack.cache_offset = (uint32_t) ppa.cache_offset;

	} else {

		p.pack.ppa = (uint32_t) ftl_ppa_addr_pack(dev, ppa);

		p.pack.addr = (uint32_t) ftl_ppa_addr_pack(dev, ppa);

	}



	return p;
@@ -404,13 +404,13 @@ ftl_ppa_from_packed(const struct spdk_ftl_dev *dev, struct ftl_ppa p) 
{

	struct ftl_ppa ppa = {};



	if (p.pack.ppa == (uint32_t)FTL_PPA_INVALID) {

	if (p.pack.addr == (uint32_t)FTL_PPA_INVALID) {

		ppa = ftl_to_ppa(FTL_PPA_INVALID);

	} else if (p.pack.cached) {

		ppa.cached = 1;

		ppa.offset = p.pack.offset;

		ppa.cache_offset = p.pack.cache_offset;

	} else {

		ppa = ftl_ppa_addr_unpack(dev, p.pack.ppa);

		ppa = ftl_ppa_addr_unpack(dev, p.pack.addr);

	}



	return ppa;
@@ -451,7 +451,7 @@ ftl_ppa_in_range(const struct spdk_ftl_dev *dev, struct ftl_ppa ppa) 
	_ftl_l2p_get(l2p, off, 64)



#define ftl_ppa_cmp(p1, p2) \

	((p1).ppa == (p2).ppa)

	((p1).addr == (p2).addr)



static inline void

ftl_l2p_set(struct spdk_ftl_dev *dev, uint64_t lba, struct ftl_ppa ppa)
@@ -459,9 +459,9 @@ ftl_l2p_set(struct spdk_ftl_dev *dev, uint64_t lba, struct ftl_ppa ppa) 
	assert(dev->num_lbas > lba);



	if (ftl_ppa_packed(dev)) {

		_ftl_l2p_set32(dev->l2p, lba, ftl_ppa_to_packed(dev, ppa).ppa);

		_ftl_l2p_set32(dev->l2p, lba, ftl_ppa_to_packed(dev, ppa).addr);

	} else {

		_ftl_l2p_set64(dev->l2p, lba, ppa.ppa);

		_ftl_l2p_set64(dev->l2p, lba, ppa.addr);

	}

}

lib/ftl/ftl_debug.c

+1 −1
Original line number Diff line number Diff line
@@ -79,7 +79,7 @@ ftl_band_validate_md(struct ftl_band *band) 
			continue;

		}



		if (ppa_l2p.ppa != ppa_md.ppa) {

		if (ppa_l2p.addr != ppa_md.addr) {

			valid = false;

			break;

		}