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