From 39965ab04851499a25b9515ef5f91aeeb097951c Mon Sep 17 00:00:00 2001 From: Wojciech Malikowski Date: Thu, 24 Oct 2019 10:36:42 -0400 Subject: [PATCH] lib/ftl: Change "lbk" name to "block" "lbk" name is more OCSSD specific so in generic FTL "block" name is more suitable. Change-Id: I792780297b792bf5e02f13cc20346da56b032918 Signed-off-by: Wojciech Malikowski Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/472284 Community-CI: SPDK CI Jenkins Reviewed-by: Shuhei Matsumoto Reviewed-by: Jim Harris Reviewed-by: Konrad Sztyber Tested-by: SPDK CI Jenkins --- include/spdk/ftl.h | 6 +- lib/ftl/ftl_band.c | 170 +++++++++---------- lib/ftl/ftl_band.h | 16 +- lib/ftl/ftl_core.c | 118 ++++++------- lib/ftl/ftl_core.h | 10 +- lib/ftl/ftl_debug.c | 4 +- lib/ftl/ftl_init.c | 16 +- lib/ftl/ftl_io.c | 82 ++++----- lib/ftl/ftl_io.h | 22 +-- lib/ftl/ftl_reloc.c | 114 ++++++------- lib/ftl/ftl_reloc.h | 2 +- lib/ftl/ftl_restore.c | 14 +- lib/ftl/ftl_trace.c | 2 +- module/bdev/ftl/bdev_ftl.c | 8 +- test/unit/lib/ftl/ftl_band.c/ftl_band_ut.c | 28 +-- test/unit/lib/ftl/ftl_md/ftl_md_ut.c | 2 +- test/unit/lib/ftl/ftl_reloc.c/ftl_reloc_ut.c | 76 ++++----- test/unit/lib/ftl/ftl_wptr/ftl_wptr_ut.c | 14 +- 18 files changed, 352 insertions(+), 352 deletions(-) diff --git a/include/spdk/ftl.h b/include/spdk/ftl.h index 341734b17..1fa549368 100644 --- a/include/spdk/ftl.h +++ b/include/spdk/ftl.h @@ -81,7 +81,7 @@ struct spdk_ftl_conf { /* IO pool size per user thread */ size_t user_io_pool_size; - /* Lowest percentage of invalid lbks for a band to be defragged */ + /* Lowest percentage of invalid blocks for a band to be defragged */ size_t invalid_thld; /* User writes limits */ @@ -134,9 +134,9 @@ struct spdk_ftl_attrs { /* Device's UUID */ struct spdk_uuid uuid; /* Number of logical blocks */ - uint64_t lbk_cnt; + uint64_t num_blocks; /* Logical block size */ - size_t lbk_size; + size_t block_size; /* Write buffer cache */ struct spdk_bdev_desc *cache_bdev_desc; /* Number of zones per parallel unit in the underlying device (including any offline ones) */ diff --git a/lib/ftl/ftl_band.c b/lib/ftl/ftl_band.c index fb687d79b..625068d9b 100644 --- a/lib/ftl/ftl_band.c +++ b/lib/ftl/ftl_band.c @@ -66,8 +66,8 @@ struct __attribute__((packed)) ftl_md_hdr { struct __attribute__((packed)) ftl_tail_md { struct ftl_md_hdr hdr; - /* Max number of lbks */ - uint64_t num_lbks; + /* Max number of blocks */ + uint64_t num_blocks; uint8_t reserved[4059]; }; @@ -87,43 +87,43 @@ struct __attribute__((packed)) ftl_head_md { }; size_t -ftl_tail_md_hdr_num_lbks(void) +ftl_tail_md_hdr_num_blocks(void) { return spdk_divide_round_up(sizeof(struct ftl_tail_md), FTL_BLOCK_SIZE); } size_t -ftl_vld_map_num_lbks(const struct spdk_ftl_dev *dev) +ftl_vld_map_num_blocks(const struct spdk_ftl_dev *dev) { return spdk_divide_round_up(ftl_vld_map_size(dev), FTL_BLOCK_SIZE); } size_t -ftl_lba_map_num_lbks(const struct spdk_ftl_dev *dev) +ftl_lba_map_num_blocks(const struct spdk_ftl_dev *dev) { return spdk_divide_round_up(ftl_get_num_blocks_in_band(dev) * sizeof(uint64_t), FTL_BLOCK_SIZE); } size_t -ftl_head_md_num_lbks(const struct spdk_ftl_dev *dev) +ftl_head_md_num_blocks(const struct spdk_ftl_dev *dev) { return dev->xfer_size; } size_t -ftl_tail_md_num_lbks(const struct spdk_ftl_dev *dev) +ftl_tail_md_num_blocks(const struct spdk_ftl_dev *dev) { - return spdk_divide_round_up(ftl_tail_md_hdr_num_lbks() + - ftl_vld_map_num_lbks(dev) + - ftl_lba_map_num_lbks(dev), + return spdk_divide_round_up(ftl_tail_md_hdr_num_blocks() + + ftl_vld_map_num_blocks(dev) + + ftl_lba_map_num_blocks(dev), dev->xfer_size) * dev->xfer_size; } static uint64_t ftl_band_tail_md_offset(const struct ftl_band *band) { - return ftl_band_num_usable_lbks(band) - - ftl_tail_md_num_lbks(band->dev); + return ftl_band_num_usable_blocks(band) - + ftl_tail_md_num_blocks(band->dev); } int @@ -284,17 +284,17 @@ ftl_pack_tail_md(struct ftl_band *band) struct ftl_tail_md *tail = lba_map->dma_buf; void *vld_offset; - vld_offset = (char *)tail + ftl_tail_md_hdr_num_lbks() * FTL_BLOCK_SIZE; + vld_offset = (char *)tail + ftl_tail_md_hdr_num_blocks() * FTL_BLOCK_SIZE; /* Clear out the buffer */ - memset(tail, 0, ftl_tail_md_hdr_num_lbks() * FTL_BLOCK_SIZE); - tail->num_lbks = ftl_get_num_blocks_in_band(dev); + memset(tail, 0, ftl_tail_md_hdr_num_blocks() * FTL_BLOCK_SIZE); + tail->num_blocks = ftl_get_num_blocks_in_band(dev); pthread_spin_lock(&lba_map->lock); spdk_bit_array_store_mask(lba_map->vld, vld_offset); pthread_spin_unlock(&lba_map->lock); - ftl_set_md_hdr(band, &tail->hdr, ftl_tail_md_num_lbks(dev) * FTL_BLOCK_SIZE); + ftl_set_md_hdr(band, &tail->hdr, ftl_tail_md_num_blocks(dev) * FTL_BLOCK_SIZE); return FTL_MD_SUCCESS; } @@ -326,9 +326,9 @@ ftl_unpack_tail_md(struct ftl_band *band) struct ftl_tail_md *tail = lba_map->dma_buf; int rc; - vld_offset = (char *)tail + ftl_tail_md_hdr_num_lbks() * FTL_BLOCK_SIZE; + vld_offset = (char *)tail + ftl_tail_md_hdr_num_blocks() * FTL_BLOCK_SIZE; - rc = ftl_md_hdr_vld(dev, &tail->hdr, ftl_tail_md_num_lbks(dev) * FTL_BLOCK_SIZE); + rc = ftl_md_hdr_vld(dev, &tail->hdr, ftl_tail_md_num_blocks(dev) * FTL_BLOCK_SIZE); if (rc) { return rc; } @@ -343,7 +343,7 @@ ftl_unpack_tail_md(struct ftl_band *band) return FTL_MD_NO_MD; } - if (tail->num_lbks != ftl_get_num_blocks_in_band(dev)) { + if (tail->num_blocks != ftl_get_num_blocks_in_band(dev)) { return FTL_MD_INVALID_SIZE; } @@ -456,7 +456,7 @@ ftl_band_set_addr(struct ftl_band *band, uint64_t lba, struct ftl_addr addr) assert(lba != FTL_LBA_INVALID); - offset = ftl_band_lbkoff_from_addr(band, addr); + offset = ftl_band_block_offset_from_addr(band, addr); pthread_spin_lock(&lba_map->lock); lba_map->num_vld++; @@ -473,18 +473,18 @@ ftl_band_age(const struct ftl_band *band) } size_t -ftl_band_num_usable_lbks(const struct ftl_band *band) +ftl_band_num_usable_blocks(const struct ftl_band *band) { return band->num_zones * ftl_get_num_blocks_in_zone(band->dev); } size_t -ftl_band_user_lbks_left(const struct ftl_band *band, size_t offset) +ftl_band_user_blocks_left(const struct ftl_band *band, size_t offset) { size_t tail_md_offset = ftl_band_tail_md_offset(band); - if (spdk_unlikely(offset <= ftl_head_md_num_lbks(band->dev))) { - return ftl_band_user_lbks(band); + if (spdk_unlikely(offset <= ftl_head_md_num_blocks(band->dev))) { + return ftl_band_user_blocks(band); } if (spdk_unlikely(offset > tail_md_offset)) { @@ -495,11 +495,11 @@ ftl_band_user_lbks_left(const struct ftl_band *band, size_t offset) } size_t -ftl_band_user_lbks(const struct ftl_band *band) +ftl_band_user_blocks(const struct ftl_band *band) { - return ftl_band_num_usable_lbks(band) - - ftl_head_md_num_lbks(band->dev) - - ftl_tail_md_num_lbks(band->dev); + return ftl_band_num_usable_blocks(band) - + ftl_head_md_num_blocks(band->dev) - + ftl_tail_md_num_blocks(band->dev); } struct ftl_band * @@ -521,7 +521,7 @@ ftl_band_zone_from_addr(struct ftl_band *band, struct ftl_addr addr) } uint64_t -ftl_band_lbkoff_from_addr(struct ftl_band *band, struct ftl_addr addr) +ftl_band_block_offset_from_addr(struct ftl_band *band, struct ftl_addr addr) { assert(ftl_addr_get_band(band->dev, addr) == band->id); assert(ftl_addr_get_punit(band->dev, addr) < ftl_get_num_punits(band->dev)); @@ -529,7 +529,7 @@ ftl_band_lbkoff_from_addr(struct ftl_band *band, struct ftl_addr addr) } struct ftl_addr -ftl_band_next_xfer_addr(struct ftl_band *band, struct ftl_addr addr, size_t num_lbks) +ftl_band_next_xfer_addr(struct ftl_band *band, struct ftl_addr addr, size_t num_blocks) { struct spdk_ftl_dev *dev = band->dev; struct ftl_zone *zone; @@ -541,8 +541,8 @@ ftl_band_next_xfer_addr(struct ftl_band *band, struct ftl_addr addr, size_t num_ offset = ftl_addr_get_zone_offset(dev, addr); zone = ftl_band_zone_from_addr(band, addr); - num_lbks += (offset % dev->xfer_size); - offset -= (offset % dev->xfer_size); + num_blocks += (offset % dev->xfer_size); + offset -= (offset % dev->xfer_size); #if defined(DEBUG) /* Check that the number of zones has not been changed */ @@ -556,17 +556,17 @@ ftl_band_next_xfer_addr(struct ftl_band *band, struct ftl_addr addr, size_t num_ assert(band->num_zones == _num_zones); #endif assert(band->num_zones != 0); - num_stripes = (num_lbks / dev->xfer_size) / band->num_zones; + num_stripes = (num_blocks / dev->xfer_size) / band->num_zones; offset += num_stripes * dev->xfer_size; - num_lbks -= num_stripes * dev->xfer_size * band->num_zones; + num_blocks -= num_stripes * dev->xfer_size * band->num_zones; if (offset > ftl_get_num_blocks_in_zone(dev)) { return ftl_to_addr(FTL_ADDR_INVALID); } - num_xfers = num_lbks / dev->xfer_size; + num_xfers = num_blocks / dev->xfer_size; for (size_t i = 0; i < num_xfers; ++i) { - /* When the last zone is reached the lbk part of the address */ + /* When the last zone is reached the block part of the address */ /* needs to be increased by xfer_size */ if (ftl_band_zone_is_last(band, zone)) { offset += dev->xfer_size; @@ -578,11 +578,11 @@ ftl_band_next_xfer_addr(struct ftl_band *band, struct ftl_addr addr, size_t num_ zone = ftl_band_next_operational_zone(band, zone); assert(zone); - num_lbks -= dev->xfer_size; + num_blocks -= dev->xfer_size; } - if (num_lbks) { - offset += num_lbks; + if (num_blocks) { + offset += num_blocks; if (offset > ftl_get_num_blocks_in_zone(dev)) { return ftl_to_addr(FTL_ADDR_INVALID); } @@ -617,19 +617,19 @@ ftl_xfer_offset_from_addr(struct ftl_band *band, struct ftl_addr addr) } struct ftl_addr -ftl_band_addr_from_lbkoff(struct ftl_band *band, uint64_t lbkoff) +ftl_band_addr_from_block_offset(struct ftl_band *band, uint64_t block_off) { struct ftl_addr addr = { .offset = 0 }; - addr.offset = lbkoff + band->id * ftl_get_num_blocks_in_band(band->dev); + addr.offset = block_off + band->id * ftl_get_num_blocks_in_band(band->dev); return addr; } struct ftl_addr ftl_band_next_addr(struct ftl_band *band, struct ftl_addr addr, size_t offset) { - uint64_t lbkoff = ftl_band_lbkoff_from_addr(band, addr); - return ftl_band_addr_from_lbkoff(band, lbkoff + offset); + uint64_t block_off = ftl_band_block_offset_from_addr(band, addr); + return ftl_band_addr_from_block_offset(band, block_off + offset); } void @@ -657,9 +657,9 @@ ftl_band_alloc_lba_map(struct ftl_band *band) memset(lba_map->dma_buf, 0, ftl_lba_map_pool_elem_size(band->dev)); lba_map->map = (uint64_t *)((char *)lba_map->dma_buf + FTL_BLOCK_SIZE * - (ftl_tail_md_hdr_num_lbks() + ftl_vld_map_num_lbks(dev))); + (ftl_tail_md_hdr_num_blocks() + ftl_vld_map_num_blocks(dev))); - lba_map->segments = (char *)lba_map->dma_buf + ftl_tail_md_num_lbks(dev) * FTL_BLOCK_SIZE; + lba_map->segments = (char *)lba_map->dma_buf + ftl_tail_md_num_blocks(dev) * FTL_BLOCK_SIZE; ftl_band_acquire_lba_map(band); return 0; @@ -695,7 +695,7 @@ ftl_read_md_cb(struct ftl_io *io, void *arg, int status) static struct ftl_md_io * ftl_io_init_md_read(struct spdk_ftl_dev *dev, struct ftl_addr addr, - struct ftl_band *band, size_t lbk_cnt, void *buf, + struct ftl_band *band, size_t num_blocks, void *buf, ftl_io_fn fn, ftl_md_pack_fn pack_fn, ftl_io_fn cb_fn, void *cb_ctx) { struct ftl_md_io *io; @@ -707,7 +707,7 @@ ftl_io_init_md_read(struct spdk_ftl_dev *dev, struct ftl_addr addr, .size = sizeof(*io), .flags = FTL_IO_MD | FTL_IO_PHYSICAL_MODE, .type = FTL_IO_READ, - .lbk_cnt = lbk_cnt, + .num_blocks = num_blocks, .cb_fn = fn, .data = buf, }; @@ -727,7 +727,7 @@ ftl_io_init_md_read(struct spdk_ftl_dev *dev, struct ftl_addr addr, static struct ftl_io * ftl_io_init_md_write(struct spdk_ftl_dev *dev, struct ftl_band *band, - void *data, size_t lbk_cnt, ftl_io_fn cb) + void *data, size_t num_blocks, ftl_io_fn cb) { struct ftl_io_init_opts opts = { .dev = dev, @@ -737,7 +737,7 @@ ftl_io_init_md_write(struct spdk_ftl_dev *dev, struct ftl_band *band, .size = sizeof(struct ftl_io), .flags = FTL_IO_MD | FTL_IO_PHYSICAL_MODE, .type = FTL_IO_WRITE, - .lbk_cnt = lbk_cnt, + .num_blocks = num_blocks, .cb_fn = cb, .data = data, .md = NULL, @@ -747,13 +747,13 @@ ftl_io_init_md_write(struct spdk_ftl_dev *dev, struct ftl_band *band, } static int -ftl_band_write_md(struct ftl_band *band, size_t lbk_cnt, +ftl_band_write_md(struct ftl_band *band, size_t num_blocks, ftl_md_pack_fn md_fn, ftl_io_fn cb) { struct spdk_ftl_dev *dev = band->dev; struct ftl_io *io; - io = ftl_io_init_md_write(dev, band, band->lba_map.dma_buf, lbk_cnt, cb); + io = ftl_io_init_md_write(dev, band, band->lba_map.dma_buf, num_blocks, cb); if (!io) { return -ENOMEM; } @@ -776,14 +776,14 @@ ftl_band_md_clear(struct ftl_band *band) int ftl_band_write_head_md(struct ftl_band *band, ftl_io_fn cb) { - return ftl_band_write_md(band, ftl_head_md_num_lbks(band->dev), + return ftl_band_write_md(band, ftl_head_md_num_blocks(band->dev), ftl_pack_head_md, cb); } int ftl_band_write_tail_md(struct ftl_band *band, ftl_io_fn cb) { - return ftl_band_write_md(band, ftl_tail_md_num_lbks(band->dev), + return ftl_band_write_md(band, ftl_tail_md_num_blocks(band->dev), ftl_pack_tail_md, cb); } @@ -791,13 +791,13 @@ static struct ftl_addr ftl_band_lba_map_addr(struct ftl_band *band, size_t offset) { return ftl_band_next_xfer_addr(band, band->tail_md_addr, - ftl_tail_md_hdr_num_lbks() + - ftl_vld_map_num_lbks(band->dev) + + ftl_tail_md_hdr_num_blocks() + + ftl_vld_map_num_blocks(band->dev) + offset); } static int -ftl_band_read_md(struct ftl_band *band, size_t lbk_cnt, struct ftl_addr start_addr, +ftl_band_read_md(struct ftl_band *band, size_t num_blocks, struct ftl_addr start_addr, void *buf, ftl_io_fn fn, ftl_md_pack_fn pack_fn, ftl_io_fn cb_fn, void *cb_ctx) { struct spdk_ftl_dev *dev = band->dev; @@ -807,7 +807,7 @@ ftl_band_read_md(struct ftl_band *band, size_t lbk_cnt, struct ftl_addr start_ad return -ENOENT; } - io = ftl_io_init_md_read(dev, start_addr, band, lbk_cnt, buf, fn, pack_fn, cb_fn, cb_ctx); + io = ftl_io_init_md_read(dev, start_addr, band, num_blocks, buf, fn, pack_fn, cb_fn, cb_ctx); if (!io) { return -ENOMEM; } @@ -819,7 +819,7 @@ ftl_band_read_md(struct ftl_band *band, size_t lbk_cnt, struct ftl_addr start_ad int ftl_band_read_tail_md(struct ftl_band *band, struct ftl_addr addr, ftl_io_fn cb_fn, void *cb_ctx) { - return ftl_band_read_md(band, ftl_tail_md_num_lbks(band->dev), addr, band->lba_map.dma_buf, + return ftl_band_read_md(band, ftl_tail_md_num_blocks(band->dev), addr, band->lba_map.dma_buf, ftl_read_md_cb, ftl_unpack_tail_md, cb_fn, cb_ctx); } @@ -884,7 +884,7 @@ ftl_lba_map_offset_from_addr(struct ftl_band *band, struct ftl_addr addr) struct ftl_addr start_addr = ftl_band_lba_map_addr(band, 0); offset = ftl_xfer_offset_from_addr(band, addr) - ftl_xfer_offset_from_addr(band, start_addr); - assert(offset < ftl_lba_map_num_lbks(band->dev)); + assert(offset < ftl_lba_map_num_blocks(band->dev)); return offset; } @@ -893,17 +893,17 @@ static void ftl_read_lba_map_cb(struct ftl_io *io, void *arg, int status) { struct ftl_lba_map *lba_map = &io->band->lba_map; - uint64_t lbk_off; + uint64_t block_off; - lbk_off = ftl_lba_map_offset_from_addr(io->band, io->addr); - assert(lbk_off + io->lbk_cnt <= ftl_lba_map_num_lbks(io->dev)); + block_off = ftl_lba_map_offset_from_addr(io->band, io->addr); + assert(block_off + io->num_blocks <= ftl_lba_map_num_blocks(io->dev)); if (!status) { - ftl_lba_map_set_segment_state(lba_map, lbk_off, io->lbk_cnt, + ftl_lba_map_set_segment_state(lba_map, block_off, io->num_blocks, FTL_LBA_MAP_SEG_CACHED); } - ftl_process_lba_map_requests(io->dev, lba_map, lbk_off, io->lbk_cnt, status); + ftl_process_lba_map_requests(io->dev, lba_map, block_off, io->num_blocks, status); } static struct ftl_lba_map_request * @@ -950,46 +950,46 @@ int ftl_band_read_lba_map(struct ftl_band *band, size_t offset, size_t lba_cnt, ftl_io_fn cb_fn, void *cb_ctx) { - size_t lbk_cnt, lbk_off, num_read, num_segments; + size_t num_blocks, block_off, num_read, num_segments; struct ftl_lba_map *lba_map = &band->lba_map; struct ftl_lba_map_request *request; int rc = 0; - lbk_off = offset / FTL_NUM_LBA_IN_BLOCK; + block_off = offset / FTL_NUM_LBA_IN_BLOCK; num_segments = spdk_divide_round_up(offset + lba_cnt, FTL_NUM_LBA_IN_BLOCK); - lbk_cnt = num_segments - lbk_off; - assert(lbk_off + lbk_cnt <= ftl_lba_map_num_lbks(band->dev)); + num_blocks = num_segments - block_off; + assert(block_off + num_blocks <= ftl_lba_map_num_blocks(band->dev)); - request = ftl_lba_map_alloc_request(band, lbk_off, lbk_cnt, cb_fn, cb_ctx); + request = ftl_lba_map_alloc_request(band, block_off, num_blocks, cb_fn, cb_ctx); if (!request) { return -ENOMEM; } - while (lbk_cnt) { - if (lba_map->segments[lbk_off] != FTL_LBA_MAP_SEG_CLEAR) { - if (lba_map->segments[lbk_off] == FTL_LBA_MAP_SEG_CACHED) { - ftl_lba_map_request_segment_done(request, lbk_off, 1); + while (num_blocks) { + if (lba_map->segments[block_off] != FTL_LBA_MAP_SEG_CLEAR) { + if (lba_map->segments[block_off] == FTL_LBA_MAP_SEG_CACHED) { + ftl_lba_map_request_segment_done(request, block_off, 1); } - lbk_cnt--; - lbk_off++; + num_blocks--; + block_off++; continue; } - num_read = ftl_lba_map_num_clear_segments(lba_map, lbk_off, lbk_cnt); - ftl_lba_map_set_segment_state(lba_map, lbk_off, num_read, + num_read = ftl_lba_map_num_clear_segments(lba_map, block_off, num_blocks); + ftl_lba_map_set_segment_state(lba_map, block_off, num_read, FTL_LBA_MAP_SEG_PENDING); - rc = ftl_band_read_md(band, num_read, ftl_band_lba_map_addr(band, lbk_off), - (char *)band->lba_map.map + lbk_off * FTL_BLOCK_SIZE, + rc = ftl_band_read_md(band, num_read, ftl_band_lba_map_addr(band, block_off), + (char *)band->lba_map.map + block_off * FTL_BLOCK_SIZE, ftl_read_lba_map_cb, NULL, cb_fn, cb_ctx); if (rc) { ftl_lba_map_request_free(band->dev, request); return rc; } - assert(lbk_cnt >= num_read); - lbk_cnt -= num_read; - lbk_off += num_read; + assert(num_blocks >= num_read); + num_blocks -= num_read; + block_off += num_read; } if (request->num_pending) { @@ -1006,7 +1006,7 @@ int ftl_band_read_head_md(struct ftl_band *band, ftl_io_fn cb_fn, void *cb_ctx) { return ftl_band_read_md(band, - ftl_head_md_num_lbks(band->dev), + ftl_head_md_num_blocks(band->dev), ftl_band_head_md_addr(band), band->lba_map.dma_buf, ftl_read_md_cb, @@ -1137,7 +1137,7 @@ ftl_band_clear_lba_map(struct ftl_band *band) size_t num_segments; spdk_bit_array_clear_mask(lba_map->vld); - memset(lba_map->map, 0, ftl_lba_map_num_lbks(band->dev) * FTL_BLOCK_SIZE); + memset(lba_map->map, 0, ftl_lba_map_num_blocks(band->dev) * FTL_BLOCK_SIZE); /* For open band all lba map segments are already cached */ assert(band->state == FTL_BAND_STATE_PREP); @@ -1151,6 +1151,6 @@ size_t ftl_lba_map_pool_elem_size(struct spdk_ftl_dev *dev) { /* Map pool element holds the whole tail md + segments map */ - return ftl_tail_md_num_lbks(dev) * FTL_BLOCK_SIZE + + return ftl_tail_md_num_blocks(dev) * FTL_BLOCK_SIZE + spdk_divide_round_up(ftl_get_num_blocks_in_band(dev), FTL_NUM_LBA_IN_BLOCK); } diff --git a/lib/ftl/ftl_band.h b/lib/ftl/ftl_band.h index 92612bcef..98145d75a 100644 --- a/lib/ftl/ftl_band.h +++ b/lib/ftl/ftl_band.h @@ -182,8 +182,8 @@ struct ftl_band { STAILQ_ENTRY(ftl_band) prio_stailq; }; -uint64_t ftl_band_lbkoff_from_addr(struct ftl_band *band, struct ftl_addr addr); -struct ftl_addr ftl_band_addr_from_lbkoff(struct ftl_band *band, uint64_t lbkoff); +uint64_t ftl_band_block_offset_from_addr(struct ftl_band *band, struct ftl_addr addr); +struct ftl_addr ftl_band_addr_from_block_offset(struct ftl_band *band, uint64_t block_off); void ftl_band_set_state(struct ftl_band *band, enum ftl_band_state state); size_t ftl_band_age(const struct ftl_band *band); void ftl_band_acquire_lba_map(struct ftl_band *band); @@ -194,12 +194,12 @@ int ftl_band_read_lba_map(struct ftl_band *band, size_t offset, size_t lba_cnt, ftl_io_fn cb_fn, void *cb_ctx); struct ftl_addr ftl_band_next_xfer_addr(struct ftl_band *band, struct ftl_addr addr, - size_t num_lbks); + size_t num_blocks); struct ftl_addr ftl_band_next_addr(struct ftl_band *band, struct ftl_addr addr, size_t offset); -size_t ftl_band_num_usable_lbks(const struct ftl_band *band); -size_t ftl_band_user_lbks_left(const struct ftl_band *band, size_t offset); -size_t ftl_band_user_lbks(const struct ftl_band *band); +size_t ftl_band_num_usable_blocks(const struct ftl_band *band); +size_t ftl_band_user_blocks_left(const struct ftl_band *band, size_t offset); +size_t ftl_band_user_blocks(const struct ftl_band *band); void ftl_band_set_addr(struct ftl_band *band, uint64_t lba, struct ftl_addr addr); struct ftl_band *ftl_band_from_addr(struct spdk_ftl_dev *dev, struct ftl_addr addr); @@ -247,12 +247,12 @@ ftl_band_state_changing(struct ftl_band *band) } static inline int -ftl_band_lbkoff_valid(struct ftl_band *band, size_t lbkoff) +ftl_band_block_offset_valid(struct ftl_band *band, size_t block_off) { struct ftl_lba_map *lba_map = &band->lba_map; pthread_spin_lock(&lba_map->lock); - if (spdk_bit_array_get(lba_map->vld, lbkoff)) { + if (spdk_bit_array_get(lba_map->vld, block_off)) { pthread_spin_unlock(&lba_map->lock); return 1; } diff --git a/lib/ftl/ftl_core.c b/lib/ftl/ftl_core.c index 9338d7827..fe9926f04 100644 --- a/lib/ftl/ftl_core.c +++ b/lib/ftl/ftl_core.c @@ -259,7 +259,7 @@ ftl_md_write_cb(struct ftl_io *io, void *arg, int status) if (band->state == FTL_BAND_STATE_CLOSED) { if (ftl_dev_has_nv_cache(dev)) { pthread_spin_lock(&nv_cache->lock); - nv_cache->num_available += ftl_band_user_lbks(band); + nv_cache->num_available += ftl_band_user_blocks(band); if (spdk_unlikely(nv_cache->num_available > nv_cache->num_data_blocks)) { nv_cache->num_available = nv_cache->num_data_blocks; @@ -289,7 +289,7 @@ static int ftl_read_next_physical_addr(struct ftl_io *io, struct ftl_addr *addr) { struct spdk_ftl_dev *dev = io->dev; - size_t lbk_cnt, max_lbks; + size_t num_blocks, max_blocks; assert(ftl_io_mode_physical(io)); assert(io->iov_pos < io->iov_cnt); @@ -305,15 +305,15 @@ ftl_read_next_physical_addr(struct ftl_io *io, struct ftl_addr *addr) /* 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 - (addr->offset % dev->xfer_size); - lbk_cnt = spdk_min(ftl_io_iovec_len_left(io), max_lbks); + max_blocks = dev->xfer_size - (addr->offset % dev->xfer_size); + num_blocks = spdk_min(ftl_io_iovec_len_left(io), max_blocks); assert(addr->offset / dev->xfer_size == - (addr->offset + lbk_cnt - 1) / dev->xfer_size); + (addr->offset + num_blocks - 1) / dev->xfer_size); } else { - lbk_cnt = ftl_io_iovec_len_left(io); + num_blocks = ftl_io_iovec_len_left(io); } - return lbk_cnt; + return num_blocks; } static int @@ -355,7 +355,7 @@ ftl_submit_erase(struct ftl_io *io) ioch = spdk_io_channel_get_ctx(ftl_get_io_channel(dev)); - for (i = 0; i < io->lbk_cnt; ++i) { + for (i = 0; i < io->num_blocks; ++i) { if (i != 0) { zone = ftl_band_next_zone(band, ftl_band_zone_from_addr(band, addr)); assert(zone->info.state == SPDK_BDEV_ZONE_STATE_CLOSED); @@ -583,7 +583,7 @@ ftl_wptr_advance(struct ftl_wptr *wptr, size_t xfer_size) } wptr->offset += xfer_size; - next_thld = (ftl_band_num_usable_lbks(band) * conf->band_thld) / 100; + next_thld = (ftl_band_num_usable_blocks(band) * conf->band_thld) / 100; if (ftl_band_full(band, wptr->offset)) { ftl_band_set_state(band, FTL_BAND_STATE_FULL); @@ -606,9 +606,9 @@ ftl_wptr_advance(struct ftl_wptr *wptr, size_t xfer_size) } static size_t -ftl_wptr_user_lbks_left(const struct ftl_wptr *wptr) +ftl_wptr_user_blocks_left(const struct ftl_wptr *wptr) { - return ftl_band_user_lbks_left(wptr->band, wptr->offset); + return ftl_band_user_blocks_left(wptr->band, wptr->offset); } static int @@ -783,7 +783,7 @@ ftl_wptr_pad_band(struct ftl_wptr *wptr) size_t size = ftl_rwb_num_pending(dev->rwb); size_t blocks_left, rwb_size, pad_size; - blocks_left = ftl_wptr_user_lbks_left(wptr); + blocks_left = ftl_wptr_user_blocks_left(wptr); assert(size <= blocks_left); assert(blocks_left % dev->xfer_size == 0); rwb_size = ftl_rwb_size(dev->rwb) - size; @@ -860,7 +860,7 @@ ftl_invalidate_addr_unlocked(struct spdk_ftl_dev *dev, struct ftl_addr addr) struct ftl_lba_map *lba_map = &band->lba_map; uint64_t offset; - offset = ftl_band_lbkoff_from_addr(band, addr); + offset = ftl_band_block_offset_from_addr(band, addr); /* The bit might be already cleared if two writes are scheduled to the */ /* same LBA at the same time */ @@ -982,17 +982,17 @@ ftl_submit_read(struct ftl_io *io) struct spdk_ftl_dev *dev = io->dev; struct ftl_io_channel *ioch; struct ftl_addr addr; - int rc = 0, lbk_cnt; + int rc = 0, num_blocks; ioch = spdk_io_channel_get_ctx(io->ioch); assert(LIST_EMPTY(&io->children)); - while (io->pos < io->lbk_cnt) { + while (io->pos < io->num_blocks) { if (ftl_io_mode_physical(io)) { - lbk_cnt = rc = ftl_read_next_physical_addr(io, &addr); + num_blocks = rc = ftl_read_next_physical_addr(io, &addr); } else { - lbk_cnt = rc = ftl_read_next_logical_addr(io, &addr); + num_blocks = rc = ftl_read_next_logical_addr(io, &addr); } /* We might need to retry the read from scratch (e.g. */ @@ -1011,13 +1011,13 @@ ftl_submit_read(struct ftl_io *io) continue; } - assert(lbk_cnt > 0); + assert(num_blocks > 0); - ftl_trace_submission(dev, io, addr, lbk_cnt); + ftl_trace_submission(dev, io, addr, num_blocks); rc = spdk_bdev_read_blocks(dev->base_bdev_desc, ioch->base_ioch, ftl_io_iovec_addr(io), addr.offset, - lbk_cnt, ftl_io_cmpl_cb, io); + num_blocks, ftl_io_cmpl_cb, io); if (spdk_unlikely(rc)) { if (rc == -ENOMEM) { ftl_add_to_retry_queue(io); @@ -1028,7 +1028,7 @@ ftl_submit_read(struct ftl_io *io) } ftl_io_inc_req(io); - ftl_io_advance(io, lbk_cnt); + ftl_io_advance(io, num_blocks); } /* If we didn't have to read anything from the device, */ @@ -1104,7 +1104,7 @@ ftl_nv_cache_wrap(void *ctx) } static uint64_t -ftl_reserve_nv_cache(struct ftl_nv_cache *nv_cache, size_t *num_lbks, unsigned int *phase) +ftl_reserve_nv_cache(struct ftl_nv_cache *nv_cache, size_t *num_blocks, unsigned int *phase) { struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(nv_cache->bdev_desc); struct spdk_ftl_dev *dev = SPDK_CONTAINEROF(nv_cache, struct spdk_ftl_dev, nv_cache); @@ -1117,18 +1117,18 @@ ftl_reserve_nv_cache(struct ftl_nv_cache *nv_cache, size_t *num_lbks, unsigned i goto out; } - num_available = spdk_min(nv_cache->num_available, *num_lbks); + num_available = spdk_min(nv_cache->num_available, *num_blocks); num_available = spdk_min(num_available, dev->conf.nv_cache.max_request_cnt); if (spdk_unlikely(nv_cache->current_addr + num_available > cache_size)) { - *num_lbks = cache_size - nv_cache->current_addr; + *num_blocks = cache_size - nv_cache->current_addr; } else { - *num_lbks = num_available; + *num_blocks = num_available; } cache_addr = nv_cache->current_addr; - nv_cache->current_addr += *num_lbks; - nv_cache->num_available -= *num_lbks; + nv_cache->current_addr += *num_blocks; + nv_cache->num_available -= *num_blocks; *phase = nv_cache->phase; if (nv_cache->current_addr == spdk_bdev_get_num_blocks(bdev)) { @@ -1143,13 +1143,13 @@ out: } static struct ftl_io * -ftl_alloc_io_nv_cache(struct ftl_io *parent, size_t num_lbks) +ftl_alloc_io_nv_cache(struct ftl_io *parent, size_t num_blocks) { struct ftl_io_init_opts opts = { .dev = parent->dev, .parent = parent, .data = ftl_io_iovec_addr(parent), - .lbk_cnt = num_lbks, + .num_blocks = num_blocks, .flags = parent->flags | FTL_IO_CACHE, }; @@ -1191,20 +1191,20 @@ ftl_submit_nv_cache(void *ctx) rc = spdk_bdev_write_blocks_with_md(nv_cache->bdev_desc, ioch->cache_ioch, ftl_io_iovec_addr(io), io->md, io->addr.offset, - io->lbk_cnt, ftl_nv_cache_submit_cb, io); + io->num_blocks, 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->addr.offset, io->lbk_cnt); + spdk_strerror(-rc), io->addr.offset, io->num_blocks); spdk_mempool_put(nv_cache->md_pool, io->md); io->status = -EIO; ftl_io_complete(io); return; } - ftl_io_advance(io, io->lbk_cnt); + ftl_io_advance(io, io->num_blocks); ftl_io_inc_req(io); } @@ -1213,13 +1213,13 @@ ftl_nv_cache_fill_md(struct ftl_io *io, unsigned int phase) { struct spdk_bdev *bdev; struct ftl_nv_cache *nv_cache = &io->dev->nv_cache; - uint64_t lbk_off, lba; + uint64_t block_off, lba; void *md_buf = io->md; bdev = spdk_bdev_desc_get_bdev(nv_cache->bdev_desc); - for (lbk_off = 0; lbk_off < io->lbk_cnt; ++lbk_off) { - lba = ftl_nv_cache_pack_lba(ftl_io_get_lba(io, lbk_off), phase); + for (block_off = 0; block_off < io->num_blocks; ++block_off) { + lba = ftl_nv_cache_pack_lba(ftl_io_get_lba(io, block_off), phase); memcpy(md_buf, &lba, sizeof(lba)); md_buf += spdk_bdev_get_md_size(bdev); } @@ -1232,14 +1232,14 @@ _ftl_write_nv_cache(void *ctx) struct spdk_ftl_dev *dev = io->dev; struct spdk_thread *thread; unsigned int phase; - uint64_t num_lbks; + uint64_t num_blocks; thread = spdk_io_channel_get_thread(io->ioch); - while (io->pos < io->lbk_cnt) { - num_lbks = ftl_io_iovec_len_left(io); + while (io->pos < io->num_blocks) { + num_blocks = ftl_io_iovec_len_left(io); - child = ftl_alloc_io_nv_cache(io, num_lbks); + child = ftl_alloc_io_nv_cache(io, num_blocks); if (spdk_unlikely(!child)) { spdk_thread_send_msg(thread, _ftl_write_nv_cache, io); return; @@ -1253,7 +1253,7 @@ _ftl_write_nv_cache(void *ctx) } /* Reserve area on the write buffer cache */ - child->addr.offset = ftl_reserve_nv_cache(&dev->nv_cache, &num_lbks, &phase); + child->addr.offset = ftl_reserve_nv_cache(&dev->nv_cache, &num_blocks, &phase); if (child->addr.offset == FTL_LBA_INVALID) { spdk_mempool_put(dev->nv_cache.md_pool, child->md); ftl_io_free(child); @@ -1262,8 +1262,8 @@ _ftl_write_nv_cache(void *ctx) } /* Shrink the IO if there isn't enough room in the cache to fill the whole iovec */ - if (spdk_unlikely(num_lbks != ftl_io_iovec_len_left(io))) { - ftl_io_shrink_iovec(child, num_lbks); + if (spdk_unlikely(num_blocks != ftl_io_iovec_len_left(io))) { + ftl_io_shrink_iovec(child, num_blocks); } ftl_nv_cache_fill_md(child, phase); @@ -1364,13 +1364,13 @@ ftl_write_cb(struct ftl_io *io, void *arg, int status) return; } - assert(io->lbk_cnt == dev->xfer_size); + assert(io->num_blocks == dev->xfer_size); assert(!(io->flags & FTL_IO_MD)); ftl_rwb_foreach(entry, batch) { band = entry->band; if (!(entry->flags & FTL_IO_PAD)) { - /* Verify that the LBA is set for user lbks */ + /* Verify that the LBA is set for user blocks */ assert(entry->lba != FTL_LBA_INVALID); } @@ -1493,7 +1493,7 @@ ftl_io_init_child_write(struct ftl_io *parent, struct ftl_addr addr, .size = sizeof(struct ftl_io), .flags = 0, .type = parent->type, - .lbk_cnt = dev->xfer_size, + .num_blocks = dev->xfer_size, .cb_fn = cb, .data = data, .md = md, @@ -1519,7 +1519,7 @@ ftl_io_child_write_cb(struct ftl_io *io, void *ctx, int status) wptr = ftl_wptr_from_band(io->band); zone->busy = false; - zone->info.write_pointer += io->lbk_cnt; + zone->info.write_pointer += io->num_blocks; /* If some other write on the same band failed the write pointer would already be freed */ if (spdk_likely(wptr)) { @@ -1528,7 +1528,7 @@ ftl_io_child_write_cb(struct ftl_io *io, void *ctx, int status) } static int -ftl_submit_child_write(struct ftl_wptr *wptr, struct ftl_io *io, int lbk_cnt) +ftl_submit_child_write(struct ftl_wptr *wptr, struct ftl_io *io, int num_blocks) { struct spdk_ftl_dev *dev = io->dev; struct ftl_io_channel *ioch; @@ -1559,12 +1559,12 @@ ftl_submit_child_write(struct ftl_wptr *wptr, struct ftl_io *io, int lbk_cnt) rc = spdk_bdev_zone_append(dev->base_bdev_desc, ioch->base_ioch, ftl_io_iovec_addr(child), ftl_addr_get_zone_slba(dev, addr), - lbk_cnt, ftl_io_cmpl_cb, child); + num_blocks, ftl_io_cmpl_cb, child); } else { rc = spdk_bdev_write_blocks(dev->base_bdev_desc, ioch->base_ioch, ftl_io_iovec_addr(child), addr.offset, - lbk_cnt, ftl_io_cmpl_cb, child); + num_blocks, ftl_io_cmpl_cb, child); } if (rc) { @@ -1577,7 +1577,7 @@ ftl_submit_child_write(struct ftl_wptr *wptr, struct ftl_io *io, int lbk_cnt) } ftl_io_inc_req(child); - ftl_io_advance(child, lbk_cnt); + ftl_io_advance(child, num_blocks); return 0; } @@ -1588,7 +1588,7 @@ ftl_submit_write(struct ftl_wptr *wptr, struct ftl_io *io) struct spdk_ftl_dev *dev = io->dev; int rc = 0; - assert(io->lbk_cnt % dev->xfer_size == 0); + assert(io->num_blocks % dev->xfer_size == 0); /* Only one child write make sense in case of user write */ assert((io->flags & FTL_IO_MD) || io->iov_cnt == 1); @@ -1772,7 +1772,7 @@ ftl_rwb_fill(struct ftl_io *io) struct ftl_addr addr = { .cached = 1 }; int flags = ftl_rwb_flags_from_io(io); - while (io->pos < io->lbk_cnt) { + while (io->pos < io->num_blocks) { if (ftl_io_current_lba(io) == FTL_LBA_INVALID) { ftl_io_advance(io, 1); continue; @@ -1834,8 +1834,8 @@ ftl_band_calc_merit(struct ftl_band *band, size_t *threshold_valid) size_t usable, valid, invalid; double vld_ratio; - /* If the band doesn't have any usable lbks it's of no use */ - usable = ftl_band_num_usable_lbks(band); + /* If the band doesn't have any usable blocks it's of no use */ + usable = ftl_band_num_usable_blocks(band); if (usable == 0) { return 0.0; } @@ -1859,7 +1859,7 @@ ftl_band_needs_defrag(struct ftl_band *band, struct spdk_ftl_dev *dev) return true; } - thld_vld = (ftl_band_num_usable_lbks(band) * conf->invalid_thld) / 100; + thld_vld = (ftl_band_num_usable_blocks(band) * conf->invalid_thld) / 100; return band->merit > ftl_band_calc_merit(band, &thld_vld); } @@ -1912,8 +1912,8 @@ void spdk_ftl_dev_get_attrs(const struct spdk_ftl_dev *dev, struct spdk_ftl_attrs *attrs) { attrs->uuid = dev->uuid; - attrs->lbk_cnt = dev->num_lbas; - attrs->lbk_size = FTL_BLOCK_SIZE; + attrs->num_blocks = dev->num_lbas; + attrs->block_size = FTL_BLOCK_SIZE; attrs->cache_bdev_desc = dev->nv_cache.bdev_desc; attrs->num_zones = ftl_get_num_zones(dev); attrs->zone_size = ftl_get_num_blocks_in_zone(dev); @@ -1988,7 +1988,7 @@ spdk_ftl_write(struct spdk_ftl_dev *dev, struct spdk_io_channel *ch, uint64_t lb return -EINVAL; } - if (lba_cnt != ftl_iovec_num_lbks(iov, iov_cnt)) { + if (lba_cnt != ftl_iovec_num_blocks(iov, iov_cnt)) { return -EINVAL; } @@ -2052,7 +2052,7 @@ spdk_ftl_read(struct spdk_ftl_dev *dev, struct spdk_io_channel *ch, uint64_t lba return -EINVAL; } - if (lba_cnt != ftl_iovec_num_lbks(iov, iov_cnt)) { + if (lba_cnt != ftl_iovec_num_blocks(iov, iov_cnt)) { return -EINVAL; } diff --git a/lib/ftl/ftl_core.h b/lib/ftl/ftl_core.h index ba836e88e..b6bbb0f93 100644 --- a/lib/ftl/ftl_core.h +++ b/lib/ftl/ftl_core.h @@ -259,11 +259,11 @@ int ftl_invalidate_addr(struct spdk_ftl_dev *dev, struct ftl_addr addr); int ftl_task_core(void *ctx); int ftl_task_read(void *ctx); void ftl_process_anm_event(struct ftl_anm_event *event); -size_t ftl_tail_md_num_lbks(const struct spdk_ftl_dev *dev); -size_t ftl_tail_md_hdr_num_lbks(void); -size_t ftl_vld_map_num_lbks(const struct spdk_ftl_dev *dev); -size_t ftl_lba_map_num_lbks(const struct spdk_ftl_dev *dev); -size_t ftl_head_md_num_lbks(const struct spdk_ftl_dev *dev); +size_t ftl_tail_md_num_blocks(const struct spdk_ftl_dev *dev); +size_t ftl_tail_md_hdr_num_blocks(void); +size_t ftl_vld_map_num_blocks(const struct spdk_ftl_dev *dev); +size_t ftl_lba_map_num_blocks(const struct spdk_ftl_dev *dev); +size_t ftl_head_md_num_blocks(const struct spdk_ftl_dev *dev); int ftl_restore_md(struct spdk_ftl_dev *dev, ftl_restore_fn cb); int ftl_restore_device(struct ftl_restore *restore, ftl_restore_fn cb); void ftl_restore_nv_cache(struct ftl_restore *restore, ftl_restore_fn cb); diff --git a/lib/ftl/ftl_debug.c b/lib/ftl/ftl_debug.c index 110f40789..9fbb43810 100644 --- a/lib/ftl/ftl_debug.c +++ b/lib/ftl/ftl_debug.c @@ -72,7 +72,7 @@ ftl_band_validate_md(struct ftl_band *band) continue; } - addr_md = ftl_band_addr_from_lbkoff(band, i); + addr_md = ftl_band_addr_from_block_offset(band, i); addr_l2p = ftl_l2p_get(dev, lba_map->map[i]); if (addr_l2p.cached) { @@ -116,7 +116,7 @@ ftl_dev_dump_bands(struct spdk_ftl_dev *dev) ftl_debug(" Band %3zu: %8zu / %zu \tnum_zones: %zu \twr_cnt: %"PRIu64"\tmerit:" "%10.3f\tstate: %s\n", i + 1, dev->bands[i].lba_map.num_vld, - ftl_band_user_lbks(&dev->bands[i]), + ftl_band_user_blocks(&dev->bands[i]), dev->bands[i].num_zones, dev->bands[i].wr_cnt, dev->bands[i].merit, diff --git a/lib/ftl/ftl_init.c b/lib/ftl/ftl_init.c index 9829bcfdc..9ebd8c0b7 100644 --- a/lib/ftl/ftl_init.c +++ b/lib/ftl/ftl_init.c @@ -75,9 +75,9 @@ static const struct spdk_ftl_conf g_default_conf = { /* 40 free bands / 100 % host writes - defrag starts running */ [SPDK_FTL_LIMIT_START] = { .thld = 40, .limit = 100 }, }, - /* 10 percent valid lbks */ + /* 10 percent valid blocks */ .invalid_thld = 10, - /* 20% spare lbks */ + /* 20% spare blocks */ .lba_rsvd = 20, /* 6M write buffer */ .rwb_size = 6 * 1024 * 1024, @@ -632,7 +632,7 @@ ftl_setup_initial_state(struct spdk_ftl_dev *dev) dev->num_lbas = 0; for (i = 0; i < ftl_get_num_bands(dev); ++i) { - dev->num_lbas += ftl_band_num_usable_lbks(&dev->bands[i]); + dev->num_lbas += ftl_band_num_usable_blocks(&dev->bands[i]); } dev->num_lbas = (dev->num_lbas * (100 - conf->lba_rsvd)) / 100; @@ -954,7 +954,7 @@ static int ftl_dev_init_base_bdev(struct spdk_ftl_dev *dev) { uint32_t block_size; - uint64_t block_cnt; + uint64_t num_blocks; struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(dev->base_bdev_desc); if (!spdk_bdev_is_zoned(bdev)) { @@ -972,8 +972,8 @@ ftl_dev_init_base_bdev(struct spdk_ftl_dev *dev) return -1; } - block_cnt = spdk_bdev_get_num_blocks(bdev); - if (block_cnt % ftl_get_num_punits(dev)) { + num_blocks = spdk_bdev_get_num_blocks(bdev); + if (num_blocks % ftl_get_num_punits(dev)) { SPDK_ERRLOG("Unsupported geometry. Base bdev block count must be multiple " "of optimal number of zones.\n"); return -1; @@ -986,8 +986,8 @@ ftl_dev_init_base_bdev(struct spdk_ftl_dev *dev) return -1; } - dev->num_bands = block_cnt / (ftl_get_num_punits(dev) * ftl_get_num_blocks_in_zone(dev)); - dev->addr_len = spdk_u64log2(block_cnt) + 1; + dev->num_bands = num_blocks / (ftl_get_num_punits(dev) * ftl_get_num_blocks_in_zone(dev)); + dev->addr_len = spdk_u64log2(num_blocks) + 1; return 0; } diff --git a/lib/ftl/ftl_io.c b/lib/ftl/ftl_io.c index b0ad533b2..fee522a15 100644 --- a/lib/ftl/ftl_io.c +++ b/lib/ftl/ftl_io.c @@ -83,7 +83,7 @@ ftl_io_iovec(struct ftl_io *io) uint64_t ftl_io_get_lba(const struct ftl_io *io, size_t offset) { - assert(offset < io->lbk_cnt); + assert(offset < io->num_blocks); if (io->flags & FTL_IO_VECTOR_LBA) { return io->lba.vector[offset]; @@ -99,45 +99,45 @@ ftl_io_current_lba(const struct ftl_io *io) } void -ftl_io_advance(struct ftl_io *io, size_t lbk_cnt) +ftl_io_advance(struct ftl_io *io, size_t num_blocks) { struct iovec *iov = ftl_io_iovec(io); - size_t iov_lbks, lbk_left = lbk_cnt; + size_t iov_blocks, block_left = num_blocks; - io->pos += lbk_cnt; + io->pos += num_blocks; if (io->iov_cnt != 0) { - while (lbk_left > 0) { + while (block_left > 0) { assert(io->iov_pos < io->iov_cnt); - iov_lbks = iov[io->iov_pos].iov_len / FTL_BLOCK_SIZE; + iov_blocks = iov[io->iov_pos].iov_len / FTL_BLOCK_SIZE; - if (io->iov_off + lbk_left < iov_lbks) { - io->iov_off += lbk_left; + if (io->iov_off + block_left < iov_blocks) { + io->iov_off += block_left; break; } - assert(iov_lbks > io->iov_off); - lbk_left -= (iov_lbks - io->iov_off); + assert(iov_blocks > io->iov_off); + block_left -= (iov_blocks - io->iov_off); io->iov_off = 0; io->iov_pos++; } } if (io->parent) { - ftl_io_advance(io->parent, lbk_cnt); + ftl_io_advance(io->parent, num_blocks); } } size_t -ftl_iovec_num_lbks(struct iovec *iov, size_t iov_cnt) +ftl_iovec_num_blocks(struct iovec *iov, size_t iov_cnt) { - size_t lbks = 0, i = 0; + size_t num_blocks = 0, i = 0; for (; i < iov_cnt; ++i) { - lbks += iov[i].iov_len / FTL_BLOCK_SIZE; + num_blocks += iov[i].iov_len / FTL_BLOCK_SIZE; } - return lbks; + return num_blocks; } void * @@ -158,19 +158,19 @@ ftl_io_iovec_len_left(struct ftl_io *io) } static void -_ftl_io_init_iovec(struct ftl_io *io, const struct iovec *iov, size_t iov_cnt, size_t lbk_cnt) +_ftl_io_init_iovec(struct ftl_io *io, const struct iovec *iov, size_t iov_cnt, size_t num_blocks) { size_t iov_off; io->iov_pos = 0; io->iov_cnt = iov_cnt; - io->lbk_cnt = lbk_cnt; + io->num_blocks = num_blocks; memcpy(io->iov, iov, iov_cnt * sizeof(*iov)); - if (lbk_cnt == 0) { + if (num_blocks == 0) { for (iov_off = 0; iov_off < iov_cnt; ++iov_off) { - io->lbk_cnt += iov[iov_off].iov_len / FTL_BLOCK_SIZE; + io->num_blocks += iov[iov_off].iov_len / FTL_BLOCK_SIZE; } } } @@ -190,24 +190,24 @@ ftl_io_add_child(struct ftl_io *io, const struct iovec *iov, size_t iov_cnt) _ftl_io_init_iovec(child, iov, iov_cnt, 0); if (io->flags & FTL_IO_VECTOR_LBA) { - child->lba.vector = io->lba.vector + io->lbk_cnt; + child->lba.vector = io->lba.vector + io->num_blocks; } else { - child->lba.single = io->lba.single + io->lbk_cnt; + child->lba.single = io->lba.single + io->num_blocks; } - io->lbk_cnt += child->lbk_cnt; + io->num_blocks += child->num_blocks; return 0; } static int -ftl_io_init_iovec(struct ftl_io *io, const struct iovec *iov, size_t iov_cnt, size_t lbk_cnt) +ftl_io_init_iovec(struct ftl_io *io, const struct iovec *iov, size_t iov_cnt, size_t num_blocks) { struct ftl_io *child; size_t iov_off = 0, iov_left; int rc; if (spdk_likely(iov_cnt <= FTL_IO_MAX_IOVEC)) { - _ftl_io_init_iovec(io, iov, iov_cnt, lbk_cnt); + _ftl_io_init_iovec(io, iov, iov_cnt, num_blocks); return 0; } @@ -228,30 +228,30 @@ ftl_io_init_iovec(struct ftl_io *io, const struct iovec *iov, size_t iov_cnt, si iov_off += iov_left; } - assert(io->lbk_cnt == lbk_cnt); + assert(io->num_blocks == num_blocks); return 0; } void -ftl_io_shrink_iovec(struct ftl_io *io, size_t lbk_cnt) +ftl_io_shrink_iovec(struct ftl_io *io, size_t num_blocks) { - size_t iov_off = 0, lbk_off = 0; + size_t iov_off = 0, block_off = 0; - assert(io->lbk_cnt >= lbk_cnt); + assert(io->num_blocks >= num_blocks); assert(io->pos == 0 && io->iov_pos == 0 && io->iov_off == 0); for (; iov_off < io->iov_cnt; ++iov_off) { size_t num_iov = io->iov[iov_off].iov_len / FTL_BLOCK_SIZE; - size_t num_left = lbk_cnt - lbk_off; + size_t num_left = num_blocks - block_off; if (num_iov >= num_left) { io->iov[iov_off].iov_len = num_left * FTL_BLOCK_SIZE; io->iov_cnt = iov_off + 1; - io->lbk_cnt = lbk_cnt; + io->num_blocks = num_blocks; break; } - lbk_off += num_iov; + block_off += num_iov; } } @@ -277,7 +277,7 @@ ftl_io_init_internal(const struct ftl_io_init_opts *opts) struct spdk_ftl_dev *dev = opts->dev; struct iovec iov = { .iov_base = opts->data, - .iov_len = opts->lbk_cnt * FTL_BLOCK_SIZE + .iov_len = opts->num_blocks * FTL_BLOCK_SIZE }; if (!io) { @@ -307,7 +307,7 @@ ftl_io_init_internal(const struct ftl_io_init_opts *opts) } } - if (ftl_io_init_iovec(io, &iov, 1, opts->lbk_cnt)) { + if (ftl_io_init_iovec(io, &iov, 1, opts->num_blocks)) { if (!opts->io) { ftl_io_free(io); } @@ -315,7 +315,7 @@ ftl_io_init_internal(const struct ftl_io_init_opts *opts) } if (opts->flags & FTL_IO_VECTOR_LBA) { - io->lba.vector = calloc(io->lbk_cnt, sizeof(uint64_t)); + io->lba.vector = calloc(io->num_blocks, sizeof(uint64_t)); if (!io->lba.vector) { ftl_io_free(io); return NULL; @@ -338,7 +338,7 @@ ftl_io_rwb_init(struct spdk_ftl_dev *dev, struct ftl_addr addr, struct ftl_band .size = sizeof(struct ftl_io), .flags = 0, .type = FTL_IO_WRITE, - .lbk_cnt = dev->xfer_size, + .num_blocks = dev->xfer_size, .cb_fn = cb, .data = ftl_rwb_batch_get_data(batch), .md = ftl_rwb_batch_get_md(batch), @@ -355,7 +355,7 @@ ftl_io_rwb_init(struct spdk_ftl_dev *dev, struct ftl_addr addr, struct ftl_band } struct ftl_io * -ftl_io_erase_init(struct ftl_band *band, size_t lbk_cnt, ftl_io_fn cb) +ftl_io_erase_init(struct ftl_band *band, size_t num_blocks, ftl_io_fn cb) { struct ftl_io *io; struct ftl_io_init_opts opts = { @@ -366,7 +366,7 @@ ftl_io_erase_init(struct ftl_band *band, size_t lbk_cnt, ftl_io_fn cb) .size = sizeof(struct ftl_io), .flags = FTL_IO_PHYSICAL_MODE, .type = FTL_IO_ERASE, - .lbk_cnt = 1, + .num_blocks = 1, .cb_fn = cb, .data = NULL, .md = NULL, @@ -377,7 +377,7 @@ ftl_io_erase_init(struct ftl_band *band, size_t lbk_cnt, ftl_io_fn cb) return NULL; } - io->lbk_cnt = lbk_cnt; + io->num_blocks = num_blocks; return io; } @@ -389,7 +389,7 @@ _ftl_user_cb(struct ftl_io *io, void *arg, int status) } struct ftl_io * -ftl_io_user_init(struct spdk_io_channel *_ioch, uint64_t lba, size_t lbk_cnt, struct iovec *iov, +ftl_io_user_init(struct spdk_io_channel *_ioch, uint64_t lba, size_t num_blocks, struct iovec *iov, size_t iov_cnt, spdk_ftl_fn cb_fn, void *cb_ctx, int type) { struct ftl_io_channel *ioch = spdk_io_channel_get_ctx(_ioch); @@ -405,7 +405,7 @@ ftl_io_user_init(struct spdk_io_channel *_ioch, uint64_t lba, size_t lbk_cnt, st io->lba.single = lba; io->user_fn = cb_fn; - if (ftl_io_init_iovec(io, iov, iov_cnt, lbk_cnt)) { + if (ftl_io_init_iovec(io, iov, iov_cnt, num_blocks)) { ftl_io_free(io); return NULL; } @@ -497,7 +497,7 @@ ftl_io_alloc_child(struct ftl_io *parent) void ftl_io_fail(struct ftl_io *io, int status) { io->status = status; - ftl_io_advance(io, io->lbk_cnt - io->pos); + ftl_io_advance(io, io->num_blocks - io->pos); } void * diff --git a/lib/ftl/ftl_io.h b/lib/ftl/ftl_io.h index cc9e6bce9..e7f7943a7 100644 --- a/lib/ftl/ftl_io.h +++ b/lib/ftl/ftl_io.h @@ -108,7 +108,7 @@ struct ftl_io_init_opts { struct ftl_band *band; /* Number of logical blocks */ - size_t lbk_cnt; + size_t num_blocks; /* Data */ void *data; @@ -155,11 +155,11 @@ struct ftl_io { /* First block address */ struct ftl_addr addr; - /* Number of processed lbks */ + /* Number of processed blocks */ size_t pos; - /* Number of lbks */ - size_t lbk_cnt; + /* Number of blocks */ + size_t num_blocks; #define FTL_IO_MAX_IOVEC 64 struct iovec iov[FTL_IO_MAX_IOVEC]; @@ -173,7 +173,7 @@ struct ftl_io { /* Position within the iovec */ size_t iov_pos; - /* Offset within the iovec (in lbks) */ + /* Offset within the iovec (in blocks) */ size_t iov_off; /* RWB entry (valid only for RWB-based IO) */ @@ -252,7 +252,7 @@ static inline bool ftl_io_done(const struct ftl_io *io) { return io->req_cnt == 0 && - io->pos == io->lbk_cnt && + io->pos == io->num_blocks && !(io->flags & FTL_IO_RETRY); } @@ -269,20 +269,20 @@ void ftl_io_dec_req(struct ftl_io *io); struct iovec *ftl_io_iovec(struct ftl_io *io); uint64_t ftl_io_current_lba(const struct ftl_io *io); uint64_t ftl_io_get_lba(const struct ftl_io *io, size_t offset); -void ftl_io_advance(struct ftl_io *io, size_t lbk_cnt); -size_t ftl_iovec_num_lbks(struct iovec *iov, size_t iov_cnt); +void ftl_io_advance(struct ftl_io *io, size_t num_blocks); +size_t ftl_iovec_num_blocks(struct iovec *iov, size_t iov_cnt); void *ftl_io_iovec_addr(struct ftl_io *io); size_t ftl_io_iovec_len_left(struct ftl_io *io); struct ftl_io *ftl_io_rwb_init(struct spdk_ftl_dev *dev, struct ftl_addr addr, struct ftl_band *band, struct ftl_rwb_batch *entry, ftl_io_fn cb); -struct ftl_io *ftl_io_erase_init(struct ftl_band *band, size_t lbk_cnt, ftl_io_fn cb); -struct ftl_io *ftl_io_user_init(struct spdk_io_channel *ioch, uint64_t lba, size_t lbk_cnt, +struct ftl_io *ftl_io_erase_init(struct ftl_band *band, size_t num_blocks, ftl_io_fn cb); +struct ftl_io *ftl_io_user_init(struct spdk_io_channel *ioch, uint64_t lba, size_t num_blocks, struct iovec *iov, size_t iov_cnt, spdk_ftl_fn cb_fn, void *cb_arg, int type); void *ftl_io_get_md(const struct ftl_io *io); void ftl_io_complete(struct ftl_io *io); -void ftl_io_shrink_iovec(struct ftl_io *io, size_t lbk_cnt); +void ftl_io_shrink_iovec(struct ftl_io *io, size_t num_blocks); void ftl_io_process_error(struct ftl_io *io, const struct spdk_nvme_cpl *status); void ftl_io_reset(struct ftl_io *io); void ftl_io_call_foreach_child(struct ftl_io *io, int (*callback)(struct ftl_io *)); diff --git a/lib/ftl/ftl_reloc.c b/lib/ftl/ftl_reloc.c index 496910a47..33f05e9f4 100644 --- a/lib/ftl/ftl_reloc.c +++ b/lib/ftl/ftl_reloc.c @@ -68,7 +68,7 @@ struct ftl_reloc_move { struct ftl_addr addr; /* Number of logical blocks */ - size_t lbk_cnt; + size_t num_blocks; /* Data buffer */ void *data; @@ -87,7 +87,7 @@ struct ftl_band_reloc { struct ftl_band *band; /* Number of logical blocks to be relocated */ - size_t num_lbks; + size_t num_blocks; /* Bitmap of logical blocks to be relocated */ struct spdk_bit_array *reloc_map; @@ -170,21 +170,21 @@ ftl_reloc_iter_zone_offset(struct ftl_band_reloc *breloc) static size_t ftl_reloc_iter_zone_done(struct ftl_band_reloc *breloc) { - size_t num_lbks = ftl_get_num_blocks_in_zone(breloc->parent->dev); + size_t num_blocks = ftl_get_num_blocks_in_zone(breloc->parent->dev); - return ftl_reloc_iter_zone_offset(breloc) == num_lbks; + return ftl_reloc_iter_zone_offset(breloc) == num_blocks; } static void -ftl_reloc_clr_lbk(struct ftl_band_reloc *breloc, size_t lbkoff) +ftl_reloc_clr_block(struct ftl_band_reloc *breloc, size_t block_off) { - if (!spdk_bit_array_get(breloc->reloc_map, lbkoff)) { + if (!spdk_bit_array_get(breloc->reloc_map, block_off)) { return; } - spdk_bit_array_clear(breloc->reloc_map, lbkoff); - assert(breloc->num_lbks); - breloc->num_lbks--; + spdk_bit_array_clear(breloc->reloc_map, block_off); + assert(breloc->num_blocks); + breloc->num_blocks--; } static void @@ -205,8 +205,8 @@ ftl_reloc_read_lba_map(struct ftl_band_reloc *breloc, struct ftl_reloc_move *mov struct ftl_band *band = breloc->band; breloc->num_outstanding++; - return ftl_band_read_lba_map(band, ftl_band_lbkoff_from_addr(band, move->addr), - move->lbk_cnt, ftl_reloc_read_lba_map_cb, move); + return ftl_band_read_lba_map(band, ftl_band_block_offset_from_addr(band, move->addr), + move->num_blocks, ftl_reloc_read_lba_map_cb, move); } static void @@ -264,10 +264,10 @@ ftl_reloc_write_cb(struct ftl_io *io, void *arg, int status) return; } - for (i = 0; i < move->lbk_cnt; ++i) { + for (i = 0; i < move->num_blocks; ++i) { addr.offset = move->addr.offset + i; - size_t lbkoff = ftl_band_lbkoff_from_addr(breloc->band, addr); - ftl_reloc_clr_lbk(breloc, lbkoff); + size_t block_off = ftl_band_block_offset_from_addr(breloc->band, addr); + ftl_reloc_clr_block(breloc, block_off); } ftl_reloc_free_move(breloc, move); @@ -304,7 +304,7 @@ ftl_reloc_iter_reset(struct ftl_band_reloc *breloc) } static size_t -ftl_reloc_iter_lbkoff(struct ftl_band_reloc *breloc) +ftl_reloc_iter_block_offset(struct ftl_band_reloc *breloc) { size_t zone_offset = breloc->iter.zone_current * ftl_get_num_blocks_in_zone(breloc->parent->dev); @@ -320,21 +320,21 @@ ftl_reloc_iter_next_zone(struct ftl_band_reloc *breloc) } static int -ftl_reloc_lbk_valid(struct ftl_band_reloc *breloc, size_t lbkoff) +ftl_reloc_block_valid(struct ftl_band_reloc *breloc, size_t block_off) { - struct ftl_addr addr = ftl_band_addr_from_lbkoff(breloc->band, lbkoff); + struct ftl_addr addr = ftl_band_addr_from_block_offset(breloc->band, block_off); return ftl_addr_is_written(breloc->band, addr) && - spdk_bit_array_get(breloc->reloc_map, lbkoff) && - ftl_band_lbkoff_valid(breloc->band, lbkoff); + spdk_bit_array_get(breloc->reloc_map, block_off) && + ftl_band_block_offset_valid(breloc->band, block_off); } static int -ftl_reloc_iter_next(struct ftl_band_reloc *breloc, size_t *lbkoff) +ftl_reloc_iter_next(struct ftl_band_reloc *breloc, size_t *block_off) { size_t zone = breloc->iter.zone_current; - *lbkoff = ftl_reloc_iter_lbkoff(breloc); + *block_off = ftl_reloc_iter_block_offset(breloc); if (ftl_reloc_iter_zone_done(breloc)) { return 0; @@ -342,8 +342,8 @@ ftl_reloc_iter_next(struct ftl_band_reloc *breloc, size_t *lbkoff) breloc->iter.zone_offset[zone]++; - if (!ftl_reloc_lbk_valid(breloc, *lbkoff)) { - ftl_reloc_clr_lbk(breloc, *lbkoff); + if (!ftl_reloc_block_valid(breloc, *block_off)) { + ftl_reloc_clr_block(breloc, *block_off); return 0; } @@ -351,12 +351,12 @@ ftl_reloc_iter_next(struct ftl_band_reloc *breloc, size_t *lbkoff) } static int -ftl_reloc_first_valid_lbk(struct ftl_band_reloc *breloc, size_t *lbkoff) +ftl_reloc_first_valid_block(struct ftl_band_reloc *breloc, size_t *block_off) { - size_t i, num_lbks = ftl_get_num_blocks_in_zone(breloc->parent->dev); + size_t i, num_blocks = ftl_get_num_blocks_in_zone(breloc->parent->dev); - for (i = ftl_reloc_iter_zone_offset(breloc); i < num_lbks; ++i) { - if (ftl_reloc_iter_next(breloc, lbkoff)) { + for (i = ftl_reloc_iter_zone_offset(breloc); i < num_blocks; ++i) { + if (ftl_reloc_iter_next(breloc, block_off)) { return 1; } } @@ -369,10 +369,10 @@ ftl_reloc_iter_done(struct ftl_band_reloc *breloc) { size_t i; size_t num_zones = ftl_get_num_punits(breloc->band->dev); - size_t num_lbks = ftl_get_num_blocks_in_zone(breloc->parent->dev); + size_t num_blocks = ftl_get_num_blocks_in_zone(breloc->parent->dev); for (i = 0; i < num_zones; ++i) { - if (breloc->iter.zone_offset[i] != num_lbks) { + if (breloc->iter.zone_offset[i] != num_blocks) { return 0; } } @@ -381,49 +381,49 @@ ftl_reloc_iter_done(struct ftl_band_reloc *breloc) } static size_t -ftl_reloc_find_valid_lbks(struct ftl_band_reloc *breloc, - size_t num_lbk, struct ftl_addr *addr) +ftl_reloc_find_valid_blocks(struct ftl_band_reloc *breloc, + size_t _num_blocks, struct ftl_addr *addr) { - size_t lbkoff, lbk_cnt = 0; + size_t block_off, num_blocks = 0; - if (!ftl_reloc_first_valid_lbk(breloc, &lbkoff)) { + if (!ftl_reloc_first_valid_block(breloc, &block_off)) { return 0; } - *addr = ftl_band_addr_from_lbkoff(breloc->band, lbkoff); + *addr = ftl_band_addr_from_block_offset(breloc->band, block_off); - for (lbk_cnt = 1; lbk_cnt < num_lbk; lbk_cnt++) { - if (!ftl_reloc_iter_next(breloc, &lbkoff)) { + for (num_blocks = 1; num_blocks < _num_blocks; num_blocks++) { + if (!ftl_reloc_iter_next(breloc, &block_off)) { break; } } - return lbk_cnt; + return num_blocks; } static size_t -ftl_reloc_next_lbks(struct ftl_band_reloc *breloc, struct ftl_addr *addr) +ftl_reloc_next_blocks(struct ftl_band_reloc *breloc, struct ftl_addr *addr) { - size_t i, lbk_cnt = 0; + size_t i, num_blocks = 0; struct spdk_ftl_dev *dev = breloc->parent->dev; for (i = 0; i < ftl_get_num_punits(dev); ++i) { - lbk_cnt = ftl_reloc_find_valid_lbks(breloc, breloc->parent->xfer_size, addr); + num_blocks = ftl_reloc_find_valid_blocks(breloc, breloc->parent->xfer_size, addr); ftl_reloc_iter_next_zone(breloc); - if (lbk_cnt || ftl_reloc_iter_done(breloc)) { + if (num_blocks || ftl_reloc_iter_done(breloc)) { break; } } - return lbk_cnt; + return num_blocks; } static struct ftl_io * ftl_reloc_io_init(struct ftl_band_reloc *breloc, struct ftl_reloc_move *move, ftl_io_fn fn, enum ftl_io_type io_type, int flags) { - size_t lbkoff, i; + size_t block_off, i; struct ftl_addr addr = move->addr; struct ftl_io *io = NULL; struct ftl_io_init_opts opts = { @@ -432,7 +432,7 @@ ftl_reloc_io_init(struct ftl_band_reloc *breloc, struct ftl_reloc_move *move, .size = sizeof(*io), .flags = flags | FTL_IO_INTERNAL | FTL_IO_PHYSICAL_MODE, .type = io_type, - .lbk_cnt = move->lbk_cnt, + .num_blocks = move->num_blocks, .data = move->data, .cb_fn = fn, }; @@ -446,15 +446,15 @@ ftl_reloc_io_init(struct ftl_band_reloc *breloc, struct ftl_reloc_move *move, io->addr = move->addr; if (flags & FTL_IO_VECTOR_LBA) { - for (i = 0; i < io->lbk_cnt; ++i, ++addr.offset) { - lbkoff = ftl_band_lbkoff_from_addr(breloc->band, addr); + for (i = 0; i < io->num_blocks; ++i, ++addr.offset) { + block_off = ftl_band_block_offset_from_addr(breloc->band, addr); - if (!ftl_band_lbkoff_valid(breloc->band, lbkoff)) { + if (!ftl_band_block_offset_valid(breloc->band, block_off)) { io->lba.vector[i] = FTL_LBA_INVALID; continue; } - io->lba.vector[i] = breloc->band->lba_map.map[lbkoff]; + io->lba.vector[i] = breloc->band->lba_map.map[block_off]; } } @@ -487,15 +487,15 @@ ftl_reloc_read(struct ftl_band_reloc *breloc, struct ftl_reloc_move *move) { struct ftl_addr addr = {}; - move->lbk_cnt = ftl_reloc_next_lbks(breloc, &addr); + move->num_blocks = ftl_reloc_next_blocks(breloc, &addr); move->breloc = breloc; move->addr = addr; - if (!move->lbk_cnt) { + if (!move->num_blocks) { return 0; } - move->data = spdk_dma_malloc(FTL_BLOCK_SIZE * move->lbk_cnt, 4096, NULL); + move->data = spdk_dma_malloc(FTL_BLOCK_SIZE * move->num_blocks, 4096, NULL); if (!move->data) { return -1; } @@ -566,7 +566,7 @@ ftl_reloc_release(struct ftl_band_reloc *breloc) if (breloc->state == FTL_BAND_RELOC_STATE_HIGH_PRIO) { /* High prio band must be relocated as a whole and ANM events will be ignored */ - assert(breloc->num_lbks == 0 && ftl_band_empty(band)); + assert(breloc->num_blocks == 0 && ftl_band_empty(band)); TAILQ_REMOVE(&reloc->prio_queue, breloc, entry); band->high_prio = 0; breloc->state = FTL_BAND_RELOC_STATE_INACTIVE; @@ -576,7 +576,7 @@ ftl_reloc_release(struct ftl_band_reloc *breloc) breloc->state = FTL_BAND_RELOC_STATE_INACTIVE; /* If we got ANM event during relocation put such band back to pending queue */ - if (breloc->num_lbks != 0) { + if (breloc->num_blocks != 0) { breloc->state = FTL_BAND_RELOC_STATE_PENDING; TAILQ_INSERT_TAIL(&reloc->pending_queue, breloc, entry); return; @@ -789,7 +789,7 @@ ftl_reloc(struct ftl_reloc *reloc) void ftl_reloc_add(struct ftl_reloc *reloc, struct ftl_band *band, size_t offset, - size_t num_lbks, int prio, bool is_defrag) + size_t num_blocks, int prio, bool is_defrag) { struct ftl_band_reloc *breloc = &reloc->brelocs[band->id]; size_t i; @@ -812,17 +812,17 @@ ftl_reloc_add(struct ftl_reloc *reloc, struct ftl_band *band, size_t offset, } pthread_spin_unlock(&band->lba_map.lock); - for (i = offset; i < offset + num_lbks; ++i) { + for (i = offset; i < offset + num_blocks; ++i) { if (spdk_bit_array_get(breloc->reloc_map, i)) { continue; } spdk_bit_array_set(breloc->reloc_map, i); - breloc->num_lbks++; + breloc->num_blocks++; } /* If the band is coming from the defrag process, mark it appropriately */ if (is_defrag) { - assert(offset == 0 && num_lbks == ftl_get_num_blocks_in_band(band->dev)); + assert(offset == 0 && num_blocks == ftl_get_num_blocks_in_band(band->dev)); reloc->num_defrag_bands++; breloc->defrag = true; } diff --git a/lib/ftl/ftl_reloc.h b/lib/ftl/ftl_reloc.h index 0dc772d32..21f49a47d 100644 --- a/lib/ftl/ftl_reloc.h +++ b/lib/ftl/ftl_reloc.h @@ -43,7 +43,7 @@ struct ftl_band; struct ftl_reloc *ftl_reloc_init(struct spdk_ftl_dev *dev); void ftl_reloc_free(struct ftl_reloc *reloc); void ftl_reloc_add(struct ftl_reloc *reloc, struct ftl_band *band, - size_t offset, size_t num_lbks, int prio, bool is_defrag); + size_t offset, size_t num_blocks, int prio, bool is_defrag); void ftl_reloc(struct ftl_reloc *reloc); void ftl_reloc_halt(struct ftl_reloc *reloc); void ftl_reloc_resume(struct ftl_reloc *reloc); diff --git a/lib/ftl/ftl_restore.c b/lib/ftl/ftl_restore.c index e0591a503..1cf232e42 100644 --- a/lib/ftl/ftl_restore.c +++ b/lib/ftl/ftl_restore.c @@ -190,7 +190,7 @@ ftl_restore_init(struct spdk_ftl_dev *dev, ftl_restore_fn cb) } /* Allocate buffer capable of holding head mds of all bands */ - restore->md_buf = spdk_dma_zmalloc(ftl_get_num_bands(dev) * ftl_head_md_num_lbks(dev) * + restore->md_buf = spdk_dma_zmalloc(ftl_get_num_bands(dev) * ftl_head_md_num_blocks(dev) * FTL_BLOCK_SIZE, 0, NULL); if (!restore->md_buf) { goto error; @@ -338,7 +338,7 @@ ftl_restore_head_md(void *ctx) rband = &restore->bands[i]; lba_map = &rband->band->lba_map; - lba_map->dma_buf = restore->md_buf + i * ftl_head_md_num_lbks(dev) * FTL_BLOCK_SIZE; + lba_map->dma_buf = restore->md_buf + i * ftl_head_md_num_blocks(dev) * FTL_BLOCK_SIZE; if (ftl_band_read_head_md(rband->band, ftl_restore_head_cb, rband)) { if (spdk_likely(rband->band->num_zones)) { @@ -402,7 +402,7 @@ ftl_restore_l2p(struct ftl_band *band) ftl_invalidate_addr(dev, addr); } - addr = ftl_band_addr_from_lbkoff(band, i); + addr = ftl_band_addr_from_block_offset(band, i); ftl_band_set_addr(band, lba, addr); ftl_l2p_set(dev, lba, addr); @@ -700,7 +700,7 @@ ftl_nv_cache_alloc_io(struct ftl_nv_cache_block *block, uint64_t lba) .io = NULL, .flags = FTL_IO_BYPASS_CACHE, .type = FTL_IO_WRITE, - .lbk_cnt = 1, + .num_blocks = 1, .cb_fn = ftl_nv_cache_write_cb, .cb_ctx = block, .data = block->buf, @@ -1129,7 +1129,7 @@ ftl_restore_init_pad_io(struct ftl_restore_band *rband, void *buffer, .size = sizeof(struct ftl_io), .flags = flags, .type = FTL_IO_WRITE, - .lbk_cnt = dev->xfer_size, + .num_blocks = dev->xfer_size, .cb_fn = ftl_pad_zone_cb, .cb_ctx = rband, .data = buffer, @@ -1166,12 +1166,12 @@ ftl_pad_zone_cb(struct ftl_io *io, void *arg, int status) } offset = io->addr.offset % ftl_get_num_blocks_in_zone(restore->dev); - if (offset + io->lbk_cnt == ftl_get_num_blocks_in_zone(restore->dev)) { + if (offset + io->num_blocks == ftl_get_num_blocks_in_zone(restore->dev)) { zone = ftl_band_zone_from_addr(band, io->addr); zone->info.state = SPDK_BDEV_ZONE_STATE_CLOSED; } else { struct ftl_addr addr = io->addr; - addr.offset += io->lbk_cnt; + addr.offset += io->num_blocks; new_io = ftl_restore_init_pad_io(rband, io->iov[0].iov_base, addr); if (spdk_unlikely(!new_io)) { restore->pad_status = -ENOMEM; diff --git a/lib/ftl/ftl_trace.c b/lib/ftl/ftl_trace.c index 9794a6f9c..c8a690e3d 100644 --- a/lib/ftl/ftl_trace.c +++ b/lib/ftl/ftl_trace.c @@ -224,7 +224,7 @@ ftl_trace_lba_io_init(struct spdk_ftl_dev *dev, const struct ftl_io *io) } } - spdk_trace_record(tpoint_id, io->trace, io->lbk_cnt, 0, ftl_io_get_lba(io, 0)); + spdk_trace_record(tpoint_id, io->trace, io->num_blocks, 0, ftl_io_get_lba(io, 0)); } void diff --git a/module/bdev/ftl/bdev_ftl.c b/module/bdev/ftl/bdev_ftl.c index 9b3d9a252..ba918e41c 100644 --- a/module/bdev/ftl/bdev_ftl.c +++ b/module/bdev/ftl/bdev_ftl.c @@ -489,13 +489,13 @@ bdev_ftl_create_cb(struct spdk_ftl_dev *dev, void *ctx, int status) ftl_bdev->dev = dev; ftl_bdev->bdev.product_name = "FTL disk"; ftl_bdev->bdev.write_cache = 0; - ftl_bdev->bdev.blocklen = attrs.lbk_size; - ftl_bdev->bdev.blockcnt = attrs.lbk_cnt; + ftl_bdev->bdev.blocklen = attrs.block_size; + ftl_bdev->bdev.blockcnt = attrs.num_blocks; ftl_bdev->bdev.uuid = attrs.uuid; SPDK_DEBUGLOG(SPDK_LOG_BDEV_FTL, "Creating bdev %s:\n", ftl_bdev->bdev.name); - SPDK_DEBUGLOG(SPDK_LOG_BDEV_FTL, "\tblock_len:\t%zu\n", attrs.lbk_size); - SPDK_DEBUGLOG(SPDK_LOG_BDEV_FTL, "\tblock_cnt:\t%"PRIu64"\n", attrs.lbk_cnt); + SPDK_DEBUGLOG(SPDK_LOG_BDEV_FTL, "\tblock_len:\t%zu\n", attrs.block_size); + SPDK_DEBUGLOG(SPDK_LOG_BDEV_FTL, "\tnum_blocks:\t%"PRIu64"\n", attrs.num_blocks); ftl_bdev->bdev.ctxt = ftl_bdev; ftl_bdev->bdev.fn_table = &ftl_fn_table; diff --git a/test/unit/lib/ftl/ftl_band.c/ftl_band_ut.c b/test/unit/lib/ftl/ftl_band.c/ftl_band_ut.c index fe22023b8..793562155 100644 --- a/test/unit/lib/ftl/ftl_band.c/ftl_band_ut.c +++ b/test/unit/lib/ftl/ftl_band.c/ftl_band_ut.c @@ -81,7 +81,7 @@ addr_from_punit(uint64_t punit) } static void -test_band_lbkoff_from_addr_base(void) +test_band_block_offset_from_addr_base(void) { struct ftl_addr addr; uint64_t offset, i, flat_lun = 0; @@ -91,7 +91,7 @@ test_band_lbkoff_from_addr_base(void) addr = addr_from_punit(i); addr.offset += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev); - offset = ftl_band_lbkoff_from_addr(g_band, addr); + offset = ftl_band_block_offset_from_addr(g_band, addr); CU_ASSERT_EQUAL(offset, flat_lun * ftl_get_num_blocks_in_zone(g_dev)); flat_lun++; } @@ -99,7 +99,7 @@ test_band_lbkoff_from_addr_base(void) } static void -test_band_lbkoff_from_addr_offset(void) +test_band_block_offset_from_addr_offset(void) { struct ftl_addr addr; uint64_t offset, expect, i, j; @@ -110,7 +110,7 @@ test_band_lbkoff_from_addr_offset(void) addr = addr_from_punit(i); addr.offset += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev) + j; - offset = ftl_band_lbkoff_from_addr(g_band, addr); + offset = ftl_band_block_offset_from_addr(g_band, addr); expect = test_offset_from_addr(addr, g_band); CU_ASSERT_EQUAL(offset, expect); @@ -120,7 +120,7 @@ test_band_lbkoff_from_addr_offset(void) } static void -test_band_addr_from_lbkoff(void) +test_band_addr_from_block_offset(void) { struct ftl_addr addr, expect; uint64_t offset, i, j; @@ -131,8 +131,8 @@ test_band_addr_from_lbkoff(void) expect = addr_from_punit(i); expect.offset += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev) + j; - offset = ftl_band_lbkoff_from_addr(g_band, expect); - addr = ftl_band_addr_from_lbkoff(g_band, offset); + offset = ftl_band_block_offset_from_addr(g_band, expect); + addr = ftl_band_addr_from_block_offset(g_band, offset); CU_ASSERT_EQUAL(addr.offset, expect.offset); } @@ -214,7 +214,7 @@ test_next_xfer_addr(void) struct ftl_addr addr, result, expect; setup_band(); - /* Verify simple one lbk incremention */ + /* Verify simple one block incremention */ addr = addr_from_punit(0); addr.offset += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev); expect = addr; @@ -296,12 +296,12 @@ main(int argc, char **argv) } if ( - CU_add_test(suite, "test_band_lbkoff_from_addr_base", - test_band_lbkoff_from_addr_base) == NULL - || CU_add_test(suite, "test_band_lbkoff_from_addr_offset", - test_band_lbkoff_from_addr_offset) == NULL - || CU_add_test(suite, "test_band_addr_from_lbkoff", - test_band_addr_from_lbkoff) == NULL + CU_add_test(suite, "test_band_block_offset_from_addr_base", + test_band_block_offset_from_addr_base) == NULL + || CU_add_test(suite, "test_band_block_offset_from_addr_offset", + test_band_block_offset_from_addr_offset) == NULL + || CU_add_test(suite, "test_band_addr_from_block_offset", + test_band_addr_from_block_offset) == NULL || CU_add_test(suite, "test_band_set_addr", test_band_set_addr) == NULL || CU_add_test(suite, "test_invalidate_addr", diff --git a/test/unit/lib/ftl/ftl_md/ftl_md_ut.c b/test/unit/lib/ftl/ftl_md/ftl_md_ut.c index 18c6f1c31..104795317 100644 --- a/test/unit/lib/ftl/ftl_md/ftl_md_ut.c +++ b/test/unit/lib/ftl/ftl_md/ftl_md_ut.c @@ -104,7 +104,7 @@ test_md_unpack_fail(void) /* check crc */ ftl_pack_tail_md(band); /* flip last bit of lba_map */ - *((char *)lba_map->dma_buf + ftl_tail_md_num_lbks(band->dev) * FTL_BLOCK_SIZE - 1) ^= 0x1; + *((char *)lba_map->dma_buf + ftl_tail_md_num_blocks(band->dev) * FTL_BLOCK_SIZE - 1) ^= 0x1; CU_ASSERT_EQUAL(ftl_unpack_tail_md(band), FTL_MD_INVALID_CRC); /* check invalid version */ diff --git a/test/unit/lib/ftl/ftl_reloc.c/ftl_reloc_ut.c b/test/unit/lib/ftl/ftl_reloc.c/ftl_reloc_ut.c index 165ce5bf5..2c4427a06 100644 --- a/test/unit/lib/ftl/ftl_reloc.c/ftl_reloc_ut.c +++ b/test/unit/lib/ftl/ftl_reloc.c/ftl_reloc_ut.c @@ -83,31 +83,31 @@ ftl_band_acquire_lba_map(struct ftl_band *band) } size_t -ftl_lba_map_num_lbks(const struct spdk_ftl_dev *dev) +ftl_lba_map_num_blocks(const struct spdk_ftl_dev *dev) { return spdk_divide_round_up(ftl_get_num_blocks_in_band(dev) * sizeof(uint64_t), FTL_BLOCK_SIZE); } int ftl_band_read_lba_map(struct ftl_band *band, size_t offset, - size_t lbk_cnt, ftl_io_fn fn, void *ctx) + size_t num_blocks, ftl_io_fn fn, void *ctx) { fn(ctx, ctx, 0); return 0; } uint64_t -ftl_band_lbkoff_from_addr(struct ftl_band *band, struct ftl_addr addr) +ftl_band_block_offset_from_addr(struct ftl_band *band, struct ftl_addr addr) { return test_offset_from_addr(addr, band); } struct ftl_addr -ftl_band_addr_from_lbkoff(struct ftl_band *band, uint64_t lbkoff) +ftl_band_addr_from_block_offset(struct ftl_band *band, uint64_t block_off) { struct ftl_addr addr = {}; - addr.offset = lbkoff + band->id * ftl_get_num_blocks_in_band(band->dev); + addr.offset = block_off + band->id * ftl_get_num_blocks_in_band(band->dev); return addr; } @@ -142,11 +142,11 @@ ftl_io_init_internal(const struct ftl_io_init_opts *opts) io->flags = opts->flags; io->cb_fn = opts->cb_fn; io->cb_ctx = io; - io->lbk_cnt = opts->lbk_cnt; + io->num_blocks = opts->num_blocks; io->iov[0].iov_base = opts->data; if (opts->flags & FTL_IO_VECTOR_LBA) { - io->lba.vector = calloc(io->lbk_cnt, sizeof(uint64_t)); + io->lba.vector = calloc(io->num_blocks, sizeof(uint64_t)); SPDK_CU_ASSERT_FATAL(io->lba.vector != NULL); } @@ -234,13 +234,13 @@ cleanup_reloc(struct spdk_ftl_dev *dev, struct ftl_reloc *reloc) } static void -set_band_valid_map(struct ftl_band *band, size_t offset, size_t num_lbks) +set_band_valid_map(struct ftl_band *band, size_t offset, size_t num_blocks) { struct ftl_lba_map *lba_map = &band->lba_map; size_t i; SPDK_CU_ASSERT_FATAL(lba_map != NULL); - for (i = offset; i < offset + num_lbks; ++i) { + for (i = offset; i < offset + num_blocks; ++i) { spdk_bit_array_set(lba_map->vld, i); lba_map->num_vld++; } @@ -249,7 +249,7 @@ set_band_valid_map(struct ftl_band *band, size_t offset, size_t num_lbks) static void test_reloc_iter_full(void) { - size_t num_lbks, num_iters, reminder, i; + size_t num_blocks, num_iters, reminder, i; struct spdk_ftl_dev *dev; struct ftl_reloc *reloc; struct ftl_band_reloc *breloc; @@ -266,30 +266,30 @@ test_reloc_iter_full(void) ftl_reloc_add(reloc, band, 0, ftl_get_num_blocks_in_band(dev), 0, true); - CU_ASSERT_EQUAL(breloc->num_lbks, ftl_get_num_blocks_in_band(dev)); + CU_ASSERT_EQUAL(breloc->num_blocks, ftl_get_num_blocks_in_band(dev)); num_iters = ftl_get_num_punits(dev) * (ftl_get_num_blocks_in_zone(dev) / reloc->xfer_size); for (i = 0; i < num_iters; i++) { - num_lbks = ftl_reloc_next_lbks(breloc, &addr); - CU_ASSERT_EQUAL(num_lbks, reloc->xfer_size); + num_blocks = ftl_reloc_next_blocks(breloc, &addr); + CU_ASSERT_EQUAL(num_blocks, reloc->xfer_size); } num_iters = ftl_get_num_punits(dev); - /* ftl_reloc_next_lbks is searching for maximum xfer_size */ + /* ftl_reloc_next_blocks is searching for maximum xfer_size */ /* contiguous valid logic blocks in zone, so we can end up */ /* with some reminder if number of logical blocks in zone */ /* is not divisible by xfer_size */ reminder = ftl_get_num_blocks_in_zone(dev) % reloc->xfer_size; for (i = 0; i < num_iters; i++) { - num_lbks = ftl_reloc_next_lbks(breloc, &addr); - CU_ASSERT_EQUAL(reminder, num_lbks); + num_blocks = ftl_reloc_next_blocks(breloc, &addr); + CU_ASSERT_EQUAL(reminder, num_blocks); } - /* num_lbks should remain intact since all the blocks are valid */ - CU_ASSERT_EQUAL(breloc->num_lbks, ftl_get_num_blocks_in_band(dev)); + /* num_blocks should remain intact since all the blocks are valid */ + CU_ASSERT_EQUAL(breloc->num_blocks, ftl_get_num_blocks_in_band(dev)); breloc->state = FTL_BAND_RELOC_STATE_INACTIVE; cleanup_reloc(dev, reloc); @@ -310,7 +310,7 @@ test_reloc_empty_band(void) ftl_reloc_add(reloc, band, 0, ftl_get_num_blocks_in_band(dev), 0, true); - CU_ASSERT_EQUAL(breloc->num_lbks, 0); + CU_ASSERT_EQUAL(breloc->num_blocks, 0); cleanup_reloc(dev, reloc); } @@ -322,7 +322,7 @@ test_reloc_full_band(void) struct ftl_reloc *reloc; struct ftl_band_reloc *breloc; struct ftl_band *band; - size_t num_moves, num_iters, num_lbk, i; + size_t num_moves, num_iters, num_block, i; setup_reloc(&dev, &reloc, &g_geo); @@ -335,24 +335,24 @@ test_reloc_full_band(void) ftl_reloc_add(reloc, band, 0, ftl_get_num_blocks_in_band(dev), 0, true); - CU_ASSERT_EQUAL(breloc->num_lbks, ftl_get_num_blocks_in_band(dev)); + CU_ASSERT_EQUAL(breloc->num_blocks, ftl_get_num_blocks_in_band(dev)); ftl_reloc_prep(breloc); add_to_active_queue(reloc, breloc); for (i = 1; i <= num_iters; ++i) { single_reloc_move(breloc); - num_lbk = ftl_get_num_blocks_in_band(dev) - (i * num_moves); - CU_ASSERT_EQUAL(breloc->num_lbks, num_lbk); + num_block = ftl_get_num_blocks_in_band(dev) - (i * num_moves); + CU_ASSERT_EQUAL(breloc->num_blocks, num_block); } - /* Process reminder lbks */ + /* Process reminder blocks */ single_reloc_move(breloc); /* Drain move queue */ ftl_reloc_process_moves(breloc); - CU_ASSERT_EQUAL(breloc->num_lbks, 0); + CU_ASSERT_EQUAL(breloc->num_blocks, 0); CU_ASSERT_TRUE(ftl_reloc_done(breloc)); ftl_reloc_release(breloc); @@ -384,14 +384,14 @@ test_reloc_scatter_band(void) ftl_reloc_prep(breloc); add_to_active_queue(reloc, breloc); - CU_ASSERT_EQUAL(breloc->num_lbks, ftl_get_num_blocks_in_band(dev)); + CU_ASSERT_EQUAL(breloc->num_blocks, ftl_get_num_blocks_in_band(dev)); for (i = 0; i < num_iters ; ++i) { single_reloc_move(breloc); } ftl_process_reloc(breloc); - CU_ASSERT_EQUAL(breloc->num_lbks, 0); + CU_ASSERT_EQUAL(breloc->num_blocks, 0); CU_ASSERT_TRUE(ftl_reloc_done(breloc)); cleanup_reloc(dev, reloc); @@ -404,7 +404,7 @@ test_reloc_zone(void) struct ftl_reloc *reloc; struct ftl_band_reloc *breloc; struct ftl_band *band; - size_t num_io, num_iters, num_lbk, i; + size_t num_io, num_iters, num_block, i; setup_reloc(&dev, &reloc, &g_geo); @@ -422,21 +422,21 @@ test_reloc_zone(void) ftl_get_num_blocks_in_zone(dev), 1, false); add_to_active_queue(reloc, breloc); - CU_ASSERT_EQUAL(breloc->num_lbks, ftl_get_num_blocks_in_zone(dev)); + CU_ASSERT_EQUAL(breloc->num_blocks, ftl_get_num_blocks_in_zone(dev)); for (i = 1; i <= num_iters ; ++i) { single_reloc_move(breloc); - num_lbk = ftl_get_num_blocks_in_zone(dev) - (i * num_io); + num_block = ftl_get_num_blocks_in_zone(dev) - (i * num_io); - CU_ASSERT_EQUAL(breloc->num_lbks, num_lbk); + CU_ASSERT_EQUAL(breloc->num_blocks, num_block); } - /* In case num_lbks_in_zone % num_io != 0 one extra iteration is needed */ + /* In case num_blocks_in_zone % num_io != 0 one extra iteration is needed */ single_reloc_move(breloc); /* Drain move queue */ ftl_reloc_process_moves(breloc); - CU_ASSERT_EQUAL(breloc->num_lbks, 0); + CU_ASSERT_EQUAL(breloc->num_blocks, 0); CU_ASSERT_TRUE(ftl_reloc_done(breloc)); ftl_reloc_release(breloc); @@ -444,7 +444,7 @@ test_reloc_zone(void) } static void -test_reloc_single_lbk(void) +test_reloc_single_block(void) { struct spdk_ftl_dev *dev; struct ftl_reloc *reloc; @@ -464,13 +464,13 @@ test_reloc_single_lbk(void) ftl_reloc_prep(breloc); add_to_active_queue(reloc, breloc); - CU_ASSERT_EQUAL(breloc->num_lbks, 1); + CU_ASSERT_EQUAL(breloc->num_blocks, 1); single_reloc_move(breloc); /* Drain move queue */ ftl_reloc_process_moves(breloc); - CU_ASSERT_EQUAL(breloc->num_lbks, 0); + CU_ASSERT_EQUAL(breloc->num_blocks, 0); CU_ASSERT_TRUE(ftl_reloc_done(breloc)); ftl_reloc_release(breloc); @@ -504,8 +504,8 @@ main(int argc, char **argv) test_reloc_scatter_band) == NULL || CU_add_test(suite, "test_reloc_zone", test_reloc_zone) == NULL - || CU_add_test(suite, "test_reloc_single_lbk", - test_reloc_single_lbk) == NULL + || CU_add_test(suite, "test_reloc_single_block", + test_reloc_single_block) == NULL ) { CU_cleanup_registry(); return CU_get_error(); diff --git a/test/unit/lib/ftl/ftl_wptr/ftl_wptr_ut.c b/test/unit/lib/ftl/ftl_wptr/ftl_wptr_ut.c index 2c94139eb..4091afd17 100644 --- a/test/unit/lib/ftl/ftl_wptr/ftl_wptr_ut.c +++ b/test/unit/lib/ftl/ftl_wptr/ftl_wptr_ut.c @@ -57,7 +57,7 @@ DEFINE_STUB_V(ftl_io_fail, (struct ftl_io *io, int status)); DEFINE_STUB_V(ftl_trace_completion, (struct spdk_ftl_dev *dev, const struct ftl_io *io, enum ftl_trace_completion completion)); DEFINE_STUB_V(ftl_reloc_add, (struct ftl_reloc *reloc, struct ftl_band *band, size_t offset, - size_t num_lbks, int prio, bool defrag)); + size_t num_blocks, int prio, bool defrag)); DEFINE_STUB_V(ftl_trace_write_band, (struct spdk_ftl_dev *dev, const struct ftl_band *band)); DEFINE_STUB_V(ftl_trace_submission, (struct spdk_ftl_dev *dev, const struct ftl_io *io, struct ftl_addr addr, size_t addr_cnt)); @@ -74,7 +74,7 @@ DEFINE_STUB(spdk_bdev_zone_management, int, (struct spdk_bdev_desc *desc, DEFINE_STUB(spdk_bdev_io_get_append_location, uint64_t, (struct spdk_bdev_io *bdev_io), 0); struct ftl_io * -ftl_io_erase_init(struct ftl_band *band, size_t lbk_cnt, ftl_io_fn cb) +ftl_io_erase_init(struct ftl_band *band, size_t num_blocks, ftl_io_fn cb) { struct ftl_io *io; @@ -84,15 +84,15 @@ ftl_io_erase_init(struct ftl_band *band, size_t lbk_cnt, ftl_io_fn cb) io->dev = band->dev; io->band = band; io->cb_fn = cb; - io->lbk_cnt = 1; + io->num_blocks = 1; return io; } void -ftl_io_advance(struct ftl_io *io, size_t lbk_cnt) +ftl_io_advance(struct ftl_io *io, size_t num_blocks) { - io->pos += lbk_cnt; + io->pos += num_blocks; } void @@ -139,7 +139,7 @@ test_wptr(void) struct ftl_band *band; struct ftl_io io = { 0 }; size_t xfer_size; - size_t zone, lbk, offset, i; + size_t zone, block, offset, i; int rc; setup_wptr_test(&dev, &g_geo); @@ -154,7 +154,7 @@ test_wptr(void) io.band = band; io.dev = dev; - for (lbk = 0, offset = 0; lbk < ftl_get_num_blocks_in_zone(dev) / xfer_size; ++lbk) { + for (block = 0, offset = 0; block < ftl_get_num_blocks_in_zone(dev) / xfer_size; ++block) { for (zone = 0; zone < band->num_zones; ++zone) { CU_ASSERT_EQUAL(wptr->offset, offset); ftl_wptr_advance(wptr, xfer_size);