1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2019 Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include "spdk/stdinc.h" 7 8 #include "spdk_internal/cunit.h" 9 #include "common/lib/ut_multithread.c" 10 11 #include "ftl/ftl_io.c" 12 #include "ftl/utils/ftl_conf.c" 13 14 DEFINE_STUB(spdk_bdev_io_get_append_location, uint64_t, (struct spdk_bdev_io *bdev_io), 0); 15 DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc)); 16 DEFINE_STUB(spdk_bdev_desc_get_bdev, struct spdk_bdev *, (struct spdk_bdev_desc *desc), NULL); 17 DEFINE_STUB(spdk_bdev_get_optimal_open_zones, uint32_t, (const struct spdk_bdev *b), 1); 18 DEFINE_STUB(spdk_bdev_get_by_name, struct spdk_bdev *, (const char *bdev_name), NULL); 19 DEFINE_STUB(spdk_bdev_is_md_separate, bool, (const struct spdk_bdev *bdev), false); 20 DEFINE_STUB(spdk_bdev_is_zoned, bool, (const struct spdk_bdev *bdev), false); 21 DEFINE_STUB(spdk_bdev_zone_appendv, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 22 struct iovec *iov, int iovcnt, uint64_t zone_id, uint64_t num_blocks, 23 spdk_bdev_io_completion_cb cb, void *cb_arg), 0); 24 DEFINE_STUB(spdk_bdev_get_zone_size, uint64_t, (const struct spdk_bdev *b), 1024); 25 DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io)); 26 DEFINE_STUB(spdk_bdev_get_buf_align, size_t, (const struct spdk_bdev *bdev), 64); 27 DEFINE_STUB(spdk_bdev_get_dif_type, enum spdk_dif_type, 28 (const struct spdk_bdev *bdev), 0); 29 DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "test"); 30 DEFINE_STUB(spdk_bdev_get_write_unit_size, uint32_t, 31 (const struct spdk_bdev *bdev), 0); 32 DEFINE_STUB(spdk_bdev_io_type_supported, bool, (struct spdk_bdev *bdev, 33 enum spdk_bdev_io_type io_type), true); 34 DEFINE_STUB(spdk_bdev_open_ext, int, 35 (const char *bdev_name, bool write, spdk_bdev_event_cb_t event_cb, 36 void *event_ctx, struct spdk_bdev_desc **desc), 0); 37 DEFINE_STUB(spdk_bdev_read_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 38 void *buf, uint64_t offset_blocks, uint64_t num_blocks, 39 spdk_bdev_io_completion_cb cb, void *cb_arg), 0); 40 DEFINE_STUB(spdk_bdev_write_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 41 void *buf, uint64_t offset_blocks, uint64_t num_blocks, spdk_bdev_io_completion_cb cb, 42 void *cb_arg), 0); 43 DEFINE_STUB(spdk_bdev_write_blocks_with_md, int, (struct spdk_bdev_desc *desc, 44 struct spdk_io_channel *ch, void *buf, void *md, uint64_t offset_blocks, 45 uint64_t num_blocks, spdk_bdev_io_completion_cb cb, void *cb_arg), 0); 46 DEFINE_STUB(spdk_bdev_writev_blocks, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 47 struct iovec *iov, int iovcnt, uint64_t offset_blocks, uint64_t num_blocks, 48 spdk_bdev_io_completion_cb cb, void *cb_arg), 0); 49 DEFINE_STUB(spdk_bdev_get_num_blocks, uint64_t, (const struct spdk_bdev *bdev), 1024); 50 DEFINE_STUB(spdk_bdev_get_md_size, uint32_t, (const struct spdk_bdev *bdev), 0); 51 DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, (const struct spdk_bdev *bdev), 4096); 52 DEFINE_STUB_V(spdk_bdev_module_release_bdev, (struct spdk_bdev *bdev)); 53 DEFINE_STUB(spdk_bdev_write_zeroes_blocks, int, 54 (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 55 uint64_t offset_blocks, uint64_t num_blocks, 56 spdk_bdev_io_completion_cb cb, void *cb_arg), 0); 57 DEFINE_STUB(spdk_mempool_create_ctor, struct spdk_mempool *, 58 (const char *name, size_t count, size_t ele_size, size_t cache_size, 59 int socket_id, spdk_mempool_obj_cb_t *obj_init, void *obj_init_arg), NULL); 60 DEFINE_STUB(spdk_mempool_obj_iter, uint32_t, 61 (struct spdk_mempool *mp, spdk_mempool_obj_cb_t obj_cb, void *obj_cb_arg), 0); 62 DEFINE_STUB_V(ftl_reloc, (struct ftl_reloc *reloc)); 63 DEFINE_STUB_V(ftl_reloc_free, (struct ftl_reloc *reloc)); 64 DEFINE_STUB_V(ftl_reloc_halt, (struct ftl_reloc *reloc)); 65 DEFINE_STUB(ftl_reloc_init, struct ftl_reloc *, (struct spdk_ftl_dev *dev), NULL); 66 DEFINE_STUB(ftl_reloc_is_halted, bool, (const struct ftl_reloc *reloc), false); 67 DEFINE_STUB_V(ftl_reloc_resume, (struct ftl_reloc *reloc)); 68 DEFINE_STUB_V(ftl_l2p_unpin, (struct spdk_ftl_dev *dev, uint64_t lba, uint64_t count)); 69 DEFINE_STUB(ftl_p2l_ckpt_acquire, struct ftl_p2l_ckpt *, (struct spdk_ftl_dev *dev), NULL); 70 DEFINE_STUB_V(ftl_p2l_ckpt_release, (struct spdk_ftl_dev *dev, struct ftl_p2l_ckpt *ckpt)); 71 DEFINE_STUB(ftl_l2p_get, ftl_addr, (struct spdk_ftl_dev *dev, uint64_t lba), 0); 72 DEFINE_STUB_V(ftl_mempool_put, (struct ftl_mempool *mpool, void *element)); 73 DEFINE_STUB_V(ftl_property_dump_bool, (struct spdk_ftl_dev *dev, 74 const struct ftl_property *property, 75 struct spdk_json_write_ctx *w)); 76 DEFINE_STUB(ftl_property_decode_bool, int, (struct spdk_ftl_dev *dev, struct ftl_property *property, 77 const char *value, size_t value_size, void *output, size_t output_size), 0); 78 DEFINE_STUB_V(ftl_property_set_generic, (struct spdk_ftl_dev *dev, struct ftl_mngt_process *mngt, 79 const struct ftl_property *property, void *new_value, size_t new_value_size)); 80 DEFINE_STUB_V(ftl_property_register, (struct spdk_ftl_dev *dev, 81 const char *name, void *value, size_t size, 82 const char *unit, const char *desc, 83 ftl_property_dump_fn dump, 84 ftl_property_decode_fn decode, 85 ftl_property_set_fn set, 86 bool verbose_mode)); 87 88 #if defined(DEBUG) 89 DEFINE_STUB_V(ftl_trace_submission, (struct spdk_ftl_dev *dev, const struct ftl_io *io, 90 ftl_addr addr, size_t addr_cnt)); 91 DEFINE_STUB_V(ftl_trace_lba_io_init, (struct spdk_ftl_dev *dev, const struct ftl_io *io)); 92 DEFINE_STUB_V(ftl_trace_limits, (struct spdk_ftl_dev *dev, int limit, size_t num_free)); 93 DEFINE_STUB(ftl_trace_alloc_id, uint64_t, (struct spdk_ftl_dev *dev), 0); 94 DEFINE_STUB_V(ftl_trace_completion, (struct spdk_ftl_dev *dev, const struct ftl_io *io, 95 enum ftl_trace_completion type)); 96 DEFINE_STUB_V(ftl_trace_write_band, (struct spdk_ftl_dev *dev, const struct ftl_band *band)); 97 #endif 98 99 #if defined(FTL_DUMP_STATS) 100 DEFINE_STUB_V(ftl_dev_dump_stats, (const struct spdk_ftl_dev *dev)); 101 #endif 102 103 struct ftl_io_channel_ctx { 104 struct ftl_io_channel *ioch; 105 }; 106 107 struct ftl_io_channel * 108 ftl_io_channel_get_ctx(struct spdk_io_channel *ioch) 109 { 110 struct ftl_io_channel_ctx *ctx = spdk_io_channel_get_ctx(ioch); 111 112 return ctx->ioch; 113 } 114 115 struct spdk_io_channel * 116 spdk_bdev_get_io_channel(struct spdk_bdev_desc *bdev_desc) 117 { 118 return spdk_get_io_channel(bdev_desc); 119 } 120 121 static int 122 channel_create_cb(void *io_device, void *ctx) 123 { 124 return 0; 125 } 126 127 static void 128 channel_destroy_cb(void *io_device, void *ctx) 129 { 130 } 131 132 static struct spdk_ftl_dev * 133 setup_device(uint32_t num_threads, uint32_t xfer_size) 134 { 135 struct spdk_ftl_dev *dev; 136 struct ftl_io_channel *ioch; 137 struct ftl_io_channel_ctx *ctx; 138 139 allocate_threads(num_threads); 140 set_thread(0); 141 142 dev = calloc(1, sizeof(*dev)); 143 SPDK_CU_ASSERT_FATAL(dev != NULL); 144 145 dev->core_thread = spdk_get_thread(); 146 dev->ioch = calloc(1, SPDK_IO_CHANNEL_STRUCT_SIZE + sizeof(struct ftl_io_channel_ctx)); 147 SPDK_CU_ASSERT_FATAL(dev->ioch != NULL); 148 149 ctx = spdk_io_channel_get_ctx(dev->ioch); 150 ctx->ioch = calloc(1, sizeof(*ctx->ioch)); 151 152 ioch = ftl_io_channel_get_ctx(dev->ioch); 153 SPDK_CU_ASSERT_FATAL(ioch != NULL); 154 155 ioch->cq = spdk_ring_create(0, 1024, 0); 156 157 dev->conf = g_default_conf; 158 dev->xfer_size = xfer_size; 159 dev->base_bdev_desc = (struct spdk_bdev_desc *)0xdeadbeef; 160 dev->nv_cache.bdev_desc = (struct spdk_bdev_desc *)0xdead1234; 161 spdk_io_device_register(dev, channel_create_cb, channel_destroy_cb, 0, NULL); 162 spdk_io_device_register(dev->base_bdev_desc, channel_create_cb, channel_destroy_cb, 0, NULL); 163 spdk_io_device_register(dev->nv_cache.bdev_desc, channel_create_cb, channel_destroy_cb, 0, NULL); 164 165 TAILQ_INIT(&dev->ioch_queue); 166 167 return dev; 168 } 169 170 static void 171 free_device(struct spdk_ftl_dev *dev) 172 { 173 struct ftl_io_channel *ioch; 174 175 ioch = ftl_io_channel_get_ctx(dev->ioch); 176 spdk_ring_free(ioch->cq); 177 free(ioch); 178 179 spdk_io_device_unregister(dev, NULL); 180 spdk_io_device_unregister(dev->base_bdev_desc, NULL); 181 spdk_io_device_unregister(dev->nv_cache.bdev_desc, NULL); 182 183 while (!TAILQ_EMPTY(&dev->ioch_queue)) { 184 TAILQ_REMOVE(&dev->ioch_queue, TAILQ_FIRST(&dev->ioch_queue), entry); 185 } 186 187 free_threads(); 188 189 free(dev->ioch); 190 free(dev->sb); 191 free(dev); 192 } 193 194 static void 195 setup_io(struct ftl_io *io, struct spdk_ftl_dev *dev, spdk_ftl_fn cb, void *ctx) 196 { 197 io->dev = dev; 198 io->user_fn = cb; 199 io->cb_ctx = ctx; 200 io->flags = 0; 201 io->ioch = dev->ioch; 202 } 203 204 static void 205 io_complete_cb(void *ctx, int status) 206 { 207 *(int *)ctx = status; 208 } 209 210 static void 211 test_completion(void) 212 { 213 struct spdk_ftl_dev *dev; 214 struct ftl_io_channel *ioch; 215 struct ftl_io io = { 0 }, *io_ring; 216 int req, status = 0; 217 218 dev = setup_device(1, FTL_NUM_LBA_IN_BLOCK); 219 ioch = ftl_io_channel_get_ctx(dev->ioch); 220 221 /* Setup IO and 'send' NUM_REQUESTS subrequests */ 222 setup_io(&io, dev, io_complete_cb, &status); 223 io.status = -EIO; 224 225 #define NUM_REQUESTS 16 226 for (req = 0; req < NUM_REQUESTS; ++req) { 227 ftl_io_inc_req(&io); 228 CU_ASSERT_FALSE(ftl_io_done(&io)); 229 } 230 231 CU_ASSERT_EQUAL(io.req_cnt, NUM_REQUESTS); 232 233 /* Complete all but one subrequest, make sure io still not marked as done */ 234 for (req = 0; req < (NUM_REQUESTS - 1); ++req) { 235 ftl_io_dec_req(&io); 236 CU_ASSERT_FALSE(ftl_io_done(&io)); 237 } 238 239 CU_ASSERT_EQUAL(io.req_cnt, 1); 240 241 /* Complete last subrequest, make sure it appears on the completion queue */ 242 ftl_io_dec_req(&io); 243 CU_ASSERT_TRUE(ftl_io_done(&io)); 244 245 ftl_io_complete(&io); 246 247 CU_ASSERT_EQUAL(spdk_ring_count(ioch->cq), 1); 248 249 /* Dequeue and check if the completion callback changes the status, this is usually done via poller */ 250 spdk_ring_dequeue(ioch->cq, (void **)&io_ring, 1); 251 io_ring->user_fn(io_ring->cb_ctx, io_ring->status); 252 253 CU_ASSERT_EQUAL(status, -EIO); 254 255 free_device(dev); 256 } 257 258 static void 259 test_multiple_ios(void) 260 { 261 struct spdk_ftl_dev *dev; 262 struct ftl_io_channel *ioch; 263 struct ftl_io io[2] = { 0 }, *io_ring[2]; 264 int status = -1; 265 266 dev = setup_device(1, FTL_NUM_LBA_IN_BLOCK); 267 ioch = ftl_io_channel_get_ctx(dev->ioch); 268 269 /* Send t2o IOs and check if both are in the completion queue */ 270 setup_io(&io[0], dev, io_complete_cb, &status); 271 CU_ASSERT_EQUAL(spdk_ring_count(ioch->cq), 0); 272 273 ftl_io_complete(io); 274 CU_ASSERT_EQUAL(spdk_ring_count(ioch->cq), 1); 275 276 setup_io(&io[1], dev, io_complete_cb, &status); 277 278 ftl_io_complete(&io[1]); 279 CU_ASSERT_EQUAL(spdk_ring_count(ioch->cq), 2); 280 281 /* Dequeue and check if the completion callback changes the status, this is usually done via poller */ 282 spdk_ring_dequeue(ioch->cq, (void **)io_ring, 2); 283 status = -1; 284 io_ring[0]->user_fn(io_ring[0]->cb_ctx, io_ring[0]->status); 285 CU_ASSERT_EQUAL(status, 0); 286 status = -1; 287 io_ring[1]->user_fn(io_ring[1]->cb_ctx, io_ring[1]->status); 288 CU_ASSERT_EQUAL(status, 0); 289 290 free_device(dev); 291 } 292 293 int 294 main(int argc, char **argv) 295 { 296 CU_pSuite suite; 297 unsigned int num_failures; 298 299 CU_initialize_registry(); 300 301 suite = CU_add_suite("ftl_io_suite", NULL, NULL); 302 303 304 CU_ADD_TEST(suite, test_completion); 305 CU_ADD_TEST(suite, test_multiple_ios); 306 307 num_failures = spdk_ut_run_tests(argc, argv, NULL); 308 CU_cleanup_registry(); 309 310 return num_failures; 311 } 312