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/stdinc.h" 35 36 #include "spdk/endian.h" 37 #include "spdk/scsi.h" 38 #include "spdk_cunit.h" 39 40 #include "CUnit/Basic.h" 41 42 #include "iscsi/iscsi.c" 43 44 #include "../common.c" 45 #include "iscsi/acceptor.h" 46 #include "iscsi/portal_grp.h" 47 #include "scsi/scsi_internal.h" 48 #include "common/lib/test_env.c" 49 50 #include "spdk_internal/mock.h" 51 52 #define UT_TARGET_NAME1 "iqn.2017-11.spdk.io:t0001" 53 #define UT_TARGET_NAME2 "iqn.2017-11.spdk.io:t0002" 54 #define UT_INITIATOR_NAME1 "iqn.2017-11.spdk.io:i0001" 55 #define UT_INITIATOR_NAME2 "iqn.2017-11.spdk.io:i0002" 56 57 struct spdk_iscsi_tgt_node * 58 spdk_iscsi_find_tgt_node(const char *target_name) 59 { 60 if (strcasecmp(target_name, UT_TARGET_NAME1) == 0) { 61 return (struct spdk_iscsi_tgt_node *)1; 62 } else { 63 return NULL; 64 } 65 } 66 67 bool 68 spdk_iscsi_tgt_node_access(struct spdk_iscsi_conn *conn, 69 struct spdk_iscsi_tgt_node *target, 70 const char *iqn, const char *addr) 71 { 72 if (strcasecmp(conn->initiator_name, UT_INITIATOR_NAME1) == 0) { 73 return true; 74 } else { 75 return false; 76 } 77 } 78 79 DEFINE_STUB(spdk_iscsi_send_tgts, int, 80 (struct spdk_iscsi_conn *conn, const char *iiqn, const char *iaddr, 81 const char *tiqn, uint8_t *data, int alloc_len, int data_len), 82 0); 83 84 DEFINE_STUB(spdk_iscsi_tgt_node_is_destructed, bool, 85 (struct spdk_iscsi_tgt_node *target), false); 86 87 DEFINE_STUB_V(spdk_iscsi_portal_grp_close_all, (void)); 88 89 DEFINE_STUB_V(spdk_iscsi_conn_migration, (struct spdk_iscsi_conn *conn)); 90 91 DEFINE_STUB_V(spdk_iscsi_conn_free_pdu, 92 (struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)); 93 94 DEFINE_STUB(spdk_iscsi_chap_get_authinfo, int, 95 (struct iscsi_chap_auth *auth, const char *authuser, int ag_tag), 96 0); 97 98 int 99 spdk_scsi_lun_get_id(const struct spdk_scsi_lun *lun) 100 { 101 return lun->id; 102 } 103 104 DEFINE_STUB(spdk_scsi_lun_is_removing, bool, (const struct spdk_scsi_lun *lun), 105 true); 106 107 struct spdk_scsi_lun * 108 spdk_scsi_dev_get_lun(struct spdk_scsi_dev *dev, int lun_id) 109 { 110 if (lun_id < 0 || lun_id >= SPDK_SCSI_DEV_MAX_LUN) { 111 return NULL; 112 } 113 114 return dev->lun[lun_id]; 115 } 116 117 DEFINE_STUB(spdk_scsi_lun_id_int_to_fmt, uint64_t, (int lun_id), 0); 118 119 DEFINE_STUB(spdk_scsi_lun_id_fmt_to_int, int, (uint64_t lun_fmt), 0); 120 121 static void 122 op_login_check_target_test(void) 123 { 124 struct spdk_iscsi_conn conn; 125 struct spdk_iscsi_pdu rsp_pdu; 126 struct spdk_iscsi_tgt_node *target; 127 int rc; 128 129 /* expect success */ 130 snprintf(conn.initiator_name, sizeof(conn.initiator_name), 131 "%s", UT_INITIATOR_NAME1); 132 133 rc = iscsi_op_login_check_target(&conn, &rsp_pdu, 134 UT_TARGET_NAME1, &target); 135 CU_ASSERT(rc == 0); 136 137 /* expect failure */ 138 snprintf(conn.initiator_name, sizeof(conn.initiator_name), 139 "%s", UT_INITIATOR_NAME1); 140 141 rc = iscsi_op_login_check_target(&conn, &rsp_pdu, 142 UT_TARGET_NAME2, &target); 143 CU_ASSERT(rc != 0); 144 145 /* expect failure */ 146 snprintf(conn.initiator_name, sizeof(conn.initiator_name), 147 "%s", UT_INITIATOR_NAME2); 148 149 rc = iscsi_op_login_check_target(&conn, &rsp_pdu, 150 UT_TARGET_NAME1, &target); 151 CU_ASSERT(rc != 0); 152 } 153 154 static void 155 maxburstlength_test(void) 156 { 157 struct spdk_iscsi_sess sess; 158 struct spdk_iscsi_conn conn; 159 struct spdk_scsi_dev dev; 160 struct spdk_scsi_lun lun; 161 struct spdk_iscsi_pdu *req_pdu, *data_out_pdu, *r2t_pdu; 162 struct iscsi_bhs_scsi_req *req; 163 struct iscsi_bhs_r2t *r2t; 164 struct iscsi_bhs_data_out *data_out; 165 struct spdk_iscsi_pdu *response_pdu; 166 int rc; 167 168 memset(&sess, 0, sizeof(sess)); 169 memset(&conn, 0, sizeof(conn)); 170 memset(&dev, 0, sizeof(dev)); 171 memset(&lun, 0, sizeof(lun)); 172 173 req_pdu = spdk_get_pdu(); 174 data_out_pdu = spdk_get_pdu(); 175 176 sess.ExpCmdSN = 0; 177 sess.MaxCmdSN = 64; 178 sess.session_type = SESSION_TYPE_NORMAL; 179 sess.MaxBurstLength = 1024; 180 181 lun.id = 0; 182 183 dev.lun[0] = &lun; 184 185 conn.full_feature = 1; 186 conn.sess = &sess; 187 conn.dev = &dev; 188 conn.state = ISCSI_CONN_STATE_RUNNING; 189 TAILQ_INIT(&conn.write_pdu_list); 190 TAILQ_INIT(&conn.active_r2t_tasks); 191 192 TAILQ_INIT(&g_write_pdu_list); 193 194 req_pdu->bhs.opcode = ISCSI_OP_SCSI; 195 req_pdu->data_segment_len = 0; 196 197 req = (struct iscsi_bhs_scsi_req *)&req_pdu->bhs; 198 199 to_be32(&req->cmd_sn, 0); 200 to_be32(&req->expected_data_xfer_len, 1028); 201 to_be32(&req->itt, 0x1234); 202 req->write_bit = 1; 203 req->final_bit = 1; 204 205 rc = spdk_iscsi_execute(&conn, req_pdu); 206 CU_ASSERT(rc == 0); 207 208 response_pdu = TAILQ_FIRST(&g_write_pdu_list); 209 SPDK_CU_ASSERT_FATAL(response_pdu != NULL); 210 211 /* 212 * Confirm that a correct R2T reply was sent in response to the 213 * SCSI request. 214 */ 215 TAILQ_REMOVE(&g_write_pdu_list, response_pdu, tailq); 216 CU_ASSERT(response_pdu->bhs.opcode == ISCSI_OP_R2T); 217 r2t = (struct iscsi_bhs_r2t *)&response_pdu->bhs; 218 CU_ASSERT(from_be32(&r2t->desired_xfer_len) == 1024); 219 CU_ASSERT(from_be32(&r2t->buffer_offset) == 0); 220 CU_ASSERT(from_be32(&r2t->itt) == 0x1234); 221 222 data_out_pdu->bhs.opcode = ISCSI_OP_SCSI_DATAOUT; 223 data_out_pdu->bhs.flags = ISCSI_FLAG_FINAL; 224 data_out_pdu->data_segment_len = 1028; 225 data_out = (struct iscsi_bhs_data_out *)&data_out_pdu->bhs; 226 data_out->itt = r2t->itt; 227 data_out->ttt = r2t->ttt; 228 DSET24(data_out->data_segment_len, 1028); 229 230 rc = spdk_iscsi_execute(&conn, data_out_pdu); 231 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 232 233 SPDK_CU_ASSERT_FATAL(response_pdu->task != NULL); 234 spdk_iscsi_task_disassociate_pdu(response_pdu->task); 235 spdk_iscsi_task_put(response_pdu->task); 236 spdk_put_pdu(response_pdu); 237 238 r2t_pdu = TAILQ_FIRST(&g_write_pdu_list); 239 CU_ASSERT(r2t_pdu != NULL); 240 TAILQ_REMOVE(&g_write_pdu_list, r2t_pdu, tailq); 241 spdk_put_pdu(r2t_pdu); 242 243 spdk_put_pdu(data_out_pdu); 244 spdk_put_pdu(req_pdu); 245 } 246 247 static void 248 underflow_for_read_transfer_test(void) 249 { 250 struct spdk_iscsi_sess sess; 251 struct spdk_iscsi_conn conn; 252 struct spdk_iscsi_task task; 253 struct spdk_iscsi_pdu *pdu; 254 struct iscsi_bhs_scsi_req *scsi_req; 255 struct iscsi_bhs_data_in *datah; 256 uint32_t residual_count = 0; 257 258 TAILQ_INIT(&g_write_pdu_list); 259 260 memset(&sess, 0, sizeof(sess)); 261 memset(&conn, 0, sizeof(conn)); 262 memset(&task, 0, sizeof(task)); 263 264 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; 265 266 conn.sess = &sess; 267 conn.MaxRecvDataSegmentLength = 8192; 268 269 pdu = spdk_get_pdu(); 270 SPDK_CU_ASSERT_FATAL(pdu != NULL); 271 272 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu->bhs; 273 scsi_req->read_bit = 1; 274 275 spdk_iscsi_task_set_pdu(&task, pdu); 276 task.parent = NULL; 277 278 task.scsi.iovs = &task.scsi.iov; 279 task.scsi.iovcnt = 1; 280 task.scsi.length = 512; 281 task.scsi.transfer_len = 512; 282 task.bytes_completed = 512; 283 task.scsi.data_transferred = 256; 284 task.scsi.status = SPDK_SCSI_STATUS_GOOD; 285 286 spdk_iscsi_task_response(&conn, &task); 287 spdk_put_pdu(pdu); 288 289 /* 290 * In this case, a SCSI Data-In PDU should contain the Status 291 * for the data transfer. 292 */ 293 to_be32(&residual_count, 256); 294 295 pdu = TAILQ_FIRST(&g_write_pdu_list); 296 SPDK_CU_ASSERT_FATAL(pdu != NULL); 297 298 CU_ASSERT(pdu->bhs.opcode == ISCSI_OP_SCSI_DATAIN); 299 300 datah = (struct iscsi_bhs_data_in *)&pdu->bhs; 301 302 CU_ASSERT(datah->flags == (ISCSI_DATAIN_UNDERFLOW | ISCSI_FLAG_FINAL | ISCSI_DATAIN_STATUS)); 303 CU_ASSERT(datah->res_cnt == residual_count); 304 305 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 306 spdk_put_pdu(pdu); 307 308 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list)); 309 } 310 311 static void 312 underflow_for_zero_read_transfer_test(void) 313 { 314 struct spdk_iscsi_sess sess; 315 struct spdk_iscsi_conn conn; 316 struct spdk_iscsi_task task; 317 struct spdk_iscsi_pdu *pdu; 318 struct iscsi_bhs_scsi_req *scsi_req; 319 struct iscsi_bhs_scsi_resp *resph; 320 uint32_t residual_count = 0, data_segment_len; 321 322 TAILQ_INIT(&g_write_pdu_list); 323 324 memset(&sess, 0, sizeof(sess)); 325 memset(&conn, 0, sizeof(conn)); 326 memset(&task, 0, sizeof(task)); 327 328 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; 329 330 conn.sess = &sess; 331 conn.MaxRecvDataSegmentLength = 8192; 332 333 pdu = spdk_get_pdu(); 334 SPDK_CU_ASSERT_FATAL(pdu != NULL); 335 336 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu->bhs; 337 scsi_req->read_bit = 1; 338 339 spdk_iscsi_task_set_pdu(&task, pdu); 340 task.parent = NULL; 341 342 task.scsi.length = 512; 343 task.scsi.transfer_len = 512; 344 task.bytes_completed = 512; 345 task.scsi.data_transferred = 0; 346 task.scsi.status = SPDK_SCSI_STATUS_GOOD; 347 348 spdk_iscsi_task_response(&conn, &task); 349 spdk_put_pdu(pdu); 350 351 /* 352 * In this case, only a SCSI Response PDU is expected and 353 * underflow must be set in it. 354 * */ 355 to_be32(&residual_count, 512); 356 357 pdu = TAILQ_FIRST(&g_write_pdu_list); 358 SPDK_CU_ASSERT_FATAL(pdu != NULL); 359 360 CU_ASSERT(pdu->bhs.opcode == ISCSI_OP_SCSI_RSP); 361 362 resph = (struct iscsi_bhs_scsi_resp *)&pdu->bhs; 363 364 CU_ASSERT(resph->flags == (ISCSI_SCSI_UNDERFLOW | 0x80)); 365 366 data_segment_len = DGET24(resph->data_segment_len); 367 CU_ASSERT(data_segment_len == 0); 368 CU_ASSERT(resph->res_cnt == residual_count); 369 370 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 371 spdk_put_pdu(pdu); 372 373 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list)); 374 } 375 376 static void 377 underflow_for_request_sense_test(void) 378 { 379 struct spdk_iscsi_sess sess; 380 struct spdk_iscsi_conn conn; 381 struct spdk_iscsi_task task; 382 struct spdk_iscsi_pdu *pdu1, *pdu2; 383 struct iscsi_bhs_scsi_req *scsi_req; 384 struct iscsi_bhs_data_in *datah; 385 struct iscsi_bhs_scsi_resp *resph; 386 uint32_t residual_count = 0, data_segment_len; 387 388 TAILQ_INIT(&g_write_pdu_list); 389 390 memset(&sess, 0, sizeof(sess)); 391 memset(&conn, 0, sizeof(conn)); 392 memset(&task, 0, sizeof(task)); 393 394 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; 395 396 conn.sess = &sess; 397 conn.MaxRecvDataSegmentLength = 8192; 398 399 pdu1 = spdk_get_pdu(); 400 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 401 402 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu1->bhs; 403 scsi_req->read_bit = 1; 404 405 spdk_iscsi_task_set_pdu(&task, pdu1); 406 task.parent = NULL; 407 408 task.scsi.iovs = &task.scsi.iov; 409 task.scsi.iovcnt = 1; 410 task.scsi.length = 512; 411 task.scsi.transfer_len = 512; 412 task.bytes_completed = 512; 413 414 task.scsi.sense_data_len = 18; 415 task.scsi.data_transferred = 18; 416 task.scsi.status = SPDK_SCSI_STATUS_GOOD; 417 418 spdk_iscsi_task_response(&conn, &task); 419 spdk_put_pdu(pdu1); 420 421 /* 422 * In this case, a SCSI Data-In PDU and a SCSI Response PDU are returned. 423 * Sense data are set both in payload and sense area. 424 * The SCSI Data-In PDU sets FINAL and the SCSI Response PDU sets UNDERFLOW. 425 * 426 * Probably there will be different implementation but keeping current SPDK 427 * implementation by adding UT will be valuable for any implementation. 428 */ 429 to_be32(&residual_count, 494); 430 431 pdu1 = TAILQ_FIRST(&g_write_pdu_list); 432 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 433 434 CU_ASSERT(pdu1->bhs.opcode == ISCSI_OP_SCSI_DATAIN); 435 436 datah = (struct iscsi_bhs_data_in *)&pdu1->bhs; 437 438 CU_ASSERT(datah->flags == ISCSI_FLAG_FINAL); 439 440 data_segment_len = DGET24(datah->data_segment_len); 441 CU_ASSERT(data_segment_len == 18); 442 CU_ASSERT(datah->res_cnt == 0); 443 444 TAILQ_REMOVE(&g_write_pdu_list, pdu1, tailq); 445 spdk_put_pdu(pdu1); 446 447 pdu2 = TAILQ_FIRST(&g_write_pdu_list); 448 /* inform scan-build (clang 6) that these pointers are not the same */ 449 SPDK_CU_ASSERT_FATAL(pdu1 != pdu2); 450 SPDK_CU_ASSERT_FATAL(pdu2 != NULL); 451 452 CU_ASSERT(pdu2->bhs.opcode == ISCSI_OP_SCSI_RSP); 453 454 resph = (struct iscsi_bhs_scsi_resp *)&pdu2->bhs; 455 456 CU_ASSERT(resph->flags == (ISCSI_SCSI_UNDERFLOW | 0x80)); 457 458 data_segment_len = DGET24(resph->data_segment_len); 459 CU_ASSERT(data_segment_len == task.scsi.sense_data_len + 2); 460 CU_ASSERT(resph->res_cnt == residual_count); 461 462 TAILQ_REMOVE(&g_write_pdu_list, pdu2, tailq); 463 spdk_put_pdu(pdu2); 464 465 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list)); 466 } 467 468 static void 469 underflow_for_check_condition_test(void) 470 { 471 struct spdk_iscsi_sess sess; 472 struct spdk_iscsi_conn conn; 473 struct spdk_iscsi_task task; 474 struct spdk_iscsi_pdu *pdu; 475 struct iscsi_bhs_scsi_req *scsi_req; 476 struct iscsi_bhs_scsi_resp *resph; 477 uint32_t data_segment_len; 478 479 TAILQ_INIT(&g_write_pdu_list); 480 481 memset(&sess, 0, sizeof(sess)); 482 memset(&conn, 0, sizeof(conn)); 483 memset(&task, 0, sizeof(task)); 484 485 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; 486 487 conn.sess = &sess; 488 conn.MaxRecvDataSegmentLength = 8192; 489 490 pdu = spdk_get_pdu(); 491 SPDK_CU_ASSERT_FATAL(pdu != NULL); 492 493 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu->bhs; 494 scsi_req->read_bit = 1; 495 496 spdk_iscsi_task_set_pdu(&task, pdu); 497 task.parent = NULL; 498 499 task.scsi.iovs = &task.scsi.iov; 500 task.scsi.iovcnt = 1; 501 task.scsi.length = 512; 502 task.scsi.transfer_len = 512; 503 task.bytes_completed = 512; 504 505 task.scsi.sense_data_len = 18; 506 task.scsi.data_transferred = 18; 507 task.scsi.status = SPDK_SCSI_STATUS_CHECK_CONDITION; 508 509 spdk_iscsi_task_response(&conn, &task); 510 spdk_put_pdu(pdu); 511 512 /* 513 * In this case, a SCSI Response PDU is returned. 514 * Sense data is set in sense area. 515 * Underflow is not set. 516 */ 517 pdu = TAILQ_FIRST(&g_write_pdu_list); 518 SPDK_CU_ASSERT_FATAL(pdu != NULL); 519 520 CU_ASSERT(pdu->bhs.opcode == ISCSI_OP_SCSI_RSP); 521 522 resph = (struct iscsi_bhs_scsi_resp *)&pdu->bhs; 523 524 CU_ASSERT(resph->flags == 0x80); 525 526 data_segment_len = DGET24(resph->data_segment_len); 527 CU_ASSERT(data_segment_len == task.scsi.sense_data_len + 2); 528 CU_ASSERT(resph->res_cnt == 0); 529 530 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 531 spdk_put_pdu(pdu); 532 533 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list)); 534 } 535 536 static void 537 add_transfer_task_test(void) 538 { 539 struct spdk_iscsi_sess sess; 540 struct spdk_iscsi_conn conn; 541 struct spdk_iscsi_task task; 542 struct spdk_iscsi_pdu *pdu, *tmp; 543 struct iscsi_bhs_r2t *r2th; 544 int rc, count = 0; 545 uint32_t buffer_offset, desired_xfer_len; 546 547 memset(&sess, 0, sizeof(sess)); 548 memset(&conn, 0, sizeof(conn)); 549 memset(&task, 0, sizeof(task)); 550 551 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; /* 1M */ 552 sess.MaxOutstandingR2T = DEFAULT_MAXR2T; /* 4 */ 553 554 conn.sess = &sess; 555 TAILQ_INIT(&conn.queued_r2t_tasks); 556 TAILQ_INIT(&conn.active_r2t_tasks); 557 558 pdu = spdk_get_pdu(); 559 SPDK_CU_ASSERT_FATAL(pdu != NULL); 560 561 pdu->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; /* 64K */ 562 task.scsi.transfer_len = 16 * 1024 * 1024; 563 spdk_iscsi_task_set_pdu(&task, pdu); 564 565 /* The following tests if the task is queued because R2T tasks are full. */ 566 conn.pending_r2t = DEFAULT_MAXR2T; 567 568 rc = add_transfer_task(&conn, &task); 569 570 CU_ASSERT(rc == SPDK_SUCCESS); 571 CU_ASSERT(TAILQ_FIRST(&conn.queued_r2t_tasks) == &task); 572 573 TAILQ_REMOVE(&conn.queued_r2t_tasks, &task, link); 574 CU_ASSERT(TAILQ_EMPTY(&conn.queued_r2t_tasks)); 575 576 /* The following tests if multiple R2Ts are issued. */ 577 conn.pending_r2t = 0; 578 579 rc = add_transfer_task(&conn, &task); 580 581 CU_ASSERT(rc == SPDK_SUCCESS); 582 CU_ASSERT(TAILQ_FIRST(&conn.active_r2t_tasks) == &task); 583 584 TAILQ_REMOVE(&conn.active_r2t_tasks, &task, link); 585 CU_ASSERT(TAILQ_EMPTY(&conn.active_r2t_tasks)); 586 587 CU_ASSERT(conn.data_out_cnt == 255); 588 CU_ASSERT(conn.pending_r2t == 1); 589 CU_ASSERT(conn.outstanding_r2t_tasks[0] == &task); 590 CU_ASSERT(conn.ttt == 1); 591 592 CU_ASSERT(task.data_out_cnt == 255); 593 CU_ASSERT(task.ttt == 1); 594 CU_ASSERT(task.outstanding_r2t == sess.MaxOutstandingR2T); 595 CU_ASSERT(task.next_r2t_offset == 596 pdu->data_segment_len + sess.MaxBurstLength * sess.MaxOutstandingR2T); 597 598 599 while (!TAILQ_EMPTY(&g_write_pdu_list)) { 600 tmp = TAILQ_FIRST(&g_write_pdu_list); 601 TAILQ_REMOVE(&g_write_pdu_list, tmp, tailq); 602 603 r2th = (struct iscsi_bhs_r2t *)&tmp->bhs; 604 605 buffer_offset = from_be32(&r2th->buffer_offset); 606 CU_ASSERT(buffer_offset == pdu->data_segment_len + sess.MaxBurstLength * count); 607 608 desired_xfer_len = from_be32(&r2th->desired_xfer_len); 609 CU_ASSERT(desired_xfer_len == sess.MaxBurstLength); 610 611 spdk_put_pdu(tmp); 612 count++; 613 } 614 615 CU_ASSERT(count == DEFAULT_MAXR2T); 616 617 spdk_put_pdu(pdu); 618 } 619 620 static void 621 get_transfer_task_test(void) 622 { 623 struct spdk_iscsi_sess sess; 624 struct spdk_iscsi_conn conn; 625 struct spdk_iscsi_task task1, task2, *task; 626 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu; 627 int rc; 628 629 memset(&sess, 0, sizeof(sess)); 630 memset(&conn, 0, sizeof(conn)); 631 memset(&task1, 0, sizeof(task1)); 632 memset(&task2, 0, sizeof(task2)); 633 634 sess.MaxBurstLength = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 635 sess.MaxOutstandingR2T = 1; 636 637 conn.sess = &sess; 638 TAILQ_INIT(&conn.active_r2t_tasks); 639 640 pdu1 = spdk_get_pdu(); 641 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 642 643 pdu1->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 644 task1.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 645 spdk_iscsi_task_set_pdu(&task1, pdu1); 646 647 rc = add_transfer_task(&conn, &task1); 648 CU_ASSERT(rc == SPDK_SUCCESS); 649 650 pdu2 = spdk_get_pdu(); 651 SPDK_CU_ASSERT_FATAL(pdu2 != NULL); 652 653 pdu2->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 654 task2.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 655 spdk_iscsi_task_set_pdu(&task2, pdu2); 656 657 rc = add_transfer_task(&conn, &task2); 658 CU_ASSERT(rc == SPDK_SUCCESS); 659 660 task = get_transfer_task(&conn, 1); 661 CU_ASSERT(task == &task1); 662 663 task = get_transfer_task(&conn, 2); 664 CU_ASSERT(task == &task2); 665 666 while (!TAILQ_EMPTY(&conn.active_r2t_tasks)) { 667 task = TAILQ_FIRST(&conn.active_r2t_tasks); 668 TAILQ_REMOVE(&conn.active_r2t_tasks, task, link); 669 } 670 671 while (!TAILQ_EMPTY(&g_write_pdu_list)) { 672 pdu = TAILQ_FIRST(&g_write_pdu_list); 673 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 674 spdk_put_pdu(pdu); 675 } 676 677 spdk_put_pdu(pdu2); 678 spdk_put_pdu(pdu1); 679 } 680 681 static void 682 del_transfer_task_test(void) 683 { 684 struct spdk_iscsi_sess sess; 685 struct spdk_iscsi_conn conn; 686 struct spdk_iscsi_task task1, task2, task3, task4, task5, *task; 687 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu3, *pdu4, *pdu5, *pdu; 688 int rc; 689 690 memset(&sess, 0, sizeof(sess)); 691 memset(&conn, 0, sizeof(conn)); 692 memset(&task1, 0, sizeof(task1)); 693 memset(&task2, 0, sizeof(task2)); 694 memset(&task3, 0, sizeof(task3)); 695 memset(&task4, 0, sizeof(task4)); 696 memset(&task5, 0, sizeof(task5)); 697 698 sess.MaxBurstLength = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 699 sess.MaxOutstandingR2T = 1; 700 701 conn.sess = &sess; 702 TAILQ_INIT(&conn.active_r2t_tasks); 703 TAILQ_INIT(&conn.queued_r2t_tasks); 704 705 pdu1 = spdk_get_pdu(); 706 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 707 708 pdu1->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 709 task1.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 710 spdk_iscsi_task_set_pdu(&task1, pdu1); 711 task1.tag = 11; 712 713 rc = add_transfer_task(&conn, &task1); 714 CU_ASSERT(rc == SPDK_SUCCESS); 715 716 pdu2 = spdk_get_pdu(); 717 SPDK_CU_ASSERT_FATAL(pdu2 != NULL); 718 719 pdu2->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 720 task2.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 721 spdk_iscsi_task_set_pdu(&task2, pdu2); 722 task2.tag = 12; 723 724 rc = add_transfer_task(&conn, &task2); 725 CU_ASSERT(rc == SPDK_SUCCESS); 726 727 pdu3 = spdk_get_pdu(); 728 SPDK_CU_ASSERT_FATAL(pdu3 != NULL); 729 730 pdu3->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 731 task3.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 732 spdk_iscsi_task_set_pdu(&task3, pdu3); 733 task3.tag = 13; 734 735 rc = add_transfer_task(&conn, &task3); 736 CU_ASSERT(rc == SPDK_SUCCESS); 737 738 pdu4 = spdk_get_pdu(); 739 SPDK_CU_ASSERT_FATAL(pdu4 != NULL); 740 741 pdu4->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 742 task4.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 743 spdk_iscsi_task_set_pdu(&task4, pdu4); 744 task4.tag = 14; 745 746 rc = add_transfer_task(&conn, &task4); 747 CU_ASSERT(rc == SPDK_SUCCESS); 748 749 pdu5 = spdk_get_pdu(); 750 SPDK_CU_ASSERT_FATAL(pdu5 != NULL); 751 752 pdu5->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 753 task5.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 754 spdk_iscsi_task_set_pdu(&task5, pdu5); 755 task5.tag = 15; 756 757 rc = add_transfer_task(&conn, &task5); 758 CU_ASSERT(rc == SPDK_SUCCESS); 759 760 CU_ASSERT(get_transfer_task(&conn, 1) == &task1); 761 CU_ASSERT(get_transfer_task(&conn, 5) == NULL); 762 spdk_del_transfer_task(&conn, 11); 763 CU_ASSERT(get_transfer_task(&conn, 1) == NULL); 764 CU_ASSERT(get_transfer_task(&conn, 5) == &task5); 765 766 CU_ASSERT(get_transfer_task(&conn, 2) == &task2); 767 spdk_del_transfer_task(&conn, 12); 768 CU_ASSERT(get_transfer_task(&conn, 2) == NULL); 769 770 CU_ASSERT(get_transfer_task(&conn, 3) == &task3); 771 spdk_del_transfer_task(&conn, 13); 772 CU_ASSERT(get_transfer_task(&conn, 3) == NULL); 773 774 CU_ASSERT(get_transfer_task(&conn, 4) == &task4); 775 spdk_del_transfer_task(&conn, 14); 776 CU_ASSERT(get_transfer_task(&conn, 4) == NULL); 777 778 CU_ASSERT(get_transfer_task(&conn, 5) == &task5); 779 spdk_del_transfer_task(&conn, 15); 780 CU_ASSERT(get_transfer_task(&conn, 5) == NULL); 781 782 while (!TAILQ_EMPTY(&conn.active_r2t_tasks)) { 783 task = TAILQ_FIRST(&conn.active_r2t_tasks); 784 TAILQ_REMOVE(&conn.active_r2t_tasks, task, link); 785 } 786 787 while (!TAILQ_EMPTY(&g_write_pdu_list)) { 788 pdu = TAILQ_FIRST(&g_write_pdu_list); 789 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 790 spdk_put_pdu(pdu); 791 } 792 793 spdk_put_pdu(pdu5); 794 spdk_put_pdu(pdu4); 795 spdk_put_pdu(pdu3); 796 spdk_put_pdu(pdu2); 797 spdk_put_pdu(pdu1); 798 } 799 800 static void 801 clear_all_transfer_tasks_test(void) 802 { 803 struct spdk_iscsi_sess sess; 804 struct spdk_iscsi_conn conn; 805 struct spdk_iscsi_task *task1, *task2, *task3, *task4, *task5, *task6; 806 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu3, *pdu4, *pdu5, *pdu6, *pdu; 807 struct spdk_iscsi_pdu *mgmt_pdu1, *mgmt_pdu2; 808 struct spdk_scsi_lun lun1, lun2; 809 uint32_t alloc_cmd_sn; 810 int rc; 811 812 memset(&sess, 0, sizeof(sess)); 813 memset(&conn, 0, sizeof(conn)); 814 memset(&lun1, 0, sizeof(lun1)); 815 memset(&lun2, 0, sizeof(lun2)); 816 817 sess.MaxBurstLength = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 818 sess.MaxOutstandingR2T = 1; 819 820 conn.sess = &sess; 821 TAILQ_INIT(&conn.active_r2t_tasks); 822 TAILQ_INIT(&conn.queued_r2t_tasks); 823 824 alloc_cmd_sn = 10; 825 826 task1 = spdk_iscsi_task_get(&conn, NULL, NULL); 827 SPDK_CU_ASSERT_FATAL(task1 != NULL); 828 pdu1 = spdk_get_pdu(); 829 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 830 831 pdu1->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 832 pdu1->cmd_sn = alloc_cmd_sn; 833 alloc_cmd_sn++; 834 task1->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 835 task1->scsi.lun = &lun1; 836 spdk_iscsi_task_set_pdu(task1, pdu1); 837 838 rc = add_transfer_task(&conn, task1); 839 CU_ASSERT(rc == SPDK_SUCCESS); 840 841 mgmt_pdu1 = spdk_get_pdu(); 842 SPDK_CU_ASSERT_FATAL(mgmt_pdu1 != NULL); 843 844 mgmt_pdu1->cmd_sn = alloc_cmd_sn; 845 alloc_cmd_sn++; 846 847 task2 = spdk_iscsi_task_get(&conn, NULL, NULL); 848 SPDK_CU_ASSERT_FATAL(task2 != NULL); 849 pdu2 = spdk_get_pdu(); 850 SPDK_CU_ASSERT_FATAL(pdu2 != NULL); 851 852 pdu2->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 853 pdu2->cmd_sn = alloc_cmd_sn; 854 alloc_cmd_sn++; 855 task2->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 856 task2->scsi.lun = &lun1; 857 spdk_iscsi_task_set_pdu(task2, pdu2); 858 859 rc = add_transfer_task(&conn, task2); 860 CU_ASSERT(rc == SPDK_SUCCESS); 861 862 task3 = spdk_iscsi_task_get(&conn, NULL, NULL); 863 SPDK_CU_ASSERT_FATAL(task3 != NULL); 864 pdu3 = spdk_get_pdu(); 865 SPDK_CU_ASSERT_FATAL(pdu3 != NULL); 866 867 pdu3->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 868 pdu3->cmd_sn = alloc_cmd_sn; 869 alloc_cmd_sn++; 870 task3->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 871 task3->scsi.lun = &lun1; 872 spdk_iscsi_task_set_pdu(task3, pdu3); 873 874 rc = add_transfer_task(&conn, task3); 875 CU_ASSERT(rc == SPDK_SUCCESS); 876 877 task4 = spdk_iscsi_task_get(&conn, NULL, NULL); 878 SPDK_CU_ASSERT_FATAL(task4 != NULL); 879 pdu4 = spdk_get_pdu(); 880 SPDK_CU_ASSERT_FATAL(pdu4 != NULL); 881 882 pdu4->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 883 pdu4->cmd_sn = alloc_cmd_sn; 884 alloc_cmd_sn++; 885 task4->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 886 task4->scsi.lun = &lun2; 887 spdk_iscsi_task_set_pdu(task4, pdu4); 888 889 rc = add_transfer_task(&conn, task4); 890 CU_ASSERT(rc == SPDK_SUCCESS); 891 892 task5 = spdk_iscsi_task_get(&conn, NULL, NULL); 893 SPDK_CU_ASSERT_FATAL(task5 != NULL); 894 pdu5 = spdk_get_pdu(); 895 SPDK_CU_ASSERT_FATAL(pdu5 != NULL); 896 897 pdu5->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 898 pdu5->cmd_sn = alloc_cmd_sn; 899 alloc_cmd_sn++; 900 task5->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 901 task5->scsi.lun = &lun2; 902 spdk_iscsi_task_set_pdu(task5, pdu5); 903 904 rc = add_transfer_task(&conn, task5); 905 CU_ASSERT(rc == SPDK_SUCCESS); 906 907 mgmt_pdu2 = spdk_get_pdu(); 908 SPDK_CU_ASSERT_FATAL(mgmt_pdu2 != NULL); 909 910 mgmt_pdu2->cmd_sn = alloc_cmd_sn; 911 alloc_cmd_sn++; 912 913 task6 = spdk_iscsi_task_get(&conn, NULL, NULL); 914 SPDK_CU_ASSERT_FATAL(task6 != NULL); 915 pdu6 = spdk_get_pdu(); 916 SPDK_CU_ASSERT_FATAL(pdu6 != NULL); 917 918 pdu6->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 919 pdu6->cmd_sn = alloc_cmd_sn; 920 alloc_cmd_sn++; 921 task5->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 922 task6->scsi.lun = &lun2; 923 spdk_iscsi_task_set_pdu(task6, pdu6); 924 925 rc = add_transfer_task(&conn, task6); 926 CU_ASSERT(rc == SPDK_SUCCESS); 927 928 CU_ASSERT(conn.ttt == 4); 929 930 CU_ASSERT(get_transfer_task(&conn, 1) == task1); 931 CU_ASSERT(get_transfer_task(&conn, 2) == task2); 932 CU_ASSERT(get_transfer_task(&conn, 3) == task3); 933 CU_ASSERT(get_transfer_task(&conn, 4) == task4); 934 CU_ASSERT(get_transfer_task(&conn, 5) == NULL); 935 936 spdk_clear_all_transfer_task(&conn, &lun1, mgmt_pdu1); 937 938 CU_ASSERT(!TAILQ_EMPTY(&conn.queued_r2t_tasks)); 939 CU_ASSERT(get_transfer_task(&conn, 1) == NULL); 940 CU_ASSERT(get_transfer_task(&conn, 2) == task2); 941 CU_ASSERT(get_transfer_task(&conn, 3) == task3); 942 CU_ASSERT(get_transfer_task(&conn, 4) == task4); 943 CU_ASSERT(get_transfer_task(&conn, 5) == task5); 944 CU_ASSERT(get_transfer_task(&conn, 6) == NULL); 945 946 spdk_clear_all_transfer_task(&conn, &lun1, NULL); 947 948 CU_ASSERT(TAILQ_EMPTY(&conn.queued_r2t_tasks)); 949 CU_ASSERT(get_transfer_task(&conn, 1) == NULL); 950 CU_ASSERT(get_transfer_task(&conn, 2) == NULL); 951 CU_ASSERT(get_transfer_task(&conn, 3) == NULL); 952 CU_ASSERT(get_transfer_task(&conn, 4) == task4); 953 CU_ASSERT(get_transfer_task(&conn, 5) == task5); 954 CU_ASSERT(get_transfer_task(&conn, 6) == task6); 955 956 spdk_clear_all_transfer_task(&conn, &lun2, mgmt_pdu2); 957 958 CU_ASSERT(get_transfer_task(&conn, 4) == NULL); 959 CU_ASSERT(get_transfer_task(&conn, 5) == NULL); 960 CU_ASSERT(get_transfer_task(&conn, 6) == task6); 961 962 spdk_clear_all_transfer_task(&conn, NULL, NULL); 963 964 CU_ASSERT(get_transfer_task(&conn, 6) == NULL); 965 966 CU_ASSERT(TAILQ_EMPTY(&conn.active_r2t_tasks)); 967 while (!TAILQ_EMPTY(&g_write_pdu_list)) { 968 pdu = TAILQ_FIRST(&g_write_pdu_list); 969 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 970 spdk_put_pdu(pdu); 971 } 972 973 spdk_put_pdu(mgmt_pdu2); 974 spdk_put_pdu(mgmt_pdu1); 975 spdk_put_pdu(pdu6); 976 spdk_put_pdu(pdu5); 977 spdk_put_pdu(pdu4); 978 spdk_put_pdu(pdu3); 979 spdk_put_pdu(pdu2); 980 spdk_put_pdu(pdu1); 981 } 982 983 static void 984 abort_queued_datain_task_test(void) 985 { 986 struct spdk_iscsi_conn conn; 987 struct spdk_iscsi_task *task, *task2, *task3; 988 int rc; 989 990 TAILQ_INIT(&conn.queued_datain_tasks); 991 992 task = spdk_iscsi_task_get(&conn, NULL, NULL); 993 SPDK_CU_ASSERT_FATAL(task != NULL); 994 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task, link); 995 996 /* Slot of data in tasks are full */ 997 conn.data_in_cnt = MAX_LARGE_DATAIN_PER_CONNECTION; 998 999 rc = _iscsi_conn_abort_queued_datain_task(&conn, task); 1000 CU_ASSERT(rc != 0); 1001 1002 /* Only one slot remains and no subtasks are submitted yet. */ 1003 conn.data_in_cnt--; 1004 task->current_datain_offset = 0; 1005 1006 rc = _iscsi_conn_abort_queued_datain_task(&conn, task); 1007 CU_ASSERT(rc == 0); 1008 CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks)); 1009 1010 task = spdk_iscsi_task_get(&conn, NULL, NULL); 1011 SPDK_CU_ASSERT_FATAL(task != NULL); 1012 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task, link); 1013 1014 /* Only one slot remains and a subtask is submitted. */ 1015 task->scsi.transfer_len = SPDK_BDEV_LARGE_BUF_MAX_SIZE * 3; 1016 task->current_datain_offset = SPDK_BDEV_LARGE_BUF_MAX_SIZE; 1017 1018 rc = _iscsi_conn_abort_queued_datain_task(&conn, task); 1019 CU_ASSERT(rc != 0); 1020 CU_ASSERT(task->current_datain_offset == SPDK_BDEV_LARGE_BUF_MAX_SIZE * 2); 1021 CU_ASSERT(conn.data_in_cnt == MAX_LARGE_DATAIN_PER_CONNECTION); 1022 1023 /* Additional one slot becomes vacant. */ 1024 conn.data_in_cnt--; 1025 1026 rc = _iscsi_conn_abort_queued_datain_task(&conn, task); 1027 CU_ASSERT(rc == 0); 1028 CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks)); 1029 1030 spdk_iscsi_task_cpl(&task->scsi); 1031 1032 /* Queue three data in tasks and abort each task sequentially */ 1033 task = spdk_iscsi_task_get(&conn, NULL, NULL); 1034 SPDK_CU_ASSERT_FATAL(task != NULL); 1035 task->tag = 1; 1036 task->current_datain_offset = 0; 1037 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task, link); 1038 1039 task2 = spdk_iscsi_task_get(&conn, NULL, NULL); 1040 SPDK_CU_ASSERT_FATAL(task2 != NULL); 1041 task2->tag = 2; 1042 task2->current_datain_offset = 0; 1043 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task2, link); 1044 1045 task3 = spdk_iscsi_task_get(&conn, NULL, NULL); 1046 SPDK_CU_ASSERT_FATAL(task3 != NULL); 1047 task3->tag = 3; 1048 task3->current_datain_offset = 0; 1049 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task3, link); 1050 1051 conn.data_in_cnt--; 1052 1053 rc = iscsi_conn_abort_queued_datain_task(&conn, 1); 1054 CU_ASSERT(rc == 0); 1055 1056 rc = iscsi_conn_abort_queued_datain_task(&conn, 2); 1057 CU_ASSERT(rc == 0); 1058 1059 rc = iscsi_conn_abort_queued_datain_task(&conn, 3); 1060 CU_ASSERT(rc == 0); 1061 1062 CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks)); 1063 } 1064 1065 static bool 1066 datain_task_is_queued(struct spdk_iscsi_conn *conn, 1067 struct spdk_iscsi_task *task) 1068 { 1069 struct spdk_iscsi_task *tmp; 1070 1071 TAILQ_FOREACH(tmp, &conn->queued_datain_tasks, link) { 1072 if (tmp == task) { 1073 return true; 1074 } 1075 } 1076 return false; 1077 } 1078 1079 static void 1080 abort_queued_datain_tasks_test(void) 1081 { 1082 struct spdk_iscsi_conn conn; 1083 struct spdk_iscsi_task *task1, *task2, *task3, *task4, *task5, *task6; 1084 struct spdk_iscsi_task *task, *tmp; 1085 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu3, *pdu4, *pdu5, *pdu6; 1086 struct spdk_iscsi_pdu *mgmt_pdu1, *mgmt_pdu2; 1087 struct spdk_scsi_lun lun1, lun2; 1088 uint32_t alloc_cmd_sn; 1089 int rc; 1090 1091 TAILQ_INIT(&conn.queued_datain_tasks); 1092 conn.data_in_cnt = 0; 1093 1094 alloc_cmd_sn = 88; 1095 1096 task1 = spdk_iscsi_task_get(&conn, NULL, NULL); 1097 SPDK_CU_ASSERT_FATAL(task1 != NULL); 1098 pdu1 = spdk_get_pdu(); 1099 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 1100 1101 pdu1->cmd_sn = alloc_cmd_sn; 1102 alloc_cmd_sn++; 1103 task1->current_datain_offset = 0; 1104 task1->scsi.lun = &lun1; 1105 spdk_iscsi_task_set_pdu(task1, pdu1); 1106 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task1, link); 1107 1108 task2 = spdk_iscsi_task_get(&conn, NULL, NULL); 1109 SPDK_CU_ASSERT_FATAL(task2 != NULL); 1110 pdu2 = spdk_get_pdu(); 1111 SPDK_CU_ASSERT_FATAL(pdu2 != NULL); 1112 1113 pdu2->cmd_sn = alloc_cmd_sn; 1114 alloc_cmd_sn++; 1115 task2->current_datain_offset = 0; 1116 task2->scsi.lun = &lun2; 1117 spdk_iscsi_task_set_pdu(task2, pdu2); 1118 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task2, link); 1119 1120 mgmt_pdu1 = spdk_get_pdu(); 1121 SPDK_CU_ASSERT_FATAL(mgmt_pdu1 != NULL); 1122 1123 mgmt_pdu1->cmd_sn = alloc_cmd_sn; 1124 alloc_cmd_sn++; 1125 1126 task3 = spdk_iscsi_task_get(&conn, NULL, NULL); 1127 SPDK_CU_ASSERT_FATAL(task3 != NULL); 1128 pdu3 = spdk_get_pdu(); 1129 SPDK_CU_ASSERT_FATAL(pdu3 != NULL); 1130 1131 pdu3->cmd_sn = alloc_cmd_sn; 1132 alloc_cmd_sn++; 1133 task3->current_datain_offset = 0; 1134 task3->scsi.lun = &lun1; 1135 spdk_iscsi_task_set_pdu(task3, pdu3); 1136 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task3, link); 1137 1138 task4 = spdk_iscsi_task_get(&conn, NULL, NULL); 1139 SPDK_CU_ASSERT_FATAL(task4 != NULL); 1140 pdu4 = spdk_get_pdu(); 1141 SPDK_CU_ASSERT_FATAL(pdu4 != NULL); 1142 1143 pdu4->cmd_sn = alloc_cmd_sn; 1144 alloc_cmd_sn++; 1145 task4->current_datain_offset = 0; 1146 task4->scsi.lun = &lun2; 1147 spdk_iscsi_task_set_pdu(task4, pdu4); 1148 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task4, link); 1149 1150 task5 = spdk_iscsi_task_get(&conn, NULL, NULL); 1151 SPDK_CU_ASSERT_FATAL(task5 != NULL); 1152 pdu5 = spdk_get_pdu(); 1153 SPDK_CU_ASSERT_FATAL(pdu5 != NULL); 1154 1155 pdu5->cmd_sn = alloc_cmd_sn; 1156 alloc_cmd_sn++; 1157 task5->current_datain_offset = 0; 1158 task5->scsi.lun = &lun1; 1159 spdk_iscsi_task_set_pdu(task5, pdu5); 1160 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task5, link); 1161 1162 mgmt_pdu2 = spdk_get_pdu(); 1163 SPDK_CU_ASSERT_FATAL(mgmt_pdu2 != NULL); 1164 1165 mgmt_pdu2->cmd_sn = alloc_cmd_sn; 1166 alloc_cmd_sn++; 1167 1168 task6 = spdk_iscsi_task_get(&conn, NULL, NULL); 1169 SPDK_CU_ASSERT_FATAL(task6 != NULL); 1170 pdu6 = spdk_get_pdu(); 1171 SPDK_CU_ASSERT_FATAL(pdu6 != NULL); 1172 1173 pdu6->cmd_sn = alloc_cmd_sn; 1174 alloc_cmd_sn++; 1175 task6->current_datain_offset = 0; 1176 task6->scsi.lun = &lun2; 1177 spdk_iscsi_task_set_pdu(task6, pdu6); 1178 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task6, link); 1179 1180 rc = iscsi_conn_abort_queued_datain_tasks(&conn, &lun1, mgmt_pdu1); 1181 CU_ASSERT(rc == 0); 1182 CU_ASSERT(!datain_task_is_queued(&conn, task1)); 1183 CU_ASSERT(datain_task_is_queued(&conn, task2)); 1184 CU_ASSERT(datain_task_is_queued(&conn, task3)); 1185 CU_ASSERT(datain_task_is_queued(&conn, task4)); 1186 CU_ASSERT(datain_task_is_queued(&conn, task5)); 1187 CU_ASSERT(datain_task_is_queued(&conn, task6)); 1188 1189 rc = iscsi_conn_abort_queued_datain_tasks(&conn, &lun2, mgmt_pdu2); 1190 CU_ASSERT(rc == 0); 1191 CU_ASSERT(!datain_task_is_queued(&conn, task2)); 1192 CU_ASSERT(datain_task_is_queued(&conn, task3)); 1193 CU_ASSERT(!datain_task_is_queued(&conn, task4)); 1194 CU_ASSERT(datain_task_is_queued(&conn, task5)); 1195 CU_ASSERT(datain_task_is_queued(&conn, task6)); 1196 1197 TAILQ_FOREACH_SAFE(task, &conn.queued_datain_tasks, link, tmp) { 1198 TAILQ_REMOVE(&conn.queued_datain_tasks, task, link); 1199 spdk_iscsi_task_cpl(&task->scsi); 1200 } 1201 1202 spdk_put_pdu(mgmt_pdu2); 1203 spdk_put_pdu(mgmt_pdu1); 1204 spdk_put_pdu(pdu6); 1205 spdk_put_pdu(pdu5); 1206 spdk_put_pdu(pdu4); 1207 spdk_put_pdu(pdu3); 1208 spdk_put_pdu(pdu2); 1209 spdk_put_pdu(pdu1); 1210 } 1211 1212 static void 1213 build_iovs_test(void) 1214 { 1215 struct spdk_iscsi_conn conn = {}; 1216 struct spdk_iscsi_pdu pdu = {}; 1217 struct iovec iovs[5] = {}; 1218 uint8_t *data; 1219 uint32_t mapped_length = 0; 1220 int rc; 1221 1222 conn.header_digest = true; 1223 conn.data_digest = true; 1224 1225 DSET24(&pdu.bhs.data_segment_len, 512); 1226 data = calloc(1, 512); 1227 SPDK_CU_ASSERT_FATAL(data != NULL); 1228 pdu.data = data; 1229 1230 pdu.bhs.total_ahs_len = 0; 1231 pdu.bhs.opcode = ISCSI_OP_SCSI; 1232 1233 pdu.writev_offset = 0; 1234 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1235 CU_ASSERT(rc == 4); 1236 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1237 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1238 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1239 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1240 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data); 1241 CU_ASSERT(iovs[2].iov_len == 512); 1242 CU_ASSERT(iovs[3].iov_base == (void *)pdu.data_digest); 1243 CU_ASSERT(iovs[3].iov_len == ISCSI_DIGEST_LEN); 1244 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN); 1245 1246 pdu.writev_offset = ISCSI_BHS_LEN / 2; 1247 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1248 CU_ASSERT(rc == 4); 1249 CU_ASSERT(iovs[0].iov_base == (void *)((uint8_t *)&pdu.bhs + ISCSI_BHS_LEN / 2)); 1250 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN / 2); 1251 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1252 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1253 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data); 1254 CU_ASSERT(iovs[2].iov_len == 512); 1255 CU_ASSERT(iovs[3].iov_base == (void *)pdu.data_digest); 1256 CU_ASSERT(iovs[3].iov_len == ISCSI_DIGEST_LEN); 1257 CU_ASSERT(mapped_length == ISCSI_BHS_LEN / 2 + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN); 1258 1259 pdu.writev_offset = ISCSI_BHS_LEN; 1260 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1261 CU_ASSERT(rc == 3); 1262 CU_ASSERT(iovs[0].iov_base == (void *)pdu.header_digest); 1263 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN); 1264 CU_ASSERT(iovs[1].iov_base == (void *)pdu.data); 1265 CU_ASSERT(iovs[1].iov_len == 512); 1266 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data_digest); 1267 CU_ASSERT(iovs[2].iov_len == ISCSI_DIGEST_LEN); 1268 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN); 1269 1270 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN / 2; 1271 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1272 CU_ASSERT(rc == 3); 1273 CU_ASSERT(iovs[0].iov_base == (void *)((uint8_t *)pdu.header_digest + ISCSI_DIGEST_LEN / 2)); 1274 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN / 2); 1275 CU_ASSERT(iovs[1].iov_base == (void *)pdu.data); 1276 CU_ASSERT(iovs[1].iov_len == 512); 1277 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data_digest); 1278 CU_ASSERT(iovs[2].iov_len == ISCSI_DIGEST_LEN); 1279 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN / 2 + 512 + ISCSI_DIGEST_LEN); 1280 1281 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN; 1282 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1283 CU_ASSERT(rc == 2); 1284 CU_ASSERT(iovs[0].iov_base == (void *)pdu.data); 1285 CU_ASSERT(iovs[0].iov_len == 512); 1286 CU_ASSERT(iovs[1].iov_base == (void *)pdu.data_digest); 1287 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1288 CU_ASSERT(mapped_length == 512 + ISCSI_DIGEST_LEN); 1289 1290 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512; 1291 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1292 CU_ASSERT(rc == 1); 1293 CU_ASSERT(iovs[0].iov_base == (void *)pdu.data_digest); 1294 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN); 1295 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN); 1296 1297 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN / 2; 1298 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1299 CU_ASSERT(rc == 1); 1300 CU_ASSERT(iovs[0].iov_base == (void *)((uint8_t *)pdu.data_digest + ISCSI_DIGEST_LEN / 2)); 1301 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN / 2); 1302 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN / 2); 1303 1304 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN; 1305 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1306 CU_ASSERT(rc == 0); 1307 CU_ASSERT(mapped_length == 0); 1308 1309 pdu.writev_offset = 0; 1310 rc = spdk_iscsi_build_iovs(&conn, iovs, 1, &pdu, &mapped_length); 1311 CU_ASSERT(rc == 1); 1312 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1313 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1314 CU_ASSERT(mapped_length == ISCSI_BHS_LEN); 1315 1316 rc = spdk_iscsi_build_iovs(&conn, iovs, 2, &pdu, &mapped_length); 1317 CU_ASSERT(rc == 2); 1318 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1319 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1320 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1321 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1322 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN); 1323 1324 rc = spdk_iscsi_build_iovs(&conn, iovs, 3, &pdu, &mapped_length); 1325 CU_ASSERT(rc == 3); 1326 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1327 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1328 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1329 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1330 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data); 1331 CU_ASSERT(iovs[2].iov_len == 512); 1332 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512); 1333 1334 rc = spdk_iscsi_build_iovs(&conn, iovs, 4, &pdu, &mapped_length); 1335 CU_ASSERT(rc == 4); 1336 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1337 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1338 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1339 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1340 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data); 1341 CU_ASSERT(iovs[2].iov_len == 512); 1342 CU_ASSERT(iovs[3].iov_base == (void *)pdu.data_digest); 1343 CU_ASSERT(iovs[3].iov_len == ISCSI_DIGEST_LEN); 1344 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN); 1345 1346 free(data); 1347 } 1348 1349 int 1350 main(int argc, char **argv) 1351 { 1352 CU_pSuite suite = NULL; 1353 unsigned int num_failures; 1354 1355 if (CU_initialize_registry() != CUE_SUCCESS) { 1356 return CU_get_error(); 1357 } 1358 1359 suite = CU_add_suite("iscsi_suite", NULL, NULL); 1360 if (suite == NULL) { 1361 CU_cleanup_registry(); 1362 return CU_get_error(); 1363 } 1364 1365 if ( 1366 CU_add_test(suite, "login check target test", op_login_check_target_test) == NULL 1367 || CU_add_test(suite, "maxburstlength test", maxburstlength_test) == NULL 1368 || CU_add_test(suite, "underflow for read transfer test", 1369 underflow_for_read_transfer_test) == NULL 1370 || CU_add_test(suite, "underflow for zero read transfer test", 1371 underflow_for_zero_read_transfer_test) == NULL 1372 || CU_add_test(suite, "underflow for request sense test", 1373 underflow_for_request_sense_test) == NULL 1374 || CU_add_test(suite, "underflow for check condition test", 1375 underflow_for_check_condition_test) == NULL 1376 || CU_add_test(suite, "add transfer task test", add_transfer_task_test) == NULL 1377 || CU_add_test(suite, "get transfer task test", get_transfer_task_test) == NULL 1378 || CU_add_test(suite, "del transfer task test", del_transfer_task_test) == NULL 1379 || CU_add_test(suite, "clear all transfer tasks test", 1380 clear_all_transfer_tasks_test) == NULL 1381 || CU_add_test(suite, "abort_queued_datain_task_test", 1382 abort_queued_datain_task_test) == NULL 1383 || CU_add_test(suite, "abort_queued_datain_tasks_test", 1384 abort_queued_datain_tasks_test) == NULL 1385 || CU_add_test(suite, "build_iovs_test", build_iovs_test) == NULL 1386 ) { 1387 CU_cleanup_registry(); 1388 return CU_get_error(); 1389 } 1390 1391 CU_basic_set_mode(CU_BRM_VERBOSE); 1392 CU_basic_run_tests(); 1393 num_failures = CU_get_number_of_failures(); 1394 CU_cleanup_registry(); 1395 return num_failures; 1396 } 1397