From a05d3047b47758af6c6939e80a6e5e4453b3ac44 Mon Sep 17 00:00:00 2001 From: Artur Paszkiewicz Date: Wed, 22 Jun 2022 14:11:50 +0200 Subject: [PATCH] FTL: Add band unit tests Signed-off-by: Kozlowski Mateusz Signed-off-by: Artur Paszkiewicz Change-Id: I51ef07c172b1cdd204b4bab81abf5d96e646e674 Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/13333 Tested-by: SPDK CI Jenkins Reviewed-by: Ben Walker Reviewed-by: Jim Harris --- test/unit/lib/ftl/Makefile | 2 +- test/unit/lib/ftl/common/utils.c | 158 +++++++++++ test/unit/lib/ftl/ftl_band.c/.gitignore | 1 + test/unit/lib/ftl/ftl_band.c/Makefile | 12 + test/unit/lib/ftl/ftl_band.c/ftl_band_ut.c | 308 +++++++++++++++++++++ test/unit/unittest.sh | 1 + 6 files changed, 481 insertions(+), 1 deletion(-) create mode 100644 test/unit/lib/ftl/common/utils.c create mode 100644 test/unit/lib/ftl/ftl_band.c/.gitignore create mode 100644 test/unit/lib/ftl/ftl_band.c/Makefile create mode 100644 test/unit/lib/ftl/ftl_band.c/ftl_band_ut.c diff --git a/test/unit/lib/ftl/Makefile b/test/unit/lib/ftl/Makefile index 34f832fca..4cd33c5c9 100644 --- a/test/unit/lib/ftl/Makefile +++ b/test/unit/lib/ftl/Makefile @@ -6,7 +6,7 @@ SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../..) include $(SPDK_ROOT_DIR)/mk/spdk.common.mk -DIRS-y = ftl_l2p ftl_io.c +DIRS-y = ftl_l2p ftl_band.c ftl_io.c DIRS-y += ftl_mempool.c ftl_mngt .PHONY: all clean $(DIRS-y) diff --git a/test/unit/lib/ftl/common/utils.c b/test/unit/lib/ftl/common/utils.c new file mode 100644 index 000000000..a3f8748fb --- /dev/null +++ b/test/unit/lib/ftl/common/utils.c @@ -0,0 +1,158 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) Intel Corporation. + * All rights reserved. + */ + +#include "spdk/ftl.h" +#include "ftl/ftl_core.h" + +#include "ftl/mngt/ftl_mngt_bdev.c" + +struct base_bdev_geometry { + size_t write_unit_size; + size_t zone_size; + size_t optimal_open_zones; + size_t blockcnt; +}; + +extern struct base_bdev_geometry g_geo; + +struct spdk_ftl_dev *test_init_ftl_dev(const struct base_bdev_geometry *geo); +struct ftl_band *test_init_ftl_band(struct spdk_ftl_dev *dev, size_t id, size_t zone_size); +void test_free_ftl_dev(struct spdk_ftl_dev *dev); +void test_free_ftl_band(struct ftl_band *band); +uint64_t test_offset_from_addr(ftl_addr addr, struct ftl_band *band); + +DEFINE_STUB(spdk_bdev_desc_get_bdev, struct spdk_bdev *, (struct spdk_bdev_desc *desc), NULL); + +uint64_t +spdk_bdev_get_zone_size(const struct spdk_bdev *bdev) +{ + return g_geo.zone_size; +} + +uint32_t +spdk_bdev_get_optimal_open_zones(const struct spdk_bdev *bdev) +{ + return g_geo.optimal_open_zones; +} + +DEFINE_RETURN_MOCK(ftl_mempool_get, void *); +void * +ftl_mempool_get(struct ftl_mempool *mpool) +{ + return spdk_mempool_get((struct spdk_mempool *)mpool); +} + +void +ftl_mempool_put(struct ftl_mempool *mpool, void *element) +{ + spdk_mempool_put((struct spdk_mempool *)mpool, element); +} + +struct spdk_ftl_dev * +test_init_ftl_dev(const struct base_bdev_geometry *geo) +{ + struct spdk_ftl_dev *dev; + + dev = calloc(1, sizeof(*dev)); + SPDK_CU_ASSERT_FATAL(dev != NULL); + + dev->xfer_size = geo->write_unit_size; + dev->core_thread = spdk_thread_create("unit_test_thread", NULL); + spdk_set_thread(dev->core_thread); + dev->ioch = calloc(1, SPDK_IO_CHANNEL_STRUCT_SIZE + + sizeof(struct ftl_io_channel *)); + dev->num_bands = geo->blockcnt / (geo->zone_size * geo->optimal_open_zones); + dev->bands = calloc(dev->num_bands, sizeof(*dev->bands)); + SPDK_CU_ASSERT_FATAL(dev->bands != NULL); + + dev->layout.base.total_blocks = UINT64_MAX; + + for (size_t i = 0; i < dev->num_bands; i++) { + struct ftl_band_md *md; + int ret; + + ret = posix_memalign((void **)&md, FTL_BLOCK_SIZE, sizeof(*md)); + SPDK_CU_ASSERT_FATAL(ret == 0); + memset(md, 0, sizeof(*md)); + dev->bands[i].md = md; + } + + dev->p2l_pool = (struct ftl_mempool *)spdk_mempool_create("ftl_ut", 2, 0x210200, + SPDK_MEMPOOL_DEFAULT_CACHE_SIZE, + SPDK_ENV_SOCKET_ID_ANY); + SPDK_CU_ASSERT_FATAL(dev->p2l_pool != NULL); + + TAILQ_INIT(&dev->free_bands); + TAILQ_INIT(&dev->shut_bands); + + /* Cache frequently used values */ + dev->num_blocks_in_band = ftl_calculate_num_blocks_in_band(dev->base_bdev_desc); + dev->is_zoned = spdk_bdev_is_zoned(spdk_bdev_desc_get_bdev(dev->base_bdev_desc)); + + return dev; +} + +struct ftl_band * +test_init_ftl_band(struct spdk_ftl_dev *dev, size_t id, size_t zone_size) +{ + struct ftl_band *band; + + SPDK_CU_ASSERT_FATAL(dev != NULL); + SPDK_CU_ASSERT_FATAL(id < dev->num_bands); + + band = &dev->bands[id]; + band->dev = dev; + band->id = id; + + band->md->state = FTL_BAND_STATE_CLOSED; + TAILQ_INSERT_HEAD(&dev->shut_bands, band, queue_entry); + + band->start_addr = zone_size * id; + + return band; +} + +void +test_free_ftl_dev(struct spdk_ftl_dev *dev) +{ + struct spdk_thread *thread; + + SPDK_CU_ASSERT_FATAL(dev != NULL); + free(dev->ioch); + + thread = dev->core_thread; + + spdk_set_thread(thread); + spdk_thread_exit(thread); + while (!spdk_thread_is_exited(thread)) { + spdk_thread_poll(thread, 0, 0); + } + spdk_thread_destroy(thread); + spdk_mempool_free((struct spdk_mempool *)dev->p2l_pool); + for (size_t i = 0; i < dev->num_bands; i++) { + free(dev->bands[i].md); + } + free(dev->bands); + free(dev); +} + +void +test_free_ftl_band(struct ftl_band *band) +{ + SPDK_CU_ASSERT_FATAL(band != NULL); + spdk_dma_free(band->p2l_map.band_dma_md); + + band->p2l_map.band_dma_md = NULL; +} + +uint64_t +test_offset_from_addr(ftl_addr addr, struct ftl_band *band) +{ + struct spdk_ftl_dev *dev = band->dev; + + CU_ASSERT_EQUAL(ftl_addr_get_band(dev, addr), band->id); + + return addr - band->id * ftl_get_num_blocks_in_band(dev); +} diff --git a/test/unit/lib/ftl/ftl_band.c/.gitignore b/test/unit/lib/ftl/ftl_band.c/.gitignore new file mode 100644 index 000000000..aa8820632 --- /dev/null +++ b/test/unit/lib/ftl/ftl_band.c/.gitignore @@ -0,0 +1 @@ +ftl_band_ut diff --git a/test/unit/lib/ftl/ftl_band.c/Makefile b/test/unit/lib/ftl/ftl_band.c/Makefile new file mode 100644 index 000000000..434f4968a --- /dev/null +++ b/test/unit/lib/ftl/ftl_band.c/Makefile @@ -0,0 +1,12 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright (c) Intel Corporation. +# All rights reserved. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../../..) + +TEST_FILE = ftl_band_ut.c + +include $(SPDK_ROOT_DIR)/mk/spdk.unittest.mk + +CFLAGS += -I$(SPDK_ROOT_DIR)/lib/ftl 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 new file mode 100644 index 000000000..20e56bfd2 --- /dev/null +++ b/test/unit/lib/ftl/ftl_band.c/ftl_band_ut.c @@ -0,0 +1,308 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) Intel Corporation. + * All rights reserved. + */ + +#include "spdk/stdinc.h" + +#include "spdk_cunit.h" +#include "common/lib/test_env.c" + +#include "ftl/ftl_core.c" +#include "ftl/ftl_band.c" +#include "../common/utils.c" + +#define TEST_BAND_IDX 42 +#define TEST_LBA 0x68676564 +#define G_GEO_ZONE_SIZE 10000 +#define G_GEO_OPTIMAL_OPEN_ZONES 1 + +struct base_bdev_geometry g_geo = { + .write_unit_size = FTL_NUM_LBA_IN_BLOCK, + .optimal_open_zones = G_GEO_OPTIMAL_OPEN_ZONES, + .zone_size = G_GEO_ZONE_SIZE, + .blockcnt = (TEST_BAND_IDX + 1) * G_GEO_ZONE_SIZE * G_GEO_OPTIMAL_OPEN_ZONES, +}; + +static struct spdk_ftl_dev *g_dev; +static struct ftl_band *g_band; + +DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io)); +DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, (const struct spdk_bdev *bdev), 512); +DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "test"); +DEFINE_STUB(spdk_bdev_get_num_blocks, uint64_t, (const struct spdk_bdev *bdev), 0); +DEFINE_STUB(spdk_bdev_get_md_size, uint32_t, (const struct spdk_bdev *bdev), 8); +DEFINE_STUB(spdk_bdev_write_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + void *buf, uint64_t offset_blocks, uint64_t num_blocks, spdk_bdev_io_completion_cb cb, + void *cb_arg), 0); +DEFINE_STUB(spdk_bdev_write_blocks_with_md, int, (struct spdk_bdev_desc *desc, + struct spdk_io_channel *ch, void *buf, void *md, uint64_t offset_blocks, + uint64_t num_blocks, spdk_bdev_io_completion_cb cb, void *cb_arg), 0); +DEFINE_STUB(spdk_bdev_read_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + void *buf, uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), 0); +DEFINE_STUB(spdk_bdev_write_zeroes_blocks, int, + (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), 0); +DEFINE_STUB(spdk_bdev_writev_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct iovec *iov, int iovcnt, uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), 0); +DEFINE_STUB_V(ftl_io_advance, (struct ftl_io *io, size_t num_blocks)); +DEFINE_STUB(ftl_io_channel_get_ctx, struct ftl_io_channel *, + (struct spdk_io_channel *ioch), NULL); +DEFINE_STUB_V(ftl_io_complete, (struct ftl_io *io)); +DEFINE_STUB(ftl_io_current_lba, uint64_t, (const struct ftl_io *io), 0); +DEFINE_STUB_V(ftl_io_dec_req, (struct ftl_io *io)); +DEFINE_STUB_V(ftl_io_fail, (struct ftl_io *io, int status)); +DEFINE_STUB_V(ftl_io_free, (struct ftl_io *io)); +DEFINE_STUB(ftl_io_get_lba, uint64_t, + (const struct ftl_io *io, size_t offset), 0); +DEFINE_STUB_V(ftl_io_inc_req, (struct ftl_io *io)); +DEFINE_STUB(ftl_io_iovec_addr, void *, (struct ftl_io *io), NULL); +DEFINE_STUB(ftl_io_iovec_len_left, size_t, (struct ftl_io *io), 0); + +DEFINE_STUB(ftl_iovec_num_blocks, size_t, + (struct iovec *iov, size_t iov_cnt), 0); +DEFINE_STUB(spdk_bdev_is_zoned, bool, (const struct spdk_bdev *bdev), true); +DEFINE_STUB(ftl_mngt_unmap, int, (struct spdk_ftl_dev *dev, uint64_t lba, uint64_t num_blocks, + spdk_ftl_fn cb, void *cb_cntx), 0); + +DEFINE_STUB_V(ftl_l2p_process, (struct spdk_ftl_dev *dev)); +DEFINE_STUB_V(ftl_nv_cache_process, (struct spdk_ftl_dev *dev)); +DEFINE_STUB(ftl_nv_cache_is_halted, bool, (struct ftl_nv_cache *nvc), true); +DEFINE_STUB(ftl_nv_cache_chunks_busy, int, (struct ftl_nv_cache *nvc), true); +DEFINE_STUB(ftl_nv_cache_full, bool, (struct ftl_nv_cache *nvc), true); +DEFINE_STUB(ftl_l2p_is_halted, bool, (struct spdk_ftl_dev *dev), true); +DEFINE_STUB(ftl_nv_cache_write, bool, (struct ftl_io *io), true); +DEFINE_STUB_V(ftl_nv_cache_halt, (struct ftl_nv_cache *nvc)); +DEFINE_STUB_V(ftl_l2p_halt, (struct spdk_ftl_dev *dev)); +DEFINE_STUB(ftl_io_init, int, (struct spdk_io_channel *_ioch, struct ftl_io *io, uint64_t lba, + size_t num_blocks, + struct iovec *iov, size_t iov_cnt, spdk_ftl_fn cb_fn, void *cb_ctx, int type), 0); +DEFINE_STUB_V(ftl_mngt_next_step, (struct ftl_mngt_process *mngt)); +DEFINE_STUB_V(ftl_mngt_fail_step, (struct ftl_mngt_process *mngt)); +DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc)); +DEFINE_STUB(spdk_bdev_get_io_channel, struct spdk_io_channel *, (struct spdk_bdev_desc *bdev_desc), + NULL); +DEFINE_STUB(spdk_bdev_io_type_supported, bool, (struct spdk_bdev *bdev, + enum spdk_bdev_io_type io_type), true); +DEFINE_STUB_V(spdk_bdev_module_release_bdev, (struct spdk_bdev *bdev)); +DEFINE_STUB(spdk_bdev_module_claim_bdev, int, (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, + struct spdk_bdev_module *module), 0); +DEFINE_STUB(spdk_bdev_open_ext, int, (const char *bdev_name, bool write, + spdk_bdev_event_cb_t event_cb, + void *event_ctx, struct spdk_bdev_desc **desc), 0); +DEFINE_STUB(spdk_bdev_get_write_unit_size, uint32_t, (const struct spdk_bdev *bdev), 1); +DEFINE_STUB(spdk_bdev_is_md_separate, bool, (const struct spdk_bdev *bdev), true); +DEFINE_STUB(spdk_bdev_get_dif_type, enum spdk_dif_type, (const struct spdk_bdev *bdev), + SPDK_DIF_DISABLE); +DEFINE_STUB(ftl_md_xfer_blocks, uint64_t, (struct spdk_ftl_dev *dev), 4); +DEFINE_STUB_V(ftl_l2p_pin, (struct spdk_ftl_dev *dev, uint64_t lba, uint64_t count, + ftl_l2p_pin_cb cb, void *cb_ctx, + struct ftl_l2p_pin_ctx *pin_ctx)); +DEFINE_STUB_V(ftl_l2p_pin_skip, (struct spdk_ftl_dev *dev, ftl_l2p_pin_cb cb, void *cb_ctx, + struct ftl_l2p_pin_ctx *pin_ctx)); +DEFINE_STUB(ftl_nv_cache_read, int, (struct ftl_io *io, ftl_addr addr, uint32_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), 0); +DEFINE_STUB(spdk_bdev_queue_io_wait, int, (struct spdk_bdev *bdev, struct spdk_io_channel *ch, + struct spdk_bdev_io_wait_entry *entry), 0); +DEFINE_STUB(ftl_l2p_get, ftl_addr, (struct spdk_ftl_dev *dev, uint64_t lba), 0); + +static void +setup_band(void) +{ + int rc; + + g_dev = test_init_ftl_dev(&g_geo); + g_band = test_init_ftl_band(g_dev, TEST_BAND_IDX, ftl_get_num_blocks_in_band(g_dev)); + rc = ftl_band_alloc_p2l_map(g_band); + CU_ASSERT_EQUAL_FATAL(rc, 0); +} + +static void +cleanup_band(void) +{ + ftl_band_release_p2l_map(g_band); + test_free_ftl_band(g_band); + test_free_ftl_dev(g_dev); +} + +static ftl_addr +addr_from_zone_id(uint64_t zone_id) +{ + ftl_addr addr; + + addr = zone_id * g_geo.zone_size; + return addr; +} + +static void +test_band_block_offset_from_addr_base(void) +{ + ftl_addr addr; + uint64_t offset; + + setup_band(); + addr = addr_from_zone_id(0); + addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev); + + offset = ftl_band_block_offset_from_addr(g_band, addr); + CU_ASSERT_EQUAL(offset, 0); + cleanup_band(); +} + +static void +test_band_block_offset_from_addr_offset(void) +{ + ftl_addr addr; + uint64_t offset, expect, j; + + setup_band(); + for (j = 0; j < g_geo.zone_size; ++j) { + addr = addr_from_zone_id(0); + addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev) + j; + + offset = ftl_band_block_offset_from_addr(g_band, addr); + + expect = test_offset_from_addr(addr, g_band); + CU_ASSERT_EQUAL(offset, expect); + } + cleanup_band(); +} + +static void +test_band_addr_from_block_offset(void) +{ + ftl_addr addr, expect; + uint64_t offset, j; + + setup_band(); + for (j = 0; j < g_geo.zone_size; ++j) { + expect = addr_from_zone_id(0); + expect += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev) + j; + + offset = ftl_band_block_offset_from_addr(g_band, expect); + addr = ftl_band_addr_from_block_offset(g_band, offset); + + CU_ASSERT_EQUAL(addr, expect); + } + cleanup_band(); +} + +static void +test_band_set_addr(void) +{ + struct ftl_p2l_map *p2l_map; + ftl_addr addr; + uint64_t offset = 0; + + setup_band(); + p2l_map = &g_band->p2l_map; + addr = addr_from_zone_id(0); + addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev); + + CU_ASSERT_EQUAL(p2l_map->num_valid, 0); + + offset = test_offset_from_addr(addr, g_band); + + ftl_band_set_addr(g_band, TEST_LBA, addr); + CU_ASSERT_EQUAL(p2l_map->num_valid, 1); + CU_ASSERT_EQUAL(p2l_map->band_map[offset], TEST_LBA); + + addr += g_geo.zone_size / 2; + offset = test_offset_from_addr(addr, g_band); + ftl_band_set_addr(g_band, TEST_LBA + 1, addr); + CU_ASSERT_EQUAL(p2l_map->num_valid, 2); + CU_ASSERT_EQUAL(p2l_map->band_map[offset], TEST_LBA + 1); + addr -= g_geo.zone_size / 2; + offset = test_offset_from_addr(addr, g_band); + cleanup_band(); +} + +static void +test_invalidate_addr(void) +{ + struct ftl_p2l_map *p2l_map; + ftl_addr addr; + + setup_band(); + p2l_map = &g_band->p2l_map; + addr = addr_from_zone_id(0); + addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev); + + ftl_band_set_addr(g_band, TEST_LBA, addr); + CU_ASSERT_EQUAL(p2l_map->num_valid, 1); + ftl_invalidate_addr(g_band->dev, addr); + CU_ASSERT_EQUAL(p2l_map->num_valid, 0); + + ftl_band_set_addr(g_band, TEST_LBA, addr); + addr += g_geo.zone_size / 2; + ftl_band_set_addr(g_band, TEST_LBA + 1, addr); + CU_ASSERT_EQUAL(p2l_map->num_valid, 2); + ftl_invalidate_addr(g_band->dev, addr); + CU_ASSERT_EQUAL(p2l_map->num_valid, 1); + cleanup_band(); +} + +static void +test_next_xfer_addr(void) +{ + ftl_addr addr, result, expect; + + setup_band(); + /* Verify simple one block incremention */ + addr = addr_from_zone_id(0); + addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev); + expect = addr; + expect += 1; + + result = ftl_band_next_xfer_addr(g_band, addr, 1); + CU_ASSERT_EQUAL(result, expect); + + /* Verify jumping from last zone to the first one */ + expect = addr_from_zone_id(0); + expect += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev) + g_dev->xfer_size; + addr = addr_from_zone_id(0); + addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev); + result = ftl_band_next_xfer_addr(g_band, addr, g_dev->xfer_size); + CU_ASSERT_EQUAL(result, expect); + + /* Verify jumping from last zone to the first one with unaligned offset */ + expect = addr_from_zone_id(0); + expect += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev); + expect += g_dev->xfer_size + 2; + addr = addr_from_zone_id(0); + addr += TEST_BAND_IDX * ftl_get_num_blocks_in_band(g_dev); + result = ftl_band_next_xfer_addr(g_band, addr, g_dev->xfer_size + 2); + CU_ASSERT_EQUAL(result, expect); + + cleanup_band(); +} + +int +main(int argc, char **argv) +{ + CU_pSuite suite = NULL; + unsigned int num_failures; + + CU_set_error_action(CUEA_ABORT); + CU_initialize_registry(); + + suite = CU_add_suite("ftl_band_suite", NULL, NULL); + + + CU_ADD_TEST(suite, test_band_block_offset_from_addr_base); + CU_ADD_TEST(suite, test_band_block_offset_from_addr_offset); + CU_ADD_TEST(suite, test_band_addr_from_block_offset); + CU_ADD_TEST(suite, test_band_set_addr); + CU_ADD_TEST(suite, test_invalidate_addr); + CU_ADD_TEST(suite, test_next_xfer_addr); + + CU_basic_set_mode(CU_BRM_VERBOSE); + CU_basic_run_tests(); + num_failures = CU_get_number_of_failures(); + CU_cleanup_registry(); + + return num_failures; +} diff --git a/test/unit/unittest.sh b/test/unit/unittest.sh index 6b35b19a3..e8c8c70cf 100755 --- a/test/unit/unittest.sh +++ b/test/unit/unittest.sh @@ -45,6 +45,7 @@ function unittest_event() { } function unittest_ftl() { + $valgrind $testdir/lib/ftl/ftl_band.c/ftl_band_ut $valgrind $testdir/lib/ftl/ftl_io.c/ftl_io_ut $valgrind $testdir/lib/ftl/ftl_mngt/ftl_mngt_ut $valgrind $testdir/lib/ftl/ftl_mempool.c/ftl_mempool_ut