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