1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk_cunit.h" 35 36 #include "lib/test_env.c" 37 #include "lib/ut_multithread.c" 38 39 /* HACK: disable VTune integration so the unit test doesn't need VTune headers and libs to build */ 40 #undef SPDK_CONFIG_VTUNE 41 42 #include "bdev.c" 43 44 #define BDEV_UT_NUM_THREADS 3 45 46 DEFINE_STUB_V(spdk_scsi_nvme_translate, (const struct spdk_bdev_io *bdev_io, 47 int *sc, int *sk, int *asc, int *ascq)); 48 49 struct ut_bdev { 50 struct spdk_bdev bdev; 51 int io_target; 52 }; 53 54 struct ut_bdev_channel { 55 TAILQ_HEAD(, spdk_bdev_io) outstanding_io; 56 }; 57 58 struct ut_bdev g_bdev; 59 struct spdk_bdev_desc *g_desc; 60 61 static int 62 stub_create_ch(void *io_device, void *ctx_buf) 63 { 64 struct ut_bdev_channel *ch = ctx_buf; 65 66 TAILQ_INIT(&ch->outstanding_io); 67 return 0; 68 } 69 70 static void 71 stub_destroy_ch(void *io_device, void *ctx_buf) 72 { 73 } 74 75 static struct spdk_io_channel * 76 stub_get_io_channel(void *ctx) 77 { 78 return spdk_get_io_channel(&g_bdev.io_target); 79 } 80 81 static int 82 stub_destruct(void *ctx) 83 { 84 return 0; 85 } 86 87 static void 88 stub_submit_request(struct spdk_io_channel *_ch, struct spdk_bdev_io *bdev_io) 89 { 90 struct ut_bdev_channel *ch = spdk_io_channel_get_ctx(_ch); 91 92 TAILQ_INSERT_TAIL(&ch->outstanding_io, bdev_io, module_link); 93 } 94 95 static void 96 stub_complete_io(void) 97 { 98 struct spdk_io_channel *_ch = spdk_get_io_channel(&g_bdev.io_target); 99 struct ut_bdev_channel *ch = spdk_io_channel_get_ctx(_ch); 100 struct spdk_bdev_io *io; 101 102 while (!TAILQ_EMPTY(&ch->outstanding_io)) { 103 io = TAILQ_FIRST(&ch->outstanding_io); 104 TAILQ_REMOVE(&ch->outstanding_io, io, module_link); 105 spdk_bdev_io_complete(io, SPDK_BDEV_IO_STATUS_SUCCESS); 106 } 107 108 spdk_put_io_channel(_ch); 109 } 110 111 static struct spdk_bdev_fn_table fn_table = { 112 .get_io_channel = stub_get_io_channel, 113 .destruct = stub_destruct, 114 .submit_request = stub_submit_request, 115 }; 116 117 static int 118 module_init(void) 119 { 120 return 0; 121 } 122 123 static void 124 module_fini(void) 125 { 126 } 127 128 SPDK_BDEV_MODULE_REGISTER(bdev_ut, module_init, module_fini, NULL, NULL, NULL) 129 130 static void 131 register_bdev(void) 132 { 133 g_bdev.bdev.name = "bdev_ut"; 134 g_bdev.bdev.fn_table = &fn_table; 135 g_bdev.bdev.module = SPDK_GET_BDEV_MODULE(bdev_ut); 136 g_bdev.bdev.blocklen = 4096; 137 g_bdev.bdev.blockcnt = 1024; 138 139 spdk_io_device_register(&g_bdev.io_target, stub_create_ch, stub_destroy_ch, 140 sizeof(struct ut_bdev_channel)); 141 spdk_bdev_register(&g_bdev.bdev); 142 } 143 144 static void 145 unregister_bdev(void) 146 { 147 /* Handle any deferred messages. */ 148 poll_threads(); 149 spdk_bdev_unregister(&g_bdev.bdev); 150 spdk_io_device_unregister(&g_bdev.io_target, NULL); 151 memset(&g_bdev, 0, sizeof(g_bdev)); 152 } 153 154 static void 155 bdev_init_cb(void *done, int rc) 156 { 157 CU_ASSERT(rc == 0); 158 *(bool *)done = true; 159 } 160 161 static void 162 setup_test(void) 163 { 164 bool done = false; 165 166 allocate_threads(BDEV_UT_NUM_THREADS); 167 spdk_bdev_initialize(bdev_init_cb, &done, NULL, NULL); 168 register_bdev(); 169 spdk_bdev_open(&g_bdev.bdev, true, NULL, NULL, &g_desc); 170 } 171 172 static void 173 teardown_test(void) 174 { 175 spdk_bdev_close(g_desc); 176 g_desc = NULL; 177 unregister_bdev(); 178 spdk_bdev_finish(); 179 free_threads(); 180 } 181 182 static void 183 basic(void) 184 { 185 setup_test(); 186 187 set_thread(0); 188 189 g_ut_threads[0].ch = spdk_bdev_get_io_channel(g_desc); 190 spdk_put_io_channel(g_ut_threads[0].ch); 191 192 teardown_test(); 193 } 194 195 static void 196 reset_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 197 { 198 bool *done = cb_arg; 199 200 CU_ASSERT(success == true); 201 *done = true; 202 spdk_bdev_free_io(bdev_io); 203 } 204 205 static void 206 put_channel_during_reset(void) 207 { 208 struct spdk_io_channel *io_ch; 209 bool done = false; 210 211 setup_test(); 212 213 set_thread(0); 214 io_ch = spdk_bdev_get_io_channel(g_desc); 215 CU_ASSERT(io_ch != NULL); 216 217 /* 218 * Start a reset, but then put the I/O channel before 219 * the deferred messages for the reset get a chance to 220 * execute. 221 */ 222 spdk_bdev_reset(g_desc, io_ch, reset_done, &done); 223 spdk_put_io_channel(io_ch); 224 poll_threads(); 225 stub_complete_io(); 226 227 teardown_test(); 228 } 229 230 static void 231 aborted_reset_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 232 { 233 enum spdk_bdev_io_status *status = cb_arg; 234 235 *status = success ? SPDK_BDEV_IO_STATUS_SUCCESS : SPDK_BDEV_IO_STATUS_FAILED; 236 spdk_bdev_free_io(bdev_io); 237 } 238 239 static void 240 aborted_reset(void) 241 { 242 struct spdk_io_channel *io_ch[2]; 243 enum spdk_bdev_io_status status1, status2; 244 245 setup_test(); 246 247 set_thread(0); 248 io_ch[0] = spdk_bdev_get_io_channel(g_desc); 249 CU_ASSERT(io_ch[0] != NULL); 250 spdk_bdev_reset(g_desc, io_ch[0], aborted_reset_done, &status1); 251 poll_threads(); 252 CU_ASSERT(g_bdev.bdev.reset_in_progress != NULL); 253 254 /* 255 * First reset has been submitted on ch0. Now submit a second 256 * reset on ch1 which will get queued since there is already a 257 * reset in progress. 258 */ 259 set_thread(1); 260 io_ch[1] = spdk_bdev_get_io_channel(g_desc); 261 CU_ASSERT(io_ch[1] != NULL); 262 spdk_bdev_reset(g_desc, io_ch[1], aborted_reset_done, &status2); 263 poll_threads(); 264 CU_ASSERT(g_bdev.bdev.reset_in_progress != NULL); 265 266 /* 267 * Now destroy ch1. This will abort the queued reset. Check that 268 * the second reset was completed with failed status. Also check 269 * that bdev->reset_in_progress != NULL, since the original reset 270 * has not been completed yet. This ensures that the bdev code is 271 * correctly noticing that the failed reset is *not* the one that 272 * had been submitted to the bdev module. 273 */ 274 set_thread(1); 275 spdk_put_io_channel(io_ch[1]); 276 poll_threads(); 277 CU_ASSERT(status2 == SPDK_BDEV_IO_STATUS_FAILED); 278 CU_ASSERT(g_bdev.bdev.reset_in_progress != NULL); 279 280 /* 281 * Now complete the first reset, verify that it completed with SUCCESS 282 * status and that bdev->reset_in_progress is also set back to NULL. 283 */ 284 set_thread(0); 285 spdk_put_io_channel(io_ch[0]); 286 stub_complete_io(); 287 poll_threads(); 288 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS); 289 CU_ASSERT(g_bdev.bdev.reset_in_progress == NULL); 290 291 teardown_test(); 292 } 293 294 static void 295 io_during_reset_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 296 { 297 enum spdk_bdev_io_status *status = cb_arg; 298 299 *status = success ? SPDK_BDEV_IO_STATUS_SUCCESS : SPDK_BDEV_IO_STATUS_FAILED; 300 spdk_bdev_free_io(bdev_io); 301 } 302 303 static void 304 io_during_reset(void) 305 { 306 struct spdk_io_channel *io_ch[2]; 307 struct spdk_bdev_channel *bdev_ch[2]; 308 enum spdk_bdev_io_status status0, status1, status_reset; 309 int rc; 310 311 setup_test(); 312 313 /* 314 * First test normal case - submit an I/O on each of two channels (with no resets) 315 * and verify they complete successfully. 316 */ 317 set_thread(0); 318 io_ch[0] = spdk_bdev_get_io_channel(g_desc); 319 bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]); 320 CU_ASSERT(bdev_ch[0]->flags == 0); 321 status0 = SPDK_BDEV_IO_STATUS_PENDING; 322 rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_reset_done, &status0); 323 CU_ASSERT(rc == 0); 324 325 set_thread(1); 326 io_ch[1] = spdk_bdev_get_io_channel(g_desc); 327 bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]); 328 CU_ASSERT(bdev_ch[1]->flags == 0); 329 status1 = SPDK_BDEV_IO_STATUS_PENDING; 330 rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_reset_done, &status1); 331 CU_ASSERT(rc == 0); 332 333 poll_threads(); 334 CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_PENDING); 335 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_PENDING); 336 337 set_thread(0); 338 stub_complete_io(); 339 CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_SUCCESS); 340 341 set_thread(1); 342 stub_complete_io(); 343 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS); 344 345 /* 346 * Now submit a reset, and leave it pending while we submit I?O on two different 347 * channels. These I/O should be failed by the bdev layer since the reset is in 348 * progress. 349 */ 350 set_thread(0); 351 status_reset = SPDK_BDEV_IO_STATUS_PENDING; 352 rc = spdk_bdev_reset(g_desc, io_ch[0], io_during_reset_done, &status_reset); 353 CU_ASSERT(rc == 0); 354 355 CU_ASSERT(bdev_ch[0]->flags == 0); 356 CU_ASSERT(bdev_ch[1]->flags == 0); 357 poll_threads(); 358 CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_RESET_IN_PROGRESS); 359 CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_RESET_IN_PROGRESS); 360 361 set_thread(0); 362 status0 = SPDK_BDEV_IO_STATUS_PENDING; 363 rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_reset_done, &status0); 364 CU_ASSERT(rc == 0); 365 366 set_thread(1); 367 status1 = SPDK_BDEV_IO_STATUS_PENDING; 368 rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_reset_done, &status1); 369 CU_ASSERT(rc == 0); 370 371 /* 372 * A reset is in progress so these read I/O should complete with failure. Note that we 373 * need to poll_threads() since I/O completed inline have their completion deferred. 374 */ 375 poll_threads(); 376 CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_PENDING); 377 CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_FAILED); 378 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_FAILED); 379 380 set_thread(0); 381 stub_complete_io(); 382 spdk_put_io_channel(io_ch[0]); 383 set_thread(1); 384 spdk_put_io_channel(io_ch[1]); 385 poll_threads(); 386 CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_SUCCESS); 387 388 teardown_test(); 389 } 390 391 int 392 main(int argc, char **argv) 393 { 394 CU_pSuite suite = NULL; 395 unsigned int num_failures; 396 397 if (CU_initialize_registry() != CUE_SUCCESS) { 398 return CU_get_error(); 399 } 400 401 suite = CU_add_suite("bdev", NULL, NULL); 402 if (suite == NULL) { 403 CU_cleanup_registry(); 404 return CU_get_error(); 405 } 406 407 if ( 408 CU_add_test(suite, "basic", basic) == NULL || 409 CU_add_test(suite, "put_channel_during_reset", put_channel_during_reset) == NULL || 410 CU_add_test(suite, "aborted_reset", aborted_reset) == NULL || 411 CU_add_test(suite, "io_during_reset", io_during_reset) == NULL 412 ) { 413 CU_cleanup_registry(); 414 return CU_get_error(); 415 } 416 417 CU_basic_set_mode(CU_BRM_VERBOSE); 418 CU_basic_run_tests(); 419 num_failures = CU_get_number_of_failures(); 420 CU_cleanup_registry(); 421 return num_failures; 422 } 423