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 "common/lib/test_env.c" 37 #include "common/lib/ut_multithread.c" 38 #include "unit/lib/json_mock.c" 39 40 /* HACK: disable VTune integration so the unit test doesn't need VTune headers and libs to build */ 41 #undef SPDK_CONFIG_VTUNE 42 43 #include "bdev/bdev.c" 44 45 #define BDEV_UT_NUM_THREADS 3 46 47 DEFINE_STUB_V(spdk_scsi_nvme_translate, (const struct spdk_bdev_io *bdev_io, 48 int *sc, int *sk, int *asc, int *ascq)); 49 50 /* Return NULL to test hardcoded defaults. */ 51 struct spdk_conf_section * 52 spdk_conf_find_section(struct spdk_conf *cp, const char *name) 53 { 54 return NULL; 55 } 56 57 /* Return NULL to test hardcoded defaults. */ 58 char * 59 spdk_conf_section_get_nmval(struct spdk_conf_section *sp, const char *key, int idx1, int idx2) 60 { 61 return NULL; 62 } 63 64 struct ut_bdev { 65 struct spdk_bdev bdev; 66 void *io_target; 67 }; 68 69 struct ut_bdev_channel { 70 TAILQ_HEAD(, spdk_bdev_io) outstanding_io; 71 uint32_t outstanding_cnt; 72 uint32_t avail_cnt; 73 }; 74 75 int g_io_device; 76 struct ut_bdev g_bdev; 77 struct spdk_bdev_desc *g_desc; 78 bool g_teardown_done = false; 79 bool g_get_io_channel = true; 80 bool g_create_ch = true; 81 bool g_init_complete_called = false; 82 83 static int 84 stub_create_ch(void *io_device, void *ctx_buf) 85 { 86 struct ut_bdev_channel *ch = ctx_buf; 87 88 if (g_create_ch == false) { 89 return -1; 90 } 91 92 TAILQ_INIT(&ch->outstanding_io); 93 ch->outstanding_cnt = 0; 94 /* 95 * When avail gets to 0, the submit_request function will return ENOMEM. 96 * Most tests to not want ENOMEM to occur, so by default set this to a 97 * big value that won't get hit. The ENOMEM tests can then override this 98 * value to something much smaller to induce ENOMEM conditions. 99 */ 100 ch->avail_cnt = 2048; 101 return 0; 102 } 103 104 static void 105 stub_destroy_ch(void *io_device, void *ctx_buf) 106 { 107 } 108 109 static struct spdk_io_channel * 110 stub_get_io_channel(void *ctx) 111 { 112 struct ut_bdev *ut_bdev = ctx; 113 114 if (g_get_io_channel == true) { 115 return spdk_get_io_channel(ut_bdev->io_target); 116 } else { 117 return NULL; 118 } 119 } 120 121 static int 122 stub_destruct(void *ctx) 123 { 124 return 0; 125 } 126 127 static void 128 stub_submit_request(struct spdk_io_channel *_ch, struct spdk_bdev_io *bdev_io) 129 { 130 struct ut_bdev_channel *ch = spdk_io_channel_get_ctx(_ch); 131 132 if (bdev_io->type == SPDK_BDEV_IO_TYPE_RESET) { 133 struct spdk_bdev_io *io; 134 135 while (!TAILQ_EMPTY(&ch->outstanding_io)) { 136 io = TAILQ_FIRST(&ch->outstanding_io); 137 TAILQ_REMOVE(&ch->outstanding_io, io, module_link); 138 ch->outstanding_cnt--; 139 spdk_bdev_io_complete(io, SPDK_BDEV_IO_STATUS_FAILED); 140 ch->avail_cnt++; 141 } 142 } 143 144 if (ch->avail_cnt > 0) { 145 TAILQ_INSERT_TAIL(&ch->outstanding_io, bdev_io, module_link); 146 ch->outstanding_cnt++; 147 ch->avail_cnt--; 148 } else { 149 spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_NOMEM); 150 } 151 } 152 153 static uint32_t 154 stub_complete_io(void *io_target, uint32_t num_to_complete) 155 { 156 struct spdk_io_channel *_ch = spdk_get_io_channel(io_target); 157 struct ut_bdev_channel *ch = spdk_io_channel_get_ctx(_ch); 158 struct spdk_bdev_io *io; 159 bool complete_all = (num_to_complete == 0); 160 uint32_t num_completed = 0; 161 162 while (complete_all || num_completed < num_to_complete) { 163 if (TAILQ_EMPTY(&ch->outstanding_io)) { 164 break; 165 } 166 io = TAILQ_FIRST(&ch->outstanding_io); 167 TAILQ_REMOVE(&ch->outstanding_io, io, module_link); 168 ch->outstanding_cnt--; 169 spdk_bdev_io_complete(io, SPDK_BDEV_IO_STATUS_SUCCESS); 170 ch->avail_cnt++; 171 num_completed++; 172 } 173 174 spdk_put_io_channel(_ch); 175 return num_completed; 176 } 177 178 static struct spdk_bdev_fn_table fn_table = { 179 .get_io_channel = stub_get_io_channel, 180 .destruct = stub_destruct, 181 .submit_request = stub_submit_request, 182 }; 183 184 static int 185 module_init(void) 186 { 187 return 0; 188 } 189 190 static void 191 module_fini(void) 192 { 193 } 194 195 static void 196 init_complete(void) 197 { 198 g_init_complete_called = true; 199 } 200 201 struct spdk_bdev_module bdev_ut_if = { 202 .name = "bdev_ut", 203 .module_init = module_init, 204 .module_fini = module_fini, 205 .init_complete = init_complete, 206 }; 207 208 SPDK_BDEV_MODULE_REGISTER(&bdev_ut_if) 209 210 static void 211 register_bdev(struct ut_bdev *ut_bdev, char *name, void *io_target) 212 { 213 memset(ut_bdev, 0, sizeof(*ut_bdev)); 214 215 ut_bdev->io_target = io_target; 216 ut_bdev->bdev.ctxt = ut_bdev; 217 ut_bdev->bdev.name = name; 218 ut_bdev->bdev.fn_table = &fn_table; 219 ut_bdev->bdev.module = &bdev_ut_if; 220 ut_bdev->bdev.blocklen = 4096; 221 ut_bdev->bdev.blockcnt = 1024; 222 223 spdk_bdev_register(&ut_bdev->bdev); 224 } 225 226 static void 227 unregister_bdev(struct ut_bdev *ut_bdev) 228 { 229 /* Handle any deferred messages. */ 230 poll_threads(); 231 spdk_bdev_unregister(&ut_bdev->bdev, NULL, NULL); 232 } 233 234 static void 235 bdev_init_cb(void *done, int rc) 236 { 237 CU_ASSERT(rc == 0); 238 *(bool *)done = true; 239 } 240 241 static void 242 setup_test(void) 243 { 244 bool done = false; 245 246 allocate_threads(BDEV_UT_NUM_THREADS); 247 spdk_bdev_initialize(bdev_init_cb, &done); 248 spdk_io_device_register(&g_io_device, stub_create_ch, stub_destroy_ch, 249 sizeof(struct ut_bdev_channel)); 250 register_bdev(&g_bdev, "ut_bdev", &g_io_device); 251 spdk_bdev_open(&g_bdev.bdev, true, NULL, NULL, &g_desc); 252 } 253 254 static void 255 finish_cb(void *cb_arg) 256 { 257 g_teardown_done = true; 258 } 259 260 static void 261 teardown_test(void) 262 { 263 g_teardown_done = false; 264 spdk_bdev_close(g_desc); 265 g_desc = NULL; 266 unregister_bdev(&g_bdev); 267 spdk_io_device_unregister(&g_io_device, NULL); 268 spdk_bdev_finish(finish_cb, NULL); 269 poll_threads(); 270 memset(&g_bdev, 0, sizeof(g_bdev)); 271 CU_ASSERT(g_teardown_done == true); 272 g_teardown_done = false; 273 free_threads(); 274 } 275 276 static uint32_t 277 bdev_io_tailq_cnt(bdev_io_tailq_t *tailq) 278 { 279 struct spdk_bdev_io *io; 280 uint32_t cnt = 0; 281 282 TAILQ_FOREACH(io, tailq, link) { 283 cnt++; 284 } 285 286 return cnt; 287 } 288 289 static void 290 basic(void) 291 { 292 g_init_complete_called = false; 293 setup_test(); 294 CU_ASSERT(g_init_complete_called == true); 295 296 set_thread(0); 297 298 g_get_io_channel = false; 299 g_ut_threads[0].ch = spdk_bdev_get_io_channel(g_desc); 300 CU_ASSERT(g_ut_threads[0].ch == NULL); 301 302 g_get_io_channel = true; 303 g_create_ch = false; 304 g_ut_threads[0].ch = spdk_bdev_get_io_channel(g_desc); 305 CU_ASSERT(g_ut_threads[0].ch == NULL); 306 307 g_get_io_channel = true; 308 g_create_ch = true; 309 g_ut_threads[0].ch = spdk_bdev_get_io_channel(g_desc); 310 CU_ASSERT(g_ut_threads[0].ch != NULL); 311 spdk_put_io_channel(g_ut_threads[0].ch); 312 313 teardown_test(); 314 } 315 316 static int 317 poller_run_done(void *ctx) 318 { 319 bool *poller_run = ctx; 320 321 *poller_run = true; 322 323 return -1; 324 } 325 326 static int 327 poller_run_times_done(void *ctx) 328 { 329 int *poller_run_times = ctx; 330 331 (*poller_run_times)++; 332 333 return -1; 334 } 335 336 static void 337 basic_poller(void) 338 { 339 struct spdk_poller *poller = NULL; 340 bool poller_run = false; 341 int poller_run_times = 0; 342 343 setup_test(); 344 345 set_thread(0); 346 reset_time(); 347 /* Register a poller with no-wait time and test execution */ 348 poller = spdk_poller_register(poller_run_done, &poller_run, 0); 349 CU_ASSERT(poller != NULL); 350 351 poll_threads(); 352 CU_ASSERT(poller_run == true); 353 354 spdk_poller_unregister(&poller); 355 CU_ASSERT(poller == NULL); 356 357 /* Register a poller with 1000us wait time and test single execution */ 358 poller_run = false; 359 poller = spdk_poller_register(poller_run_done, &poller_run, 1000); 360 CU_ASSERT(poller != NULL); 361 362 poll_threads(); 363 CU_ASSERT(poller_run == false); 364 365 increment_time(1000); 366 poll_threads(); 367 CU_ASSERT(poller_run == true); 368 369 reset_time(); 370 poller_run = false; 371 poll_threads(); 372 CU_ASSERT(poller_run == false); 373 374 increment_time(1000); 375 poll_threads(); 376 CU_ASSERT(poller_run == true); 377 378 spdk_poller_unregister(&poller); 379 CU_ASSERT(poller == NULL); 380 381 reset_time(); 382 /* Register a poller with 1000us wait time and test multiple execution */ 383 poller = spdk_poller_register(poller_run_times_done, &poller_run_times, 1000); 384 CU_ASSERT(poller != NULL); 385 386 poll_threads(); 387 CU_ASSERT(poller_run_times == 0); 388 389 increment_time(1000); 390 poll_threads(); 391 CU_ASSERT(poller_run_times == 1); 392 393 poller_run_times = 0; 394 increment_time(2000); 395 poll_threads(); 396 CU_ASSERT(poller_run_times == 2); 397 398 spdk_poller_unregister(&poller); 399 CU_ASSERT(poller == NULL); 400 401 teardown_test(); 402 } 403 404 static void 405 reset_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 406 { 407 bool *done = cb_arg; 408 409 CU_ASSERT(success == true); 410 *done = true; 411 spdk_bdev_free_io(bdev_io); 412 } 413 414 static void 415 put_channel_during_reset(void) 416 { 417 struct spdk_io_channel *io_ch; 418 bool done = false; 419 420 setup_test(); 421 422 set_thread(0); 423 io_ch = spdk_bdev_get_io_channel(g_desc); 424 CU_ASSERT(io_ch != NULL); 425 426 /* 427 * Start a reset, but then put the I/O channel before 428 * the deferred messages for the reset get a chance to 429 * execute. 430 */ 431 spdk_bdev_reset(g_desc, io_ch, reset_done, &done); 432 spdk_put_io_channel(io_ch); 433 poll_threads(); 434 stub_complete_io(g_bdev.io_target, 0); 435 436 teardown_test(); 437 } 438 439 static void 440 aborted_reset_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 441 { 442 enum spdk_bdev_io_status *status = cb_arg; 443 444 *status = success ? SPDK_BDEV_IO_STATUS_SUCCESS : SPDK_BDEV_IO_STATUS_FAILED; 445 spdk_bdev_free_io(bdev_io); 446 } 447 448 static void 449 aborted_reset(void) 450 { 451 struct spdk_io_channel *io_ch[2]; 452 enum spdk_bdev_io_status status1, status2; 453 454 setup_test(); 455 456 set_thread(0); 457 io_ch[0] = spdk_bdev_get_io_channel(g_desc); 458 CU_ASSERT(io_ch[0] != NULL); 459 spdk_bdev_reset(g_desc, io_ch[0], aborted_reset_done, &status1); 460 poll_threads(); 461 CU_ASSERT(g_bdev.bdev.reset_in_progress != NULL); 462 463 /* 464 * First reset has been submitted on ch0. Now submit a second 465 * reset on ch1 which will get queued since there is already a 466 * reset in progress. 467 */ 468 set_thread(1); 469 io_ch[1] = spdk_bdev_get_io_channel(g_desc); 470 CU_ASSERT(io_ch[1] != NULL); 471 spdk_bdev_reset(g_desc, io_ch[1], aborted_reset_done, &status2); 472 poll_threads(); 473 CU_ASSERT(g_bdev.bdev.reset_in_progress != NULL); 474 475 /* 476 * Now destroy ch1. This will abort the queued reset. Check that 477 * the second reset was completed with failed status. Also check 478 * that bdev->reset_in_progress != NULL, since the original reset 479 * has not been completed yet. This ensures that the bdev code is 480 * correctly noticing that the failed reset is *not* the one that 481 * had been submitted to the bdev module. 482 */ 483 set_thread(1); 484 spdk_put_io_channel(io_ch[1]); 485 poll_threads(); 486 CU_ASSERT(status2 == SPDK_BDEV_IO_STATUS_FAILED); 487 CU_ASSERT(g_bdev.bdev.reset_in_progress != NULL); 488 489 /* 490 * Now complete the first reset, verify that it completed with SUCCESS 491 * status and that bdev->reset_in_progress is also set back to NULL. 492 */ 493 set_thread(0); 494 spdk_put_io_channel(io_ch[0]); 495 stub_complete_io(g_bdev.io_target, 0); 496 poll_threads(); 497 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS); 498 CU_ASSERT(g_bdev.bdev.reset_in_progress == NULL); 499 500 teardown_test(); 501 } 502 503 static void 504 io_during_io_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 505 { 506 enum spdk_bdev_io_status *status = cb_arg; 507 508 *status = success ? SPDK_BDEV_IO_STATUS_SUCCESS : SPDK_BDEV_IO_STATUS_FAILED; 509 spdk_bdev_free_io(bdev_io); 510 } 511 512 static void 513 io_during_reset(void) 514 { 515 struct spdk_io_channel *io_ch[2]; 516 struct spdk_bdev_channel *bdev_ch[2]; 517 enum spdk_bdev_io_status status0, status1, status_reset; 518 int rc; 519 520 setup_test(); 521 522 /* 523 * First test normal case - submit an I/O on each of two channels (with no resets) 524 * and verify they complete successfully. 525 */ 526 set_thread(0); 527 io_ch[0] = spdk_bdev_get_io_channel(g_desc); 528 bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]); 529 CU_ASSERT(bdev_ch[0]->flags == 0); 530 status0 = SPDK_BDEV_IO_STATUS_PENDING; 531 rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status0); 532 CU_ASSERT(rc == 0); 533 534 set_thread(1); 535 io_ch[1] = spdk_bdev_get_io_channel(g_desc); 536 bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]); 537 CU_ASSERT(bdev_ch[1]->flags == 0); 538 status1 = SPDK_BDEV_IO_STATUS_PENDING; 539 rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status1); 540 CU_ASSERT(rc == 0); 541 542 poll_threads(); 543 CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_PENDING); 544 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_PENDING); 545 546 set_thread(0); 547 stub_complete_io(g_bdev.io_target, 0); 548 CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_SUCCESS); 549 550 set_thread(1); 551 stub_complete_io(g_bdev.io_target, 0); 552 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS); 553 554 /* 555 * Now submit a reset, and leave it pending while we submit I/O on two different 556 * channels. These I/O should be failed by the bdev layer since the reset is in 557 * progress. 558 */ 559 set_thread(0); 560 status_reset = SPDK_BDEV_IO_STATUS_PENDING; 561 rc = spdk_bdev_reset(g_desc, io_ch[0], io_during_io_done, &status_reset); 562 CU_ASSERT(rc == 0); 563 564 CU_ASSERT(bdev_ch[0]->flags == 0); 565 CU_ASSERT(bdev_ch[1]->flags == 0); 566 poll_threads(); 567 CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_RESET_IN_PROGRESS); 568 CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_RESET_IN_PROGRESS); 569 570 set_thread(0); 571 status0 = SPDK_BDEV_IO_STATUS_PENDING; 572 rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status0); 573 CU_ASSERT(rc == 0); 574 575 set_thread(1); 576 status1 = SPDK_BDEV_IO_STATUS_PENDING; 577 rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status1); 578 CU_ASSERT(rc == 0); 579 580 /* 581 * A reset is in progress so these read I/O should complete with failure. Note that we 582 * need to poll_threads() since I/O completed inline have their completion deferred. 583 */ 584 poll_threads(); 585 CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_PENDING); 586 CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_FAILED); 587 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_FAILED); 588 589 /* 590 * Complete the reset 591 */ 592 set_thread(0); 593 stub_complete_io(g_bdev.io_target, 0); 594 595 /* 596 * Only poll thread 0. We should not get a completion. 597 */ 598 poll_thread(0); 599 CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_PENDING); 600 601 /* 602 * Poll both thread 0 and 1 so the messages can propagate and we 603 * get a completion. 604 */ 605 poll_threads(); 606 CU_ASSERT(status_reset == SPDK_BDEV_IO_STATUS_SUCCESS); 607 608 spdk_put_io_channel(io_ch[0]); 609 set_thread(1); 610 spdk_put_io_channel(io_ch[1]); 611 poll_threads(); 612 613 teardown_test(); 614 } 615 616 static void 617 basic_qos(void) 618 { 619 struct spdk_io_channel *io_ch[2]; 620 struct spdk_bdev_channel *bdev_ch[2]; 621 struct spdk_bdev *bdev; 622 enum spdk_bdev_io_status status; 623 int rc; 624 625 setup_test(); 626 627 /* Enable QoS */ 628 bdev = &g_bdev.bdev; 629 bdev->qos = calloc(1, sizeof(*bdev->qos)); 630 SPDK_CU_ASSERT_FATAL(bdev->qos != NULL); 631 TAILQ_INIT(&bdev->qos->queued); 632 bdev->qos->rate_limit = 2000; /* 2 I/O per millisecond */ 633 634 g_get_io_channel = true; 635 636 set_thread(0); 637 io_ch[0] = spdk_bdev_get_io_channel(g_desc); 638 bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]); 639 CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_QOS_ENABLED); 640 641 set_thread(1); 642 io_ch[1] = spdk_bdev_get_io_channel(g_desc); 643 bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]); 644 CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_QOS_ENABLED); 645 646 /* 647 * Send an I/O on thread 0, which is where the QoS thread is running. 648 */ 649 set_thread(0); 650 status = SPDK_BDEV_IO_STATUS_PENDING; 651 rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status); 652 CU_ASSERT(rc == 0); 653 CU_ASSERT(status == SPDK_BDEV_IO_STATUS_PENDING); 654 poll_threads(); 655 stub_complete_io(g_bdev.io_target, 0); 656 poll_threads(); 657 CU_ASSERT(status == SPDK_BDEV_IO_STATUS_SUCCESS); 658 659 /* Send an I/O on thread 1. The QoS thread is not running here. */ 660 status = SPDK_BDEV_IO_STATUS_PENDING; 661 set_thread(1); 662 rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status); 663 CU_ASSERT(rc == 0); 664 CU_ASSERT(status == SPDK_BDEV_IO_STATUS_PENDING); 665 poll_threads(); 666 /* Complete I/O on thread 1. This should not complete the I/O we submitted */ 667 stub_complete_io(g_bdev.io_target, 0); 668 poll_threads(); 669 CU_ASSERT(status == SPDK_BDEV_IO_STATUS_PENDING); 670 /* Now complete I/O on thread 0 */ 671 set_thread(0); 672 poll_threads(); 673 stub_complete_io(g_bdev.io_target, 0); 674 poll_threads(); 675 CU_ASSERT(status == SPDK_BDEV_IO_STATUS_SUCCESS); 676 677 /* Tear down the channels */ 678 set_thread(0); 679 spdk_put_io_channel(io_ch[0]); 680 set_thread(1); 681 spdk_put_io_channel(io_ch[1]); 682 poll_threads(); 683 set_thread(0); 684 685 /* Close the descriptor, which should stop the qos channel */ 686 spdk_bdev_close(g_desc); 687 poll_threads(); 688 CU_ASSERT(bdev->qos->ch == NULL); 689 690 spdk_bdev_open(bdev, true, NULL, NULL, &g_desc); 691 692 /* Create the channels in reverse order. */ 693 set_thread(1); 694 io_ch[1] = spdk_bdev_get_io_channel(g_desc); 695 bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]); 696 CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_QOS_ENABLED); 697 698 set_thread(0); 699 io_ch[0] = spdk_bdev_get_io_channel(g_desc); 700 bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]); 701 CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_QOS_ENABLED); 702 703 /* Confirm that the qos thread is now thread 1 */ 704 CU_ASSERT(bdev->qos->ch == bdev_ch[1]); 705 706 /* Tear down the channels */ 707 set_thread(0); 708 spdk_put_io_channel(io_ch[0]); 709 set_thread(1); 710 spdk_put_io_channel(io_ch[1]); 711 poll_threads(); 712 713 set_thread(0); 714 715 teardown_test(); 716 } 717 718 static void 719 io_during_qos_queue(void) 720 { 721 struct spdk_io_channel *io_ch[2]; 722 struct spdk_bdev_channel *bdev_ch[2]; 723 struct spdk_bdev *bdev; 724 enum spdk_bdev_io_status status0, status1; 725 int rc; 726 727 setup_test(); 728 reset_time(); 729 730 /* Enable QoS */ 731 bdev = &g_bdev.bdev; 732 bdev->qos = calloc(1, sizeof(*bdev->qos)); 733 SPDK_CU_ASSERT_FATAL(bdev->qos != NULL); 734 TAILQ_INIT(&bdev->qos->queued); 735 bdev->qos->rate_limit = 1000; /* 1000 I/O per second, or 1 per millisecond */ 736 737 g_get_io_channel = true; 738 739 /* Create channels */ 740 set_thread(0); 741 io_ch[0] = spdk_bdev_get_io_channel(g_desc); 742 bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]); 743 CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_QOS_ENABLED); 744 745 set_thread(1); 746 io_ch[1] = spdk_bdev_get_io_channel(g_desc); 747 bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]); 748 CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_QOS_ENABLED); 749 750 /* Send two I/O */ 751 status1 = SPDK_BDEV_IO_STATUS_PENDING; 752 rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status1); 753 CU_ASSERT(rc == 0); 754 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_PENDING); 755 set_thread(0); 756 status0 = SPDK_BDEV_IO_STATUS_PENDING; 757 rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status0); 758 CU_ASSERT(rc == 0); 759 CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_PENDING); 760 761 /* Complete any I/O that arrived at the disk */ 762 poll_threads(); 763 set_thread(1); 764 stub_complete_io(g_bdev.io_target, 0); 765 set_thread(0); 766 stub_complete_io(g_bdev.io_target, 0); 767 poll_threads(); 768 769 /* Only one of the I/O should complete. (logical XOR) */ 770 if (status0 == SPDK_BDEV_IO_STATUS_SUCCESS) { 771 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_PENDING); 772 } else { 773 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS); 774 } 775 776 /* Advance in time by a millisecond */ 777 increment_time(1000); 778 779 /* Complete more I/O */ 780 poll_threads(); 781 set_thread(1); 782 stub_complete_io(g_bdev.io_target, 0); 783 set_thread(0); 784 stub_complete_io(g_bdev.io_target, 0); 785 poll_threads(); 786 787 /* Now the second I/O should be done */ 788 CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_SUCCESS); 789 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_SUCCESS); 790 791 /* Tear down the channels */ 792 set_thread(1); 793 spdk_put_io_channel(io_ch[1]); 794 set_thread(0); 795 spdk_put_io_channel(io_ch[0]); 796 poll_threads(); 797 798 teardown_test(); 799 } 800 801 static void 802 io_during_qos_reset(void) 803 { 804 struct spdk_io_channel *io_ch[2]; 805 struct spdk_bdev_channel *bdev_ch[2]; 806 struct spdk_bdev *bdev; 807 enum spdk_bdev_io_status status0, status1, reset_status; 808 int rc; 809 810 setup_test(); 811 reset_time(); 812 813 /* Enable QoS */ 814 bdev = &g_bdev.bdev; 815 bdev->qos = calloc(1, sizeof(*bdev->qos)); 816 SPDK_CU_ASSERT_FATAL(bdev->qos != NULL); 817 TAILQ_INIT(&bdev->qos->queued); 818 bdev->qos->rate_limit = 1000; /* 1000 I/O per second, or 1 per millisecond */ 819 820 g_get_io_channel = true; 821 822 /* Create channels */ 823 set_thread(0); 824 io_ch[0] = spdk_bdev_get_io_channel(g_desc); 825 bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]); 826 CU_ASSERT(bdev_ch[0]->flags == BDEV_CH_QOS_ENABLED); 827 828 set_thread(1); 829 io_ch[1] = spdk_bdev_get_io_channel(g_desc); 830 bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]); 831 CU_ASSERT(bdev_ch[1]->flags == BDEV_CH_QOS_ENABLED); 832 833 /* Send two I/O. One of these gets queued by QoS. The other is sitting at the disk. */ 834 status1 = SPDK_BDEV_IO_STATUS_PENDING; 835 rc = spdk_bdev_read_blocks(g_desc, io_ch[1], NULL, 0, 1, io_during_io_done, &status1); 836 CU_ASSERT(rc == 0); 837 set_thread(0); 838 status0 = SPDK_BDEV_IO_STATUS_PENDING; 839 rc = spdk_bdev_read_blocks(g_desc, io_ch[0], NULL, 0, 1, io_during_io_done, &status0); 840 CU_ASSERT(rc == 0); 841 842 poll_threads(); 843 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_PENDING); 844 CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_PENDING); 845 846 /* Reset the bdev. */ 847 reset_status = SPDK_BDEV_IO_STATUS_PENDING; 848 rc = spdk_bdev_reset(g_desc, io_ch[0], io_during_io_done, &reset_status); 849 CU_ASSERT(rc == 0); 850 851 /* Complete any I/O that arrived at the disk */ 852 poll_threads(); 853 set_thread(1); 854 stub_complete_io(g_bdev.io_target, 0); 855 set_thread(0); 856 stub_complete_io(g_bdev.io_target, 0); 857 poll_threads(); 858 859 CU_ASSERT(reset_status == SPDK_BDEV_IO_STATUS_SUCCESS); 860 CU_ASSERT(status0 == SPDK_BDEV_IO_STATUS_FAILED); 861 CU_ASSERT(status1 == SPDK_BDEV_IO_STATUS_FAILED); 862 863 /* Tear down the channels */ 864 set_thread(1); 865 spdk_put_io_channel(io_ch[1]); 866 set_thread(0); 867 spdk_put_io_channel(io_ch[0]); 868 poll_threads(); 869 870 teardown_test(); 871 } 872 873 static void 874 enomem_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg) 875 { 876 enum spdk_bdev_io_status *status = cb_arg; 877 878 *status = success ? SPDK_BDEV_IO_STATUS_SUCCESS : SPDK_BDEV_IO_STATUS_FAILED; 879 spdk_bdev_free_io(bdev_io); 880 } 881 882 static void 883 enomem(void) 884 { 885 struct spdk_io_channel *io_ch; 886 struct spdk_bdev_channel *bdev_ch; 887 struct spdk_bdev_shared_resource *shared_resource; 888 struct ut_bdev_channel *ut_ch; 889 const uint32_t IO_ARRAY_SIZE = 64; 890 const uint32_t AVAIL = 20; 891 enum spdk_bdev_io_status status[IO_ARRAY_SIZE], status_reset; 892 uint32_t nomem_cnt, i; 893 struct spdk_bdev_io *first_io; 894 int rc; 895 896 setup_test(); 897 898 set_thread(0); 899 io_ch = spdk_bdev_get_io_channel(g_desc); 900 bdev_ch = spdk_io_channel_get_ctx(io_ch); 901 shared_resource = bdev_ch->shared_resource; 902 ut_ch = spdk_io_channel_get_ctx(bdev_ch->channel); 903 ut_ch->avail_cnt = AVAIL; 904 905 /* First submit a number of IOs equal to what the channel can support. */ 906 for (i = 0; i < AVAIL; i++) { 907 status[i] = SPDK_BDEV_IO_STATUS_PENDING; 908 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[i]); 909 CU_ASSERT(rc == 0); 910 } 911 CU_ASSERT(TAILQ_EMPTY(&shared_resource->nomem_io)); 912 913 /* 914 * Next, submit one additional I/O. This one should fail with ENOMEM and then go onto 915 * the enomem_io list. 916 */ 917 status[AVAIL] = SPDK_BDEV_IO_STATUS_PENDING; 918 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[AVAIL]); 919 CU_ASSERT(rc == 0); 920 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&shared_resource->nomem_io)); 921 first_io = TAILQ_FIRST(&shared_resource->nomem_io); 922 923 /* 924 * Now submit a bunch more I/O. These should all fail with ENOMEM and get queued behind 925 * the first_io above. 926 */ 927 for (i = AVAIL + 1; i < IO_ARRAY_SIZE; i++) { 928 status[i] = SPDK_BDEV_IO_STATUS_PENDING; 929 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[i]); 930 CU_ASSERT(rc == 0); 931 } 932 933 /* Assert that first_io is still at the head of the list. */ 934 CU_ASSERT(TAILQ_FIRST(&shared_resource->nomem_io) == first_io); 935 CU_ASSERT(bdev_io_tailq_cnt(&shared_resource->nomem_io) == (IO_ARRAY_SIZE - AVAIL)); 936 nomem_cnt = bdev_io_tailq_cnt(&shared_resource->nomem_io); 937 CU_ASSERT(shared_resource->nomem_threshold == (AVAIL - NOMEM_THRESHOLD_COUNT)); 938 939 /* 940 * Complete 1 I/O only. The key check here is bdev_io_tailq_cnt - this should not have 941 * changed since completing just 1 I/O should not trigger retrying the queued nomem_io 942 * list. 943 */ 944 stub_complete_io(g_bdev.io_target, 1); 945 CU_ASSERT(bdev_io_tailq_cnt(&shared_resource->nomem_io) == nomem_cnt); 946 947 /* 948 * Complete enough I/O to hit the nomem_theshold. This should trigger retrying nomem_io, 949 * and we should see I/O get resubmitted to the test bdev module. 950 */ 951 stub_complete_io(g_bdev.io_target, NOMEM_THRESHOLD_COUNT - 1); 952 CU_ASSERT(bdev_io_tailq_cnt(&shared_resource->nomem_io) < nomem_cnt); 953 nomem_cnt = bdev_io_tailq_cnt(&shared_resource->nomem_io); 954 955 /* Complete 1 I/O only. This should not trigger retrying the queued nomem_io. */ 956 stub_complete_io(g_bdev.io_target, 1); 957 CU_ASSERT(bdev_io_tailq_cnt(&shared_resource->nomem_io) == nomem_cnt); 958 959 /* 960 * Send a reset and confirm that all I/O are completed, including the ones that 961 * were queued on the nomem_io list. 962 */ 963 status_reset = SPDK_BDEV_IO_STATUS_PENDING; 964 rc = spdk_bdev_reset(g_desc, io_ch, enomem_done, &status_reset); 965 poll_threads(); 966 CU_ASSERT(rc == 0); 967 /* This will complete the reset. */ 968 stub_complete_io(g_bdev.io_target, 0); 969 970 CU_ASSERT(bdev_io_tailq_cnt(&shared_resource->nomem_io) == 0); 971 CU_ASSERT(shared_resource->io_outstanding == 0); 972 973 spdk_put_io_channel(io_ch); 974 poll_threads(); 975 teardown_test(); 976 } 977 978 static void 979 enomem_multi_bdev(void) 980 { 981 struct spdk_io_channel *io_ch; 982 struct spdk_bdev_channel *bdev_ch; 983 struct spdk_bdev_shared_resource *shared_resource; 984 struct ut_bdev_channel *ut_ch; 985 const uint32_t IO_ARRAY_SIZE = 64; 986 const uint32_t AVAIL = 20; 987 enum spdk_bdev_io_status status[IO_ARRAY_SIZE]; 988 uint32_t i; 989 struct ut_bdev *second_bdev; 990 struct spdk_bdev_desc *second_desc; 991 struct spdk_bdev_channel *second_bdev_ch; 992 struct spdk_io_channel *second_ch; 993 int rc; 994 995 setup_test(); 996 997 /* Register second bdev with the same io_target */ 998 second_bdev = calloc(1, sizeof(*second_bdev)); 999 SPDK_CU_ASSERT_FATAL(second_bdev != NULL); 1000 register_bdev(second_bdev, "ut_bdev2", g_bdev.io_target); 1001 spdk_bdev_open(&second_bdev->bdev, true, NULL, NULL, &second_desc); 1002 1003 set_thread(0); 1004 io_ch = spdk_bdev_get_io_channel(g_desc); 1005 bdev_ch = spdk_io_channel_get_ctx(io_ch); 1006 shared_resource = bdev_ch->shared_resource; 1007 ut_ch = spdk_io_channel_get_ctx(bdev_ch->channel); 1008 ut_ch->avail_cnt = AVAIL; 1009 1010 second_ch = spdk_bdev_get_io_channel(second_desc); 1011 second_bdev_ch = spdk_io_channel_get_ctx(second_ch); 1012 SPDK_CU_ASSERT_FATAL(shared_resource == second_bdev_ch->shared_resource); 1013 1014 /* Saturate io_target through bdev A. */ 1015 for (i = 0; i < AVAIL; i++) { 1016 status[i] = SPDK_BDEV_IO_STATUS_PENDING; 1017 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[i]); 1018 CU_ASSERT(rc == 0); 1019 } 1020 CU_ASSERT(TAILQ_EMPTY(&shared_resource->nomem_io)); 1021 1022 /* 1023 * Now submit I/O through the second bdev. This should fail with ENOMEM 1024 * and then go onto the nomem_io list. 1025 */ 1026 status[AVAIL] = SPDK_BDEV_IO_STATUS_PENDING; 1027 rc = spdk_bdev_read_blocks(second_desc, second_ch, NULL, 0, 1, enomem_done, &status[AVAIL]); 1028 CU_ASSERT(rc == 0); 1029 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&shared_resource->nomem_io)); 1030 1031 /* Complete first bdev's I/O. This should retry sending second bdev's nomem_io */ 1032 stub_complete_io(g_bdev.io_target, AVAIL); 1033 1034 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&shared_resource->nomem_io)); 1035 CU_ASSERT(shared_resource->io_outstanding == 1); 1036 1037 /* Now complete our retried I/O */ 1038 stub_complete_io(g_bdev.io_target, 1); 1039 SPDK_CU_ASSERT_FATAL(shared_resource->io_outstanding == 0); 1040 1041 spdk_put_io_channel(io_ch); 1042 spdk_put_io_channel(second_ch); 1043 spdk_bdev_close(second_desc); 1044 unregister_bdev(second_bdev); 1045 poll_threads(); 1046 free(second_bdev); 1047 teardown_test(); 1048 } 1049 1050 1051 static void 1052 enomem_multi_io_target(void) 1053 { 1054 struct spdk_io_channel *io_ch; 1055 struct spdk_bdev_channel *bdev_ch; 1056 struct ut_bdev_channel *ut_ch; 1057 const uint32_t IO_ARRAY_SIZE = 64; 1058 const uint32_t AVAIL = 20; 1059 enum spdk_bdev_io_status status[IO_ARRAY_SIZE]; 1060 uint32_t i; 1061 int new_io_device; 1062 struct ut_bdev *second_bdev; 1063 struct spdk_bdev_desc *second_desc; 1064 struct spdk_bdev_channel *second_bdev_ch; 1065 struct spdk_io_channel *second_ch; 1066 int rc; 1067 1068 setup_test(); 1069 1070 /* Create new io_target and a second bdev using it */ 1071 spdk_io_device_register(&new_io_device, stub_create_ch, stub_destroy_ch, 1072 sizeof(struct ut_bdev_channel)); 1073 second_bdev = calloc(1, sizeof(*second_bdev)); 1074 SPDK_CU_ASSERT_FATAL(second_bdev != NULL); 1075 register_bdev(second_bdev, "ut_bdev2", &new_io_device); 1076 spdk_bdev_open(&second_bdev->bdev, true, NULL, NULL, &second_desc); 1077 1078 set_thread(0); 1079 io_ch = spdk_bdev_get_io_channel(g_desc); 1080 bdev_ch = spdk_io_channel_get_ctx(io_ch); 1081 ut_ch = spdk_io_channel_get_ctx(bdev_ch->channel); 1082 ut_ch->avail_cnt = AVAIL; 1083 1084 /* Different io_target should imply a different shared_resource */ 1085 second_ch = spdk_bdev_get_io_channel(second_desc); 1086 second_bdev_ch = spdk_io_channel_get_ctx(second_ch); 1087 SPDK_CU_ASSERT_FATAL(bdev_ch->shared_resource != second_bdev_ch->shared_resource); 1088 1089 /* Saturate io_target through bdev A. */ 1090 for (i = 0; i < AVAIL; i++) { 1091 status[i] = SPDK_BDEV_IO_STATUS_PENDING; 1092 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[i]); 1093 CU_ASSERT(rc == 0); 1094 } 1095 CU_ASSERT(TAILQ_EMPTY(&bdev_ch->shared_resource->nomem_io)); 1096 1097 /* Issue one more I/O to fill ENOMEM list. */ 1098 status[AVAIL] = SPDK_BDEV_IO_STATUS_PENDING; 1099 rc = spdk_bdev_read_blocks(g_desc, io_ch, NULL, 0, 1, enomem_done, &status[AVAIL]); 1100 CU_ASSERT(rc == 0); 1101 SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&bdev_ch->shared_resource->nomem_io)); 1102 1103 /* 1104 * Now submit I/O through the second bdev. This should go through and complete 1105 * successfully because we're using a different io_device underneath. 1106 */ 1107 status[AVAIL] = SPDK_BDEV_IO_STATUS_PENDING; 1108 rc = spdk_bdev_read_blocks(second_desc, second_ch, NULL, 0, 1, enomem_done, &status[AVAIL]); 1109 CU_ASSERT(rc == 0); 1110 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&second_bdev_ch->shared_resource->nomem_io)); 1111 stub_complete_io(second_bdev->io_target, 1); 1112 1113 /* Cleanup; Complete outstanding I/O. */ 1114 stub_complete_io(g_bdev.io_target, AVAIL); 1115 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&bdev_ch->shared_resource->nomem_io)); 1116 /* Complete the ENOMEM I/O */ 1117 stub_complete_io(g_bdev.io_target, 1); 1118 CU_ASSERT(bdev_ch->shared_resource->io_outstanding == 0); 1119 1120 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&bdev_ch->shared_resource->nomem_io)); 1121 CU_ASSERT(bdev_ch->shared_resource->io_outstanding == 0); 1122 spdk_put_io_channel(io_ch); 1123 spdk_put_io_channel(second_ch); 1124 spdk_bdev_close(second_desc); 1125 unregister_bdev(second_bdev); 1126 spdk_io_device_unregister(&new_io_device, NULL); 1127 poll_threads(); 1128 free(second_bdev); 1129 teardown_test(); 1130 } 1131 1132 static void 1133 qos_dynamic_enable_done(void *cb_arg, int status) 1134 { 1135 int *rc = cb_arg; 1136 *rc = status; 1137 } 1138 1139 static void 1140 qos_dynamic_enable(void) 1141 { 1142 struct spdk_io_channel *io_ch[2]; 1143 struct spdk_bdev_channel *bdev_ch[2]; 1144 struct spdk_bdev *bdev; 1145 int status, second_status; 1146 1147 setup_test(); 1148 reset_time(); 1149 1150 bdev = &g_bdev.bdev; 1151 1152 g_get_io_channel = true; 1153 1154 /* Create channels */ 1155 set_thread(0); 1156 io_ch[0] = spdk_bdev_get_io_channel(g_desc); 1157 bdev_ch[0] = spdk_io_channel_get_ctx(io_ch[0]); 1158 CU_ASSERT(bdev_ch[0]->flags == 0); 1159 1160 set_thread(1); 1161 io_ch[1] = spdk_bdev_get_io_channel(g_desc); 1162 bdev_ch[1] = spdk_io_channel_get_ctx(io_ch[1]); 1163 CU_ASSERT(bdev_ch[1]->flags == 0); 1164 1165 set_thread(0); 1166 1167 /* Enable QoS */ 1168 status = -1; 1169 spdk_bdev_set_qos_limit_iops(bdev, 10000, qos_dynamic_enable_done, &status); 1170 poll_threads(); 1171 CU_ASSERT(status == 0); 1172 CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) != 0); 1173 CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) != 0); 1174 1175 /* Disable QoS */ 1176 status = -1; 1177 spdk_bdev_set_qos_limit_iops(bdev, 0, qos_dynamic_enable_done, &status); 1178 poll_threads(); 1179 CU_ASSERT(status == 0); 1180 CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) == 0); 1181 CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) == 0); 1182 1183 /* Disable QoS again */ 1184 status = -1; 1185 spdk_bdev_set_qos_limit_iops(bdev, 0, qos_dynamic_enable_done, &status); 1186 poll_threads(); 1187 CU_ASSERT(status == 0); /* This should succeed */ 1188 CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) == 0); 1189 CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) == 0); 1190 1191 /* Enable QoS on thread 0 */ 1192 status = -1; 1193 spdk_bdev_set_qos_limit_iops(bdev, 10000, qos_dynamic_enable_done, &status); 1194 poll_threads(); 1195 CU_ASSERT(status == 0); 1196 CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) != 0); 1197 CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) != 0); 1198 1199 /* Disable QoS on thread 1 */ 1200 set_thread(1); 1201 status = -1; 1202 spdk_bdev_set_qos_limit_iops(bdev, 0, qos_dynamic_enable_done, &status); 1203 /* Don't poll yet. This should leave the channels with QoS enabled */ 1204 CU_ASSERT(status == -1); 1205 CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) != 0); 1206 CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) != 0); 1207 1208 /* Enable QoS. This should immediately fail because the previous disable QoS hasn't completed. */ 1209 second_status = 0; 1210 spdk_bdev_set_qos_limit_iops(bdev, 10000, qos_dynamic_enable_done, &second_status); 1211 poll_threads(); 1212 CU_ASSERT(status == 0); /* The disable should succeed */ 1213 CU_ASSERT(second_status < 0); /* The enable should fail */ 1214 CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) == 0); 1215 CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) == 0); 1216 1217 /* Enable QoS on thread 1. This should succeed now that the disable has completed. */ 1218 status = -1; 1219 spdk_bdev_set_qos_limit_iops(bdev, 10000, qos_dynamic_enable_done, &status); 1220 poll_threads(); 1221 CU_ASSERT(status == 0); 1222 CU_ASSERT((bdev_ch[0]->flags & BDEV_CH_QOS_ENABLED) != 0); 1223 CU_ASSERT((bdev_ch[1]->flags & BDEV_CH_QOS_ENABLED) != 0); 1224 1225 /* Tear down the channels */ 1226 set_thread(0); 1227 spdk_put_io_channel(io_ch[0]); 1228 set_thread(1); 1229 spdk_put_io_channel(io_ch[1]); 1230 poll_threads(); 1231 1232 set_thread(0); 1233 teardown_test(); 1234 } 1235 1236 int 1237 main(int argc, char **argv) 1238 { 1239 CU_pSuite suite = NULL; 1240 unsigned int num_failures; 1241 1242 if (CU_initialize_registry() != CUE_SUCCESS) { 1243 return CU_get_error(); 1244 } 1245 1246 suite = CU_add_suite("bdev", NULL, NULL); 1247 if (suite == NULL) { 1248 CU_cleanup_registry(); 1249 return CU_get_error(); 1250 } 1251 1252 if ( 1253 CU_add_test(suite, "basic", basic) == NULL || 1254 CU_add_test(suite, "basic_poller", basic_poller) == NULL || 1255 CU_add_test(suite, "basic_qos", basic_qos) == NULL || 1256 CU_add_test(suite, "put_channel_during_reset", put_channel_during_reset) == NULL || 1257 CU_add_test(suite, "aborted_reset", aborted_reset) == NULL || 1258 CU_add_test(suite, "io_during_reset", io_during_reset) == NULL || 1259 CU_add_test(suite, "io_during_qos_queue", io_during_qos_queue) == NULL || 1260 CU_add_test(suite, "io_during_qos_reset", io_during_qos_reset) == NULL || 1261 CU_add_test(suite, "enomem", enomem) == NULL || 1262 CU_add_test(suite, "enomem_multi_bdev", enomem_multi_bdev) == NULL || 1263 CU_add_test(suite, "enomem_multi_io_target", enomem_multi_io_target) == NULL || 1264 CU_add_test(suite, "qos_dynamic_enable", qos_dynamic_enable) == NULL 1265 ) { 1266 CU_cleanup_registry(); 1267 return CU_get_error(); 1268 } 1269 1270 CU_basic_set_mode(CU_BRM_VERBOSE); 1271 CU_basic_run_tests(); 1272 num_failures = CU_get_number_of_failures(); 1273 CU_cleanup_registry(); 1274 return num_failures; 1275 } 1276