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 .mutex = PTHREAD_MUTEX_INITIALIZER 59 }; 60 61 struct spdk_iscsi_tgt_node * 62 iscsi_find_tgt_node(const char *target_name) 63 { 64 if (strcasecmp(target_name, UT_TARGET_NAME1) == 0) { 65 g_tgt.dev = NULL; 66 return (struct spdk_iscsi_tgt_node *)&g_tgt; 67 } else { 68 return NULL; 69 } 70 } 71 72 bool 73 iscsi_tgt_node_access(struct spdk_iscsi_conn *conn, 74 struct spdk_iscsi_tgt_node *target, 75 const char *iqn, const char *addr) 76 { 77 if (strcasecmp(conn->initiator_name, UT_INITIATOR_NAME1) == 0) { 78 return true; 79 } else { 80 return false; 81 } 82 } 83 84 DEFINE_STUB(iscsi_tgt_node_is_redirected, bool, 85 (struct spdk_iscsi_conn *conn, struct spdk_iscsi_tgt_node *target, 86 char *buf, int buf_len), 87 false); 88 89 DEFINE_STUB(iscsi_send_tgts, int, 90 (struct spdk_iscsi_conn *conn, const char *iiqn, 91 const char *tiqn, uint8_t *data, int alloc_len, int data_len), 92 0); 93 94 DEFINE_STUB(iscsi_tgt_node_is_destructed, bool, 95 (struct spdk_iscsi_tgt_node *target), false); 96 97 DEFINE_STUB_V(iscsi_portal_grp_close_all, (void)); 98 99 DEFINE_STUB_V(iscsi_conn_schedule, (struct spdk_iscsi_conn *conn)); 100 101 DEFINE_STUB_V(iscsi_conn_free_pdu, 102 (struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu)); 103 104 DEFINE_STUB_V(iscsi_conn_pdu_generic_complete, (void *cb_arg)); 105 106 DEFINE_STUB(iscsi_conn_handle_queued_datain_tasks, int, 107 (struct spdk_iscsi_conn *conn), 0); 108 109 DEFINE_STUB(iscsi_conn_abort_queued_datain_task, int, 110 (struct spdk_iscsi_conn *conn, uint32_t ref_task_tag), 0); 111 112 DEFINE_STUB(iscsi_conn_abort_queued_datain_tasks, int, 113 (struct spdk_iscsi_conn *conn, struct spdk_scsi_lun *lun, 114 struct spdk_iscsi_pdu *pdu), 0); 115 116 DEFINE_STUB(iscsi_chap_get_authinfo, int, 117 (struct iscsi_chap_auth *auth, const char *authuser, int ag_tag), 118 0); 119 120 DEFINE_STUB(spdk_sock_set_recvbuf, int, (struct spdk_sock *sock, int sz), 0); 121 122 int 123 spdk_scsi_lun_get_id(const struct spdk_scsi_lun *lun) 124 { 125 return lun->id; 126 } 127 128 DEFINE_STUB(spdk_scsi_lun_is_removing, bool, (const struct spdk_scsi_lun *lun), 129 true); 130 131 struct spdk_scsi_lun * 132 spdk_scsi_dev_get_lun(struct spdk_scsi_dev *dev, int lun_id) 133 { 134 struct spdk_scsi_lun *lun; 135 136 TAILQ_FOREACH(lun, &dev->luns, tailq) { 137 if (lun->id == lun_id) { 138 break; 139 } 140 } 141 142 return lun; 143 } 144 145 DEFINE_STUB(spdk_scsi_lun_id_int_to_fmt, uint64_t, (int lun_id), 0); 146 147 DEFINE_STUB(spdk_scsi_lun_id_fmt_to_int, int, (uint64_t lun_fmt), 0); 148 149 DEFINE_STUB(spdk_scsi_lun_get_dif_ctx, bool, 150 (struct spdk_scsi_lun *lun, struct spdk_scsi_task *task, 151 struct spdk_dif_ctx *dif_ctx), false); 152 153 static void 154 op_login_check_target_test(void) 155 { 156 struct spdk_iscsi_conn conn = {}; 157 struct spdk_iscsi_pdu rsp_pdu = {}; 158 struct spdk_iscsi_tgt_node *target; 159 int rc; 160 161 /* expect success */ 162 snprintf(conn.initiator_name, sizeof(conn.initiator_name), 163 "%s", UT_INITIATOR_NAME1); 164 165 rc = iscsi_op_login_check_target(&conn, &rsp_pdu, 166 UT_TARGET_NAME1, &target); 167 CU_ASSERT(rc == 0); 168 169 /* expect failure */ 170 snprintf(conn.initiator_name, sizeof(conn.initiator_name), 171 "%s", UT_INITIATOR_NAME1); 172 173 rc = iscsi_op_login_check_target(&conn, &rsp_pdu, 174 UT_TARGET_NAME2, &target); 175 CU_ASSERT(rc != 0); 176 177 /* expect failure */ 178 snprintf(conn.initiator_name, sizeof(conn.initiator_name), 179 "%s", UT_INITIATOR_NAME2); 180 181 rc = iscsi_op_login_check_target(&conn, &rsp_pdu, 182 UT_TARGET_NAME1, &target); 183 CU_ASSERT(rc != 0); 184 } 185 186 static void 187 op_login_session_normal_test(void) 188 { 189 struct spdk_iscsi_conn conn = {}; 190 struct spdk_iscsi_portal portal = {}; 191 struct spdk_iscsi_portal_grp group = {}; 192 struct spdk_iscsi_pdu rsp_pdu = {}; 193 struct iscsi_bhs_login_rsp *rsph; 194 struct spdk_iscsi_sess sess = {}; 195 struct iscsi_param param = {}; 196 int rc; 197 198 /* setup related data structures */ 199 rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu.bhs; 200 rsph->tsih = 0; 201 memset(rsph->isid, 0, sizeof(rsph->isid)); 202 conn.portal = &portal; 203 portal.group = &group; 204 conn.portal->group->tag = 0; 205 conn.params = NULL; 206 207 /* expect failure: NULL params for target name */ 208 rc = iscsi_op_login_session_normal(&conn, &rsp_pdu, UT_INITIATOR_NAME1, 209 NULL, 0); 210 CU_ASSERT(rc != 0); 211 CU_ASSERT(rsph->status_class == ISCSI_CLASS_INITIATOR_ERROR); 212 CU_ASSERT(rsph->status_detail == ISCSI_LOGIN_MISSING_PARMS); 213 214 /* expect failure: incorrect key for target name */ 215 param.next = NULL; 216 rc = iscsi_op_login_session_normal(&conn, &rsp_pdu, UT_INITIATOR_NAME1, 217 ¶m, 0); 218 CU_ASSERT(rc != 0); 219 CU_ASSERT(rsph->status_class == ISCSI_CLASS_INITIATOR_ERROR); 220 CU_ASSERT(rsph->status_detail == ISCSI_LOGIN_MISSING_PARMS); 221 222 /* expect failure: NULL target name */ 223 param.key = "TargetName"; 224 param.val = NULL; 225 rc = iscsi_op_login_session_normal(&conn, &rsp_pdu, UT_INITIATOR_NAME1, 226 ¶m, 0); 227 CU_ASSERT(rc != 0); 228 CU_ASSERT(rsph->status_class == ISCSI_CLASS_INITIATOR_ERROR); 229 CU_ASSERT(rsph->status_detail == ISCSI_LOGIN_MISSING_PARMS); 230 231 /* expect failure: session not found */ 232 param.key = "TargetName"; 233 param.val = "iqn.2017-11.spdk.io:t0001"; 234 snprintf(conn.initiator_name, sizeof(conn.initiator_name), 235 "%s", UT_INITIATOR_NAME1); 236 rsph->tsih = 1; /* to append the session */ 237 rc = iscsi_op_login_session_normal(&conn, &rsp_pdu, UT_INITIATOR_NAME1, 238 ¶m, 0); 239 CU_ASSERT(conn.target_port == NULL); 240 CU_ASSERT(rc != 0); 241 CU_ASSERT(rsph->status_class == ISCSI_CLASS_INITIATOR_ERROR); 242 CU_ASSERT(rsph->status_detail == ISCSI_LOGIN_CONN_ADD_FAIL); 243 244 /* expect failure: session found while tag is wrong */ 245 g_iscsi.MaxSessions = UT_ISCSI_TSIH * 2; 246 g_iscsi.session = calloc(1, sizeof(void *) * g_iscsi.MaxSessions); 247 g_iscsi.session[UT_ISCSI_TSIH - 1] = &sess; 248 sess.tsih = UT_ISCSI_TSIH; 249 rsph->tsih = UT_ISCSI_TSIH >> 8; /* to append the session */ 250 sess.tag = 1; 251 rc = iscsi_op_login_session_normal(&conn, &rsp_pdu, UT_INITIATOR_NAME1, 252 ¶m, 0); 253 CU_ASSERT(conn.target_port == NULL); 254 CU_ASSERT(rc != 0); 255 CU_ASSERT(rsph->status_class == ISCSI_CLASS_INITIATOR_ERROR); 256 CU_ASSERT(rsph->status_detail == ISCSI_LOGIN_CONN_ADD_FAIL); 257 258 /* expect suceess: drop the session */ 259 rsph->tsih = 0; /* to create the session */ 260 g_iscsi.AllowDuplicateIsid = false; 261 rc = iscsi_op_login_session_normal(&conn, &rsp_pdu, UT_INITIATOR_NAME1, 262 ¶m, 0); 263 CU_ASSERT(rc == 0); 264 265 /* expect suceess: create the session */ 266 rsph->tsih = 0; /* to create the session */ 267 g_iscsi.AllowDuplicateIsid = true; 268 rc = iscsi_op_login_session_normal(&conn, &rsp_pdu, UT_INITIATOR_NAME1, 269 ¶m, 0); 270 CU_ASSERT(rc == 0); 271 272 free(g_iscsi.session); 273 } 274 275 static void 276 maxburstlength_test(void) 277 { 278 struct spdk_iscsi_sess sess = {}; 279 struct spdk_iscsi_conn conn = {}; 280 struct spdk_scsi_dev dev = {}; 281 struct spdk_scsi_lun lun = {}; 282 struct spdk_iscsi_pdu *req_pdu, *data_out_pdu, *r2t_pdu; 283 struct iscsi_bhs_scsi_req *req; 284 struct iscsi_bhs_r2t *r2t; 285 struct iscsi_bhs_data_out *data_out; 286 struct spdk_iscsi_pdu *response_pdu; 287 int rc; 288 289 g_iscsi.MaxR2TPerConnection = DEFAULT_MAXR2T; 290 291 req_pdu = iscsi_get_pdu(&conn); 292 data_out_pdu = iscsi_get_pdu(&conn); 293 294 sess.ExpCmdSN = 0; 295 sess.MaxCmdSN = 64; 296 sess.session_type = SESSION_TYPE_NORMAL; 297 sess.MaxBurstLength = 1024; 298 299 lun.id = 0; 300 301 TAILQ_INIT(&dev.luns); 302 TAILQ_INSERT_TAIL(&dev.luns, &lun, tailq); 303 304 conn.full_feature = 1; 305 conn.sess = &sess; 306 conn.dev = &dev; 307 conn.state = ISCSI_CONN_STATE_RUNNING; 308 TAILQ_INIT(&conn.write_pdu_list); 309 TAILQ_INIT(&conn.active_r2t_tasks); 310 311 req_pdu->bhs.opcode = ISCSI_OP_SCSI; 312 req_pdu->data_segment_len = 0; 313 314 req = (struct iscsi_bhs_scsi_req *)&req_pdu->bhs; 315 316 to_be32(&req->cmd_sn, 0); 317 to_be32(&req->expected_data_xfer_len, 1028); 318 to_be32(&req->itt, 0x1234); 319 req->write_bit = 1; 320 req->final_bit = 1; 321 322 rc = iscsi_pdu_hdr_handle(&conn, req_pdu); 323 if (rc == 0 && !req_pdu->is_rejected) { 324 rc = iscsi_pdu_payload_handle(&conn, req_pdu); 325 } 326 CU_ASSERT(rc == 0); 327 328 response_pdu = TAILQ_FIRST(&g_write_pdu_list); 329 SPDK_CU_ASSERT_FATAL(response_pdu != NULL); 330 331 /* 332 * Confirm that a correct R2T reply was sent in response to the 333 * SCSI request. 334 */ 335 TAILQ_REMOVE(&g_write_pdu_list, response_pdu, tailq); 336 CU_ASSERT(response_pdu->bhs.opcode == ISCSI_OP_R2T); 337 r2t = (struct iscsi_bhs_r2t *)&response_pdu->bhs; 338 CU_ASSERT(from_be32(&r2t->desired_xfer_len) == 1024); 339 CU_ASSERT(from_be32(&r2t->buffer_offset) == 0); 340 CU_ASSERT(from_be32(&r2t->itt) == 0x1234); 341 342 data_out_pdu->bhs.opcode = ISCSI_OP_SCSI_DATAOUT; 343 data_out_pdu->bhs.flags = ISCSI_FLAG_FINAL; 344 data_out_pdu->data_segment_len = 1028; 345 data_out = (struct iscsi_bhs_data_out *)&data_out_pdu->bhs; 346 data_out->itt = r2t->itt; 347 data_out->ttt = r2t->ttt; 348 DSET24(data_out->data_segment_len, 1028); 349 350 rc = iscsi_pdu_hdr_handle(&conn, data_out_pdu); 351 if (rc == 0 && !data_out_pdu->is_rejected) { 352 rc = iscsi_pdu_payload_handle(&conn, data_out_pdu); 353 } 354 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 355 356 SPDK_CU_ASSERT_FATAL(response_pdu->task != NULL); 357 iscsi_task_disassociate_pdu(response_pdu->task); 358 iscsi_task_put(response_pdu->task); 359 iscsi_put_pdu(response_pdu); 360 361 r2t_pdu = TAILQ_FIRST(&g_write_pdu_list); 362 CU_ASSERT(r2t_pdu != NULL); 363 TAILQ_REMOVE(&g_write_pdu_list, r2t_pdu, tailq); 364 iscsi_put_pdu(r2t_pdu); 365 366 iscsi_put_pdu(data_out_pdu); 367 iscsi_put_pdu(req_pdu); 368 } 369 370 static void 371 underflow_for_read_transfer_test(void) 372 { 373 struct spdk_iscsi_sess sess = {}; 374 struct spdk_iscsi_conn conn = {}; 375 struct spdk_iscsi_task task = {}; 376 struct spdk_scsi_dev dev = {}; 377 struct spdk_scsi_lun lun = {}; 378 struct spdk_iscsi_pdu *pdu; 379 struct iscsi_bhs_scsi_req *scsi_req; 380 struct iscsi_bhs_data_in *datah; 381 uint32_t residual_count = 0; 382 383 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; 384 385 conn.sess = &sess; 386 conn.MaxRecvDataSegmentLength = 8192; 387 388 TAILQ_INIT(&dev.luns); 389 TAILQ_INSERT_TAIL(&dev.luns, &lun, tailq); 390 conn.dev = &dev; 391 392 pdu = iscsi_get_pdu(&conn); 393 SPDK_CU_ASSERT_FATAL(pdu != NULL); 394 395 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu->bhs; 396 scsi_req->read_bit = 1; 397 398 iscsi_task_set_pdu(&task, pdu); 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 task.scsi.data_transferred = 256; 407 task.scsi.status = SPDK_SCSI_STATUS_GOOD; 408 409 iscsi_task_response(&conn, &task); 410 iscsi_put_pdu(pdu); 411 412 /* 413 * In this case, a SCSI Data-In PDU should contain the Status 414 * for the data transfer. 415 */ 416 to_be32(&residual_count, 256); 417 418 pdu = TAILQ_FIRST(&g_write_pdu_list); 419 SPDK_CU_ASSERT_FATAL(pdu != NULL); 420 421 CU_ASSERT(pdu->bhs.opcode == ISCSI_OP_SCSI_DATAIN); 422 423 datah = (struct iscsi_bhs_data_in *)&pdu->bhs; 424 425 CU_ASSERT(datah->flags == (ISCSI_DATAIN_UNDERFLOW | ISCSI_FLAG_FINAL | ISCSI_DATAIN_STATUS)); 426 CU_ASSERT(datah->res_cnt == residual_count); 427 428 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 429 iscsi_put_pdu(pdu); 430 431 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list)); 432 } 433 434 static void 435 underflow_for_zero_read_transfer_test(void) 436 { 437 struct spdk_iscsi_sess sess = {}; 438 struct spdk_iscsi_conn conn = {}; 439 struct spdk_iscsi_task task = {}; 440 struct spdk_scsi_dev dev = {}; 441 struct spdk_scsi_lun lun = {}; 442 struct spdk_iscsi_pdu *pdu; 443 struct iscsi_bhs_scsi_req *scsi_req; 444 struct iscsi_bhs_scsi_resp *resph; 445 uint32_t residual_count = 0, data_segment_len; 446 447 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; 448 449 conn.sess = &sess; 450 conn.MaxRecvDataSegmentLength = 8192; 451 452 TAILQ_INIT(&dev.luns); 453 TAILQ_INSERT_TAIL(&dev.luns, &lun, tailq); 454 conn.dev = &dev; 455 456 pdu = iscsi_get_pdu(&conn); 457 SPDK_CU_ASSERT_FATAL(pdu != NULL); 458 459 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu->bhs; 460 scsi_req->read_bit = 1; 461 462 iscsi_task_set_pdu(&task, pdu); 463 task.parent = NULL; 464 465 task.scsi.length = 512; 466 task.scsi.transfer_len = 512; 467 task.bytes_completed = 512; 468 task.scsi.data_transferred = 0; 469 task.scsi.status = SPDK_SCSI_STATUS_GOOD; 470 471 iscsi_task_response(&conn, &task); 472 iscsi_put_pdu(pdu); 473 474 /* 475 * In this case, only a SCSI Response PDU is expected and 476 * underflow must be set in it. 477 * */ 478 to_be32(&residual_count, 512); 479 480 pdu = TAILQ_FIRST(&g_write_pdu_list); 481 SPDK_CU_ASSERT_FATAL(pdu != NULL); 482 483 CU_ASSERT(pdu->bhs.opcode == ISCSI_OP_SCSI_RSP); 484 485 resph = (struct iscsi_bhs_scsi_resp *)&pdu->bhs; 486 487 CU_ASSERT(resph->flags == (ISCSI_SCSI_UNDERFLOW | 0x80)); 488 489 data_segment_len = DGET24(resph->data_segment_len); 490 CU_ASSERT(data_segment_len == 0); 491 CU_ASSERT(resph->res_cnt == residual_count); 492 493 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 494 iscsi_put_pdu(pdu); 495 496 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list)); 497 } 498 499 static void 500 underflow_for_request_sense_test(void) 501 { 502 struct spdk_iscsi_sess sess = {}; 503 struct spdk_iscsi_conn conn = {}; 504 struct spdk_iscsi_task task = {}; 505 struct spdk_scsi_dev dev = {}; 506 struct spdk_scsi_lun lun = {}; 507 struct spdk_iscsi_pdu *pdu1, *pdu2; 508 struct iscsi_bhs_scsi_req *scsi_req; 509 struct iscsi_bhs_data_in *datah; 510 struct iscsi_bhs_scsi_resp *resph; 511 uint32_t residual_count = 0, data_segment_len; 512 513 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; 514 515 conn.sess = &sess; 516 conn.MaxRecvDataSegmentLength = 8192; 517 518 TAILQ_INIT(&dev.luns); 519 TAILQ_INSERT_TAIL(&dev.luns, &lun, tailq); 520 conn.dev = &dev; 521 522 pdu1 = iscsi_get_pdu(&conn); 523 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 524 525 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu1->bhs; 526 scsi_req->read_bit = 1; 527 528 iscsi_task_set_pdu(&task, pdu1); 529 task.parent = NULL; 530 531 task.scsi.iovs = &task.scsi.iov; 532 task.scsi.iovcnt = 1; 533 task.scsi.length = 512; 534 task.scsi.transfer_len = 512; 535 task.bytes_completed = 512; 536 537 task.scsi.sense_data_len = 18; 538 task.scsi.data_transferred = 18; 539 task.scsi.status = SPDK_SCSI_STATUS_GOOD; 540 541 iscsi_task_response(&conn, &task); 542 iscsi_put_pdu(pdu1); 543 544 /* 545 * In this case, a SCSI Data-In PDU and a SCSI Response PDU are returned. 546 * Sense data are set both in payload and sense area. 547 * The SCSI Data-In PDU sets FINAL and the SCSI Response PDU sets UNDERFLOW. 548 * 549 * Probably there will be different implementation but keeping current SPDK 550 * implementation by adding UT will be valuable for any implementation. 551 */ 552 to_be32(&residual_count, 494); 553 554 pdu1 = TAILQ_FIRST(&g_write_pdu_list); 555 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 556 557 CU_ASSERT(pdu1->bhs.opcode == ISCSI_OP_SCSI_DATAIN); 558 559 datah = (struct iscsi_bhs_data_in *)&pdu1->bhs; 560 561 CU_ASSERT(datah->flags == ISCSI_FLAG_FINAL); 562 563 data_segment_len = DGET24(datah->data_segment_len); 564 CU_ASSERT(data_segment_len == 18); 565 CU_ASSERT(datah->res_cnt == 0); 566 567 TAILQ_REMOVE(&g_write_pdu_list, pdu1, tailq); 568 iscsi_put_pdu(pdu1); 569 570 pdu2 = TAILQ_FIRST(&g_write_pdu_list); 571 /* inform scan-build (clang 6) that these pointers are not the same */ 572 SPDK_CU_ASSERT_FATAL(pdu1 != pdu2); 573 SPDK_CU_ASSERT_FATAL(pdu2 != NULL); 574 575 CU_ASSERT(pdu2->bhs.opcode == ISCSI_OP_SCSI_RSP); 576 577 resph = (struct iscsi_bhs_scsi_resp *)&pdu2->bhs; 578 579 CU_ASSERT(resph->flags == (ISCSI_SCSI_UNDERFLOW | 0x80)); 580 581 data_segment_len = DGET24(resph->data_segment_len); 582 CU_ASSERT(data_segment_len == task.scsi.sense_data_len + 2); 583 CU_ASSERT(resph->res_cnt == residual_count); 584 585 TAILQ_REMOVE(&g_write_pdu_list, pdu2, tailq); 586 iscsi_put_pdu(pdu2); 587 588 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list)); 589 } 590 591 static void 592 underflow_for_check_condition_test(void) 593 { 594 struct spdk_iscsi_sess sess = {}; 595 struct spdk_iscsi_conn conn = {}; 596 struct spdk_iscsi_task task = {}; 597 struct spdk_scsi_dev dev = {}; 598 struct spdk_scsi_lun lun = {}; 599 struct spdk_iscsi_pdu *pdu; 600 struct iscsi_bhs_scsi_req *scsi_req; 601 struct iscsi_bhs_scsi_resp *resph; 602 uint32_t data_segment_len; 603 604 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; 605 606 conn.sess = &sess; 607 conn.MaxRecvDataSegmentLength = 8192; 608 609 TAILQ_INIT(&dev.luns); 610 TAILQ_INSERT_TAIL(&dev.luns, &lun, tailq); 611 conn.dev = &dev; 612 613 pdu = iscsi_get_pdu(&conn); 614 SPDK_CU_ASSERT_FATAL(pdu != NULL); 615 616 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu->bhs; 617 scsi_req->read_bit = 1; 618 619 iscsi_task_set_pdu(&task, pdu); 620 task.parent = NULL; 621 622 task.scsi.iovs = &task.scsi.iov; 623 task.scsi.iovcnt = 1; 624 task.scsi.length = 512; 625 task.scsi.transfer_len = 512; 626 task.bytes_completed = 512; 627 628 task.scsi.sense_data_len = 18; 629 task.scsi.data_transferred = 18; 630 task.scsi.status = SPDK_SCSI_STATUS_CHECK_CONDITION; 631 632 iscsi_task_response(&conn, &task); 633 iscsi_put_pdu(pdu); 634 635 /* 636 * In this case, a SCSI Response PDU is returned. 637 * Sense data is set in sense area. 638 * Underflow is not set. 639 */ 640 pdu = TAILQ_FIRST(&g_write_pdu_list); 641 SPDK_CU_ASSERT_FATAL(pdu != NULL); 642 643 CU_ASSERT(pdu->bhs.opcode == ISCSI_OP_SCSI_RSP); 644 645 resph = (struct iscsi_bhs_scsi_resp *)&pdu->bhs; 646 647 CU_ASSERT(resph->flags == 0x80); 648 649 data_segment_len = DGET24(resph->data_segment_len); 650 CU_ASSERT(data_segment_len == task.scsi.sense_data_len + 2); 651 CU_ASSERT(resph->res_cnt == 0); 652 653 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 654 iscsi_put_pdu(pdu); 655 656 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list)); 657 } 658 659 static void 660 add_transfer_task_test(void) 661 { 662 struct spdk_iscsi_sess sess = {}; 663 struct spdk_iscsi_conn conn = {}; 664 struct spdk_iscsi_task task = {}; 665 struct spdk_iscsi_pdu *pdu, *tmp; 666 struct iscsi_bhs_r2t *r2th; 667 int rc, count = 0; 668 uint32_t buffer_offset, desired_xfer_len; 669 670 g_iscsi.MaxR2TPerConnection = DEFAULT_MAXR2T; 671 672 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; /* 1M */ 673 sess.MaxOutstandingR2T = DEFAULT_MAXR2T; /* 4 */ 674 675 conn.sess = &sess; 676 TAILQ_INIT(&conn.queued_r2t_tasks); 677 TAILQ_INIT(&conn.active_r2t_tasks); 678 679 pdu = iscsi_get_pdu(&conn); 680 SPDK_CU_ASSERT_FATAL(pdu != NULL); 681 682 pdu->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; /* 64K */ 683 task.scsi.transfer_len = 16 * 1024 * 1024; 684 iscsi_task_set_pdu(&task, pdu); 685 686 /* The following tests if the task is queued because R2T tasks are full. */ 687 conn.pending_r2t = DEFAULT_MAXR2T; 688 689 rc = add_transfer_task(&conn, &task); 690 691 CU_ASSERT(rc == 0); 692 CU_ASSERT(TAILQ_FIRST(&conn.queued_r2t_tasks) == &task); 693 694 TAILQ_REMOVE(&conn.queued_r2t_tasks, &task, link); 695 CU_ASSERT(TAILQ_EMPTY(&conn.queued_r2t_tasks)); 696 697 /* The following tests if multiple R2Ts are issued. */ 698 conn.pending_r2t = 0; 699 700 rc = add_transfer_task(&conn, &task); 701 702 CU_ASSERT(rc == 0); 703 CU_ASSERT(TAILQ_FIRST(&conn.active_r2t_tasks) == &task); 704 705 TAILQ_REMOVE(&conn.active_r2t_tasks, &task, link); 706 CU_ASSERT(TAILQ_EMPTY(&conn.active_r2t_tasks)); 707 708 CU_ASSERT(conn.data_out_cnt == 255); 709 CU_ASSERT(conn.pending_r2t == 1); 710 CU_ASSERT(conn.ttt == 1); 711 712 CU_ASSERT(task.data_out_cnt == 255); 713 CU_ASSERT(task.ttt == 1); 714 CU_ASSERT(task.outstanding_r2t == sess.MaxOutstandingR2T); 715 CU_ASSERT(task.next_r2t_offset == 716 pdu->data_segment_len + sess.MaxBurstLength * sess.MaxOutstandingR2T); 717 718 719 while (!TAILQ_EMPTY(&g_write_pdu_list)) { 720 tmp = TAILQ_FIRST(&g_write_pdu_list); 721 TAILQ_REMOVE(&g_write_pdu_list, tmp, tailq); 722 723 r2th = (struct iscsi_bhs_r2t *)&tmp->bhs; 724 725 buffer_offset = from_be32(&r2th->buffer_offset); 726 CU_ASSERT(buffer_offset == pdu->data_segment_len + sess.MaxBurstLength * count); 727 728 desired_xfer_len = from_be32(&r2th->desired_xfer_len); 729 CU_ASSERT(desired_xfer_len == sess.MaxBurstLength); 730 731 iscsi_put_pdu(tmp); 732 count++; 733 } 734 735 CU_ASSERT(count == DEFAULT_MAXR2T); 736 737 iscsi_put_pdu(pdu); 738 } 739 740 static void 741 get_transfer_task_test(void) 742 { 743 struct spdk_iscsi_sess sess = {}; 744 struct spdk_iscsi_conn conn = {}; 745 struct spdk_iscsi_task task1 = {}, task2 = {}, *task; 746 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu; 747 int rc; 748 749 sess.MaxBurstLength = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 750 sess.MaxOutstandingR2T = 1; 751 752 conn.sess = &sess; 753 TAILQ_INIT(&conn.active_r2t_tasks); 754 755 pdu1 = iscsi_get_pdu(&conn); 756 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 757 758 pdu1->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 759 task1.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 760 iscsi_task_set_pdu(&task1, pdu1); 761 762 rc = add_transfer_task(&conn, &task1); 763 CU_ASSERT(rc == 0); 764 765 pdu2 = iscsi_get_pdu(&conn); 766 SPDK_CU_ASSERT_FATAL(pdu2 != NULL); 767 768 pdu2->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 769 task2.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 770 iscsi_task_set_pdu(&task2, pdu2); 771 772 rc = add_transfer_task(&conn, &task2); 773 CU_ASSERT(rc == 0); 774 775 task = get_transfer_task(&conn, 1); 776 CU_ASSERT(task == &task1); 777 778 task = get_transfer_task(&conn, 2); 779 CU_ASSERT(task == &task2); 780 781 while (!TAILQ_EMPTY(&conn.active_r2t_tasks)) { 782 task = TAILQ_FIRST(&conn.active_r2t_tasks); 783 TAILQ_REMOVE(&conn.active_r2t_tasks, task, link); 784 } 785 786 while (!TAILQ_EMPTY(&g_write_pdu_list)) { 787 pdu = TAILQ_FIRST(&g_write_pdu_list); 788 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 789 iscsi_put_pdu(pdu); 790 } 791 792 iscsi_put_pdu(pdu2); 793 iscsi_put_pdu(pdu1); 794 } 795 796 static void 797 del_transfer_task_test(void) 798 { 799 struct spdk_iscsi_sess sess = {}; 800 struct spdk_iscsi_conn conn = {}; 801 struct spdk_iscsi_task *task1, *task2, *task3, *task4, *task5; 802 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu3, *pdu4, *pdu5, *pdu; 803 int rc; 804 805 sess.MaxBurstLength = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 806 sess.MaxOutstandingR2T = 1; 807 808 conn.sess = &sess; 809 TAILQ_INIT(&conn.active_r2t_tasks); 810 TAILQ_INIT(&conn.queued_r2t_tasks); 811 812 pdu1 = iscsi_get_pdu(&conn); 813 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 814 815 pdu1->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 816 817 task1 = iscsi_task_get(&conn, NULL, NULL); 818 SPDK_CU_ASSERT_FATAL(task1 != NULL); 819 820 task1->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 821 iscsi_task_set_pdu(task1, pdu1); 822 task1->tag = 11; 823 824 rc = add_transfer_task(&conn, task1); 825 CU_ASSERT(rc == 0); 826 827 pdu2 = iscsi_get_pdu(&conn); 828 SPDK_CU_ASSERT_FATAL(pdu2 != NULL); 829 830 pdu2->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 831 832 task2 = iscsi_task_get(&conn, NULL, NULL); 833 SPDK_CU_ASSERT_FATAL(task2 != NULL); 834 835 task2->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 836 iscsi_task_set_pdu(task2, pdu2); 837 task2->tag = 12; 838 839 rc = add_transfer_task(&conn, task2); 840 CU_ASSERT(rc == 0); 841 842 pdu3 = iscsi_get_pdu(&conn); 843 SPDK_CU_ASSERT_FATAL(pdu3 != NULL); 844 845 pdu3->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 846 847 task3 = iscsi_task_get(&conn, NULL, NULL); 848 SPDK_CU_ASSERT_FATAL(task3 != NULL); 849 850 task3->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 851 iscsi_task_set_pdu(task3, pdu3); 852 task3->tag = 13; 853 854 rc = add_transfer_task(&conn, task3); 855 CU_ASSERT(rc == 0); 856 857 pdu4 = iscsi_get_pdu(&conn); 858 SPDK_CU_ASSERT_FATAL(pdu4 != NULL); 859 860 pdu4->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 861 862 task4 = iscsi_task_get(&conn, NULL, NULL); 863 SPDK_CU_ASSERT_FATAL(task4 != NULL); 864 865 task4->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 866 iscsi_task_set_pdu(task4, pdu4); 867 task4->tag = 14; 868 869 rc = add_transfer_task(&conn, task4); 870 CU_ASSERT(rc == 0); 871 872 pdu5 = iscsi_get_pdu(&conn); 873 SPDK_CU_ASSERT_FATAL(pdu5 != NULL); 874 875 pdu5->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 876 877 task5 = iscsi_task_get(&conn, NULL, NULL); 878 SPDK_CU_ASSERT_FATAL(task5 != NULL); 879 880 task5->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 881 iscsi_task_set_pdu(task5, pdu5); 882 task5->tag = 15; 883 884 rc = add_transfer_task(&conn, task5); 885 CU_ASSERT(rc == 0); 886 887 CU_ASSERT(get_transfer_task(&conn, 1) == task1); 888 CU_ASSERT(get_transfer_task(&conn, 5) == NULL); 889 iscsi_del_transfer_task(&conn, 11); 890 CU_ASSERT(get_transfer_task(&conn, 1) == NULL); 891 CU_ASSERT(get_transfer_task(&conn, 5) == task5); 892 893 CU_ASSERT(get_transfer_task(&conn, 2) == task2); 894 iscsi_del_transfer_task(&conn, 12); 895 CU_ASSERT(get_transfer_task(&conn, 2) == NULL); 896 897 CU_ASSERT(get_transfer_task(&conn, 3) == task3); 898 iscsi_del_transfer_task(&conn, 13); 899 CU_ASSERT(get_transfer_task(&conn, 3) == NULL); 900 901 CU_ASSERT(get_transfer_task(&conn, 4) == task4); 902 iscsi_del_transfer_task(&conn, 14); 903 CU_ASSERT(get_transfer_task(&conn, 4) == NULL); 904 905 CU_ASSERT(get_transfer_task(&conn, 5) == task5); 906 iscsi_del_transfer_task(&conn, 15); 907 CU_ASSERT(get_transfer_task(&conn, 5) == NULL); 908 909 CU_ASSERT(TAILQ_EMPTY(&conn.active_r2t_tasks)); 910 911 while (!TAILQ_EMPTY(&g_write_pdu_list)) { 912 pdu = TAILQ_FIRST(&g_write_pdu_list); 913 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 914 iscsi_put_pdu(pdu); 915 } 916 917 iscsi_put_pdu(pdu5); 918 iscsi_put_pdu(pdu4); 919 iscsi_put_pdu(pdu3); 920 iscsi_put_pdu(pdu2); 921 iscsi_put_pdu(pdu1); 922 } 923 924 static void 925 clear_all_transfer_tasks_test(void) 926 { 927 struct spdk_iscsi_sess sess = {}; 928 struct spdk_iscsi_conn conn = {}; 929 struct spdk_iscsi_task *task1, *task2, *task3, *task4, *task5, *task6; 930 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu3, *pdu4, *pdu5, *pdu6, *pdu; 931 struct spdk_iscsi_pdu *mgmt_pdu1, *mgmt_pdu2; 932 struct spdk_scsi_lun lun1 = {}, lun2 = {}; 933 uint32_t alloc_cmd_sn; 934 int rc; 935 936 sess.MaxBurstLength = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 937 sess.MaxOutstandingR2T = 1; 938 939 conn.sess = &sess; 940 TAILQ_INIT(&conn.active_r2t_tasks); 941 TAILQ_INIT(&conn.queued_r2t_tasks); 942 943 alloc_cmd_sn = 10; 944 945 task1 = iscsi_task_get(&conn, NULL, NULL); 946 SPDK_CU_ASSERT_FATAL(task1 != NULL); 947 pdu1 = iscsi_get_pdu(&conn); 948 SPDK_CU_ASSERT_FATAL(pdu1 != NULL); 949 950 pdu1->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 951 pdu1->cmd_sn = alloc_cmd_sn; 952 alloc_cmd_sn++; 953 task1->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 954 task1->scsi.lun = &lun1; 955 iscsi_task_set_pdu(task1, pdu1); 956 957 rc = add_transfer_task(&conn, task1); 958 CU_ASSERT(rc == 0); 959 960 mgmt_pdu1 = iscsi_get_pdu(&conn); 961 SPDK_CU_ASSERT_FATAL(mgmt_pdu1 != NULL); 962 963 mgmt_pdu1->cmd_sn = alloc_cmd_sn; 964 alloc_cmd_sn++; 965 966 task2 = iscsi_task_get(&conn, NULL, NULL); 967 SPDK_CU_ASSERT_FATAL(task2 != NULL); 968 pdu2 = iscsi_get_pdu(&conn); 969 SPDK_CU_ASSERT_FATAL(pdu2 != NULL); 970 971 pdu2->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 972 pdu2->cmd_sn = alloc_cmd_sn; 973 alloc_cmd_sn++; 974 task2->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 975 task2->scsi.lun = &lun1; 976 iscsi_task_set_pdu(task2, pdu2); 977 978 rc = add_transfer_task(&conn, task2); 979 CU_ASSERT(rc == 0); 980 981 task3 = iscsi_task_get(&conn, NULL, NULL); 982 SPDK_CU_ASSERT_FATAL(task3 != NULL); 983 pdu3 = iscsi_get_pdu(&conn); 984 SPDK_CU_ASSERT_FATAL(pdu3 != NULL); 985 986 pdu3->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 987 pdu3->cmd_sn = alloc_cmd_sn; 988 alloc_cmd_sn++; 989 task3->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 990 task3->scsi.lun = &lun1; 991 iscsi_task_set_pdu(task3, pdu3); 992 993 rc = add_transfer_task(&conn, task3); 994 CU_ASSERT(rc == 0); 995 996 task4 = iscsi_task_get(&conn, NULL, NULL); 997 SPDK_CU_ASSERT_FATAL(task4 != NULL); 998 pdu4 = iscsi_get_pdu(&conn); 999 SPDK_CU_ASSERT_FATAL(pdu4 != NULL); 1000 1001 pdu4->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 1002 pdu4->cmd_sn = alloc_cmd_sn; 1003 alloc_cmd_sn++; 1004 task4->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 1005 task4->scsi.lun = &lun2; 1006 iscsi_task_set_pdu(task4, pdu4); 1007 1008 rc = add_transfer_task(&conn, task4); 1009 CU_ASSERT(rc == 0); 1010 1011 task5 = iscsi_task_get(&conn, NULL, NULL); 1012 SPDK_CU_ASSERT_FATAL(task5 != NULL); 1013 pdu5 = iscsi_get_pdu(&conn); 1014 SPDK_CU_ASSERT_FATAL(pdu5 != NULL); 1015 1016 pdu5->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 1017 pdu5->cmd_sn = alloc_cmd_sn; 1018 alloc_cmd_sn++; 1019 task5->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 1020 task5->scsi.lun = &lun2; 1021 iscsi_task_set_pdu(task5, pdu5); 1022 1023 rc = add_transfer_task(&conn, task5); 1024 CU_ASSERT(rc == 0); 1025 1026 mgmt_pdu2 = iscsi_get_pdu(&conn); 1027 SPDK_CU_ASSERT_FATAL(mgmt_pdu2 != NULL); 1028 1029 mgmt_pdu2->cmd_sn = alloc_cmd_sn; 1030 alloc_cmd_sn++; 1031 1032 task6 = iscsi_task_get(&conn, NULL, NULL); 1033 SPDK_CU_ASSERT_FATAL(task6 != NULL); 1034 pdu6 = iscsi_get_pdu(&conn); 1035 SPDK_CU_ASSERT_FATAL(pdu6 != NULL); 1036 1037 pdu6->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 1038 pdu6->cmd_sn = alloc_cmd_sn; 1039 alloc_cmd_sn++; 1040 task5->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 1041 task6->scsi.lun = &lun2; 1042 iscsi_task_set_pdu(task6, pdu6); 1043 1044 rc = add_transfer_task(&conn, task6); 1045 CU_ASSERT(rc == 0); 1046 1047 CU_ASSERT(conn.ttt == 4); 1048 1049 CU_ASSERT(get_transfer_task(&conn, 1) == task1); 1050 CU_ASSERT(get_transfer_task(&conn, 2) == task2); 1051 CU_ASSERT(get_transfer_task(&conn, 3) == task3); 1052 CU_ASSERT(get_transfer_task(&conn, 4) == task4); 1053 CU_ASSERT(get_transfer_task(&conn, 5) == NULL); 1054 1055 iscsi_clear_all_transfer_task(&conn, &lun1, mgmt_pdu1); 1056 1057 CU_ASSERT(!TAILQ_EMPTY(&conn.queued_r2t_tasks)); 1058 CU_ASSERT(get_transfer_task(&conn, 1) == NULL); 1059 CU_ASSERT(get_transfer_task(&conn, 2) == task2); 1060 CU_ASSERT(get_transfer_task(&conn, 3) == task3); 1061 CU_ASSERT(get_transfer_task(&conn, 4) == task4); 1062 CU_ASSERT(get_transfer_task(&conn, 5) == task5); 1063 CU_ASSERT(get_transfer_task(&conn, 6) == NULL); 1064 1065 iscsi_clear_all_transfer_task(&conn, &lun1, NULL); 1066 1067 CU_ASSERT(TAILQ_EMPTY(&conn.queued_r2t_tasks)); 1068 CU_ASSERT(get_transfer_task(&conn, 1) == NULL); 1069 CU_ASSERT(get_transfer_task(&conn, 2) == NULL); 1070 CU_ASSERT(get_transfer_task(&conn, 3) == NULL); 1071 CU_ASSERT(get_transfer_task(&conn, 4) == task4); 1072 CU_ASSERT(get_transfer_task(&conn, 5) == task5); 1073 CU_ASSERT(get_transfer_task(&conn, 6) == task6); 1074 1075 iscsi_clear_all_transfer_task(&conn, &lun2, mgmt_pdu2); 1076 1077 CU_ASSERT(get_transfer_task(&conn, 4) == NULL); 1078 CU_ASSERT(get_transfer_task(&conn, 5) == NULL); 1079 CU_ASSERT(get_transfer_task(&conn, 6) == task6); 1080 1081 iscsi_clear_all_transfer_task(&conn, NULL, NULL); 1082 1083 CU_ASSERT(get_transfer_task(&conn, 6) == NULL); 1084 1085 CU_ASSERT(TAILQ_EMPTY(&conn.active_r2t_tasks)); 1086 while (!TAILQ_EMPTY(&g_write_pdu_list)) { 1087 pdu = TAILQ_FIRST(&g_write_pdu_list); 1088 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq); 1089 iscsi_put_pdu(pdu); 1090 } 1091 1092 iscsi_put_pdu(mgmt_pdu2); 1093 iscsi_put_pdu(mgmt_pdu1); 1094 iscsi_put_pdu(pdu6); 1095 iscsi_put_pdu(pdu5); 1096 iscsi_put_pdu(pdu4); 1097 iscsi_put_pdu(pdu3); 1098 iscsi_put_pdu(pdu2); 1099 iscsi_put_pdu(pdu1); 1100 } 1101 1102 static void 1103 build_iovs_test(void) 1104 { 1105 struct spdk_iscsi_conn conn = {}; 1106 struct spdk_iscsi_pdu pdu = {}; 1107 struct iovec iovs[5] = {}; 1108 uint8_t *data; 1109 uint32_t mapped_length = 0; 1110 int rc; 1111 1112 conn.header_digest = true; 1113 conn.data_digest = true; 1114 1115 DSET24(&pdu.bhs.data_segment_len, 512); 1116 data = calloc(1, 512); 1117 SPDK_CU_ASSERT_FATAL(data != NULL); 1118 pdu.data = data; 1119 1120 pdu.bhs.total_ahs_len = 0; 1121 pdu.bhs.opcode = ISCSI_OP_SCSI; 1122 1123 pdu.writev_offset = 0; 1124 rc = iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1125 CU_ASSERT(rc == 4); 1126 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1127 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1128 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1129 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1130 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data); 1131 CU_ASSERT(iovs[2].iov_len == 512); 1132 CU_ASSERT(iovs[3].iov_base == (void *)pdu.data_digest); 1133 CU_ASSERT(iovs[3].iov_len == ISCSI_DIGEST_LEN); 1134 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN); 1135 1136 pdu.writev_offset = ISCSI_BHS_LEN / 2; 1137 rc = iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1138 CU_ASSERT(rc == 4); 1139 CU_ASSERT(iovs[0].iov_base == (void *)((uint8_t *)&pdu.bhs + ISCSI_BHS_LEN / 2)); 1140 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN / 2); 1141 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1142 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1143 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data); 1144 CU_ASSERT(iovs[2].iov_len == 512); 1145 CU_ASSERT(iovs[3].iov_base == (void *)pdu.data_digest); 1146 CU_ASSERT(iovs[3].iov_len == ISCSI_DIGEST_LEN); 1147 CU_ASSERT(mapped_length == ISCSI_BHS_LEN / 2 + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN); 1148 1149 pdu.writev_offset = ISCSI_BHS_LEN; 1150 rc = iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1151 CU_ASSERT(rc == 3); 1152 CU_ASSERT(iovs[0].iov_base == (void *)pdu.header_digest); 1153 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN); 1154 CU_ASSERT(iovs[1].iov_base == (void *)pdu.data); 1155 CU_ASSERT(iovs[1].iov_len == 512); 1156 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data_digest); 1157 CU_ASSERT(iovs[2].iov_len == ISCSI_DIGEST_LEN); 1158 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN); 1159 1160 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN / 2; 1161 rc = iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1162 CU_ASSERT(rc == 3); 1163 CU_ASSERT(iovs[0].iov_base == (void *)((uint8_t *)pdu.header_digest + ISCSI_DIGEST_LEN / 2)); 1164 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN / 2); 1165 CU_ASSERT(iovs[1].iov_base == (void *)pdu.data); 1166 CU_ASSERT(iovs[1].iov_len == 512); 1167 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data_digest); 1168 CU_ASSERT(iovs[2].iov_len == ISCSI_DIGEST_LEN); 1169 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN / 2 + 512 + ISCSI_DIGEST_LEN); 1170 1171 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN; 1172 rc = iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1173 CU_ASSERT(rc == 2); 1174 CU_ASSERT(iovs[0].iov_base == (void *)pdu.data); 1175 CU_ASSERT(iovs[0].iov_len == 512); 1176 CU_ASSERT(iovs[1].iov_base == (void *)pdu.data_digest); 1177 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1178 CU_ASSERT(mapped_length == 512 + ISCSI_DIGEST_LEN); 1179 1180 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512; 1181 rc = iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1182 CU_ASSERT(rc == 1); 1183 CU_ASSERT(iovs[0].iov_base == (void *)pdu.data_digest); 1184 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN); 1185 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN); 1186 1187 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN / 2; 1188 rc = iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1189 CU_ASSERT(rc == 1); 1190 CU_ASSERT(iovs[0].iov_base == (void *)((uint8_t *)pdu.data_digest + ISCSI_DIGEST_LEN / 2)); 1191 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN / 2); 1192 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN / 2); 1193 1194 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN; 1195 rc = iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length); 1196 CU_ASSERT(rc == 0); 1197 CU_ASSERT(mapped_length == 0); 1198 1199 pdu.writev_offset = 0; 1200 rc = iscsi_build_iovs(&conn, iovs, 1, &pdu, &mapped_length); 1201 CU_ASSERT(rc == 1); 1202 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1203 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1204 CU_ASSERT(mapped_length == ISCSI_BHS_LEN); 1205 1206 rc = iscsi_build_iovs(&conn, iovs, 2, &pdu, &mapped_length); 1207 CU_ASSERT(rc == 2); 1208 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1209 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1210 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1211 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1212 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN); 1213 1214 rc = iscsi_build_iovs(&conn, iovs, 3, &pdu, &mapped_length); 1215 CU_ASSERT(rc == 3); 1216 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1217 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1218 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1219 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1220 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data); 1221 CU_ASSERT(iovs[2].iov_len == 512); 1222 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512); 1223 1224 rc = iscsi_build_iovs(&conn, iovs, 4, &pdu, &mapped_length); 1225 CU_ASSERT(rc == 4); 1226 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1227 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1228 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1229 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1230 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data); 1231 CU_ASSERT(iovs[2].iov_len == 512); 1232 CU_ASSERT(iovs[3].iov_base == (void *)pdu.data_digest); 1233 CU_ASSERT(iovs[3].iov_len == ISCSI_DIGEST_LEN); 1234 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN); 1235 1236 free(data); 1237 } 1238 1239 static void 1240 build_iovs_with_md_test(void) 1241 { 1242 struct spdk_iscsi_conn conn = {}; 1243 struct spdk_iscsi_pdu pdu = {}; 1244 struct iovec iovs[6] = {}; 1245 uint8_t *data; 1246 uint32_t mapped_length = 0; 1247 int rc; 1248 1249 conn.header_digest = true; 1250 conn.data_digest = true; 1251 1252 DSET24(&pdu.bhs.data_segment_len, 4096 * 2); 1253 data = calloc(1, (4096 + 128) * 2); 1254 SPDK_CU_ASSERT_FATAL(data != NULL); 1255 pdu.data = data; 1256 pdu.data_buf_len = (4096 + 128) * 2; 1257 1258 pdu.bhs.total_ahs_len = 0; 1259 pdu.bhs.opcode = ISCSI_OP_SCSI; 1260 1261 rc = spdk_dif_ctx_init(&pdu.dif_ctx, 4096 + 128, 128, true, false, SPDK_DIF_TYPE1, 1262 0, 0, 0, 0, 0, 0); 1263 CU_ASSERT(rc == 0); 1264 1265 pdu.dif_insert_or_strip = true; 1266 1267 pdu.writev_offset = 0; 1268 rc = iscsi_build_iovs(&conn, iovs, 6, &pdu, &mapped_length); 1269 CU_ASSERT(rc == 5); 1270 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1271 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1272 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1273 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1274 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data); 1275 CU_ASSERT(iovs[2].iov_len == 4096); 1276 CU_ASSERT(iovs[3].iov_base == (void *)(pdu.data + 4096 + 128)); 1277 CU_ASSERT(iovs[3].iov_len == 4096); 1278 CU_ASSERT(iovs[4].iov_base == (void *)pdu.data_digest); 1279 CU_ASSERT(iovs[4].iov_len == ISCSI_DIGEST_LEN); 1280 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 4096 * 2 + ISCSI_DIGEST_LEN); 1281 1282 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 2048; 1283 rc = iscsi_build_iovs(&conn, iovs, 6, &pdu, &mapped_length); 1284 CU_ASSERT(rc == 3); 1285 CU_ASSERT(iovs[0].iov_base == (void *)(pdu.data + 2048)); 1286 CU_ASSERT(iovs[0].iov_len == 2048); 1287 CU_ASSERT(iovs[1].iov_base == (void *)(pdu.data + 4096 + 128)); 1288 CU_ASSERT(iovs[1].iov_len == 4096); 1289 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data_digest); 1290 CU_ASSERT(iovs[2].iov_len == ISCSI_DIGEST_LEN); 1291 CU_ASSERT(mapped_length == 2048 + 4096 + ISCSI_DIGEST_LEN); 1292 1293 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 4096 * 2; 1294 rc = iscsi_build_iovs(&conn, iovs, 6, &pdu, &mapped_length); 1295 CU_ASSERT(rc == 1); 1296 CU_ASSERT(iovs[0].iov_base == (void *)pdu.data_digest); 1297 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN); 1298 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN); 1299 1300 pdu.writev_offset = 0; 1301 rc = iscsi_build_iovs(&conn, iovs, 3, &pdu, &mapped_length); 1302 CU_ASSERT(rc == 3); 1303 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs); 1304 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN); 1305 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest); 1306 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN); 1307 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data); 1308 CU_ASSERT(iovs[2].iov_len == 4096); 1309 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 4096); 1310 1311 free(data); 1312 } 1313 1314 static void 1315 check_iscsi_reject(struct spdk_iscsi_pdu *pdu, uint8_t reason) 1316 { 1317 struct spdk_iscsi_pdu *rsp_pdu; 1318 struct iscsi_bhs_reject *reject_bhs; 1319 1320 CU_ASSERT(pdu->is_rejected == true); 1321 rsp_pdu = TAILQ_FIRST(&g_write_pdu_list); 1322 CU_ASSERT(rsp_pdu != NULL); 1323 reject_bhs = (struct iscsi_bhs_reject *)&rsp_pdu->bhs; 1324 CU_ASSERT(reject_bhs->reason == reason); 1325 1326 TAILQ_REMOVE(&g_write_pdu_list, rsp_pdu, tailq); 1327 iscsi_put_pdu(rsp_pdu); 1328 pdu->is_rejected = false; 1329 } 1330 1331 static void 1332 check_login_response(uint8_t status_class, uint8_t status_detail) 1333 { 1334 struct spdk_iscsi_pdu *rsp_pdu; 1335 struct iscsi_bhs_login_rsp *login_rsph; 1336 1337 rsp_pdu = TAILQ_FIRST(&g_write_pdu_list); 1338 CU_ASSERT(rsp_pdu != NULL); 1339 login_rsph = (struct iscsi_bhs_login_rsp *)&rsp_pdu->bhs; 1340 CU_ASSERT(login_rsph->status_class == status_class); 1341 CU_ASSERT(login_rsph->status_detail == status_detail); 1342 1343 TAILQ_REMOVE(&g_write_pdu_list, rsp_pdu, tailq); 1344 iscsi_put_pdu(rsp_pdu); 1345 } 1346 1347 static void 1348 pdu_hdr_op_login_test(void) 1349 { 1350 struct spdk_iscsi_sess sess = {}; 1351 struct spdk_iscsi_conn conn = {}; 1352 struct spdk_iscsi_pdu pdu = {}; 1353 struct iscsi_bhs_login_req *login_reqh; 1354 int rc; 1355 1356 login_reqh = (struct iscsi_bhs_login_req *)&pdu.bhs; 1357 1358 /* Case 1 - On discovery session, target only accepts text requests with the 1359 * SendTargets key and logout request with reason "close the session". 1360 */ 1361 sess.session_type = SESSION_TYPE_DISCOVERY; 1362 conn.full_feature = true; 1363 conn.sess = &sess; 1364 1365 rc = iscsi_pdu_hdr_op_login(&conn, &pdu); 1366 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1367 1368 /* Case 2 - Data segment length is limited to be not more than 8KB, the default 1369 * FirstBurstLength, for login request. 1370 */ 1371 sess.session_type = SESSION_TYPE_INVALID; 1372 conn.full_feature = false; 1373 conn.sess = NULL; 1374 pdu.data_segment_len = SPDK_ISCSI_FIRST_BURST_LENGTH + 1; 1375 1376 rc = iscsi_pdu_hdr_op_login(&conn, &pdu); 1377 CU_ASSERT(rc == 0); 1378 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1379 1380 /* Case 3 - PDU pool is empty */ 1381 pdu.data_segment_len = SPDK_ISCSI_FIRST_BURST_LENGTH; 1382 g_pdu_pool_is_empty = true; 1383 1384 rc = iscsi_pdu_hdr_op_login(&conn, &pdu); 1385 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1386 1387 /* Case 4 - A login request with the C bit set to 1 must have the T bit set to 0. */ 1388 g_pdu_pool_is_empty = false; 1389 login_reqh->flags |= ISCSI_LOGIN_TRANSIT; 1390 login_reqh->flags |= ISCSI_LOGIN_CONTINUE; 1391 1392 rc = iscsi_pdu_hdr_op_login(&conn, &pdu); 1393 CU_ASSERT(rc == 0); 1394 check_login_response(ISCSI_CLASS_INITIATOR_ERROR, ISCSI_LOGIN_INITIATOR_ERROR); 1395 1396 /* Case 5 - Both version-min and version-max must be set to 0x00. */ 1397 login_reqh->flags = 0; 1398 login_reqh->version_min = ISCSI_VERSION + 1; 1399 1400 rc = iscsi_pdu_hdr_op_login(&conn, &pdu); 1401 CU_ASSERT(rc == 0); 1402 check_login_response(ISCSI_CLASS_INITIATOR_ERROR, ISCSI_LOGIN_UNSUPPORTED_VERSION); 1403 1404 /* Case 6 - T bit is set to 1 correctly but invalid stage code is set to NSG. */ 1405 login_reqh->version_min = ISCSI_VERSION; 1406 login_reqh->flags |= ISCSI_LOGIN_TRANSIT; 1407 login_reqh->flags |= ISCSI_NSG_RESERVED_CODE; 1408 1409 rc = iscsi_pdu_hdr_op_login(&conn, &pdu); 1410 CU_ASSERT(rc == 0); 1411 check_login_response(ISCSI_CLASS_INITIATOR_ERROR, ISCSI_LOGIN_INITIATOR_ERROR); 1412 1413 /* Case 7 - Login request is correct. Login response is initialized and set to 1414 * the current connection. 1415 */ 1416 login_reqh->flags = 0; 1417 1418 rc = iscsi_pdu_hdr_op_login(&conn, &pdu); 1419 CU_ASSERT(rc == 0); 1420 CU_ASSERT(conn.login_rsp_pdu != NULL); 1421 1422 iscsi_put_pdu(conn.login_rsp_pdu); 1423 } 1424 1425 static void 1426 pdu_hdr_op_text_test(void) 1427 { 1428 struct spdk_iscsi_sess sess = {}; 1429 struct spdk_iscsi_conn conn = {}; 1430 struct spdk_iscsi_pdu pdu = {}; 1431 struct iscsi_bhs_text_req *text_reqh; 1432 int rc; 1433 1434 text_reqh = (struct iscsi_bhs_text_req *)&pdu.bhs; 1435 1436 conn.sess = &sess; 1437 1438 /* Case 1 - Data segment length for text request must not be more than 1439 * FirstBurstLength plus extra space to account for digests. 1440 */ 1441 pdu.data_segment_len = iscsi_get_max_immediate_data_size() + 1; 1442 1443 rc = iscsi_pdu_hdr_op_text(&conn, &pdu); 1444 CU_ASSERT(rc == 0); 1445 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1446 1447 /* Case 2 - A text request with the C bit set to 1 must have the F bit set to 0. */ 1448 pdu.data_segment_len = iscsi_get_max_immediate_data_size(); 1449 text_reqh->flags |= ISCSI_FLAG_FINAL; 1450 text_reqh->flags |= ISCSI_TEXT_CONTINUE; 1451 1452 rc = iscsi_pdu_hdr_op_text(&conn, &pdu); 1453 CU_ASSERT(rc == -1); 1454 1455 /* Case 3 - ExpStatSN of the text request is expected to match StatSN of the current 1456 * connection. But StarPort iSCSI initiator didn't follow the expectation. In this 1457 * case we overwrite StatSN by ExpStatSN and processes the request as correct. 1458 */ 1459 text_reqh->flags = 0; 1460 to_be32(&text_reqh->exp_stat_sn, 1234); 1461 to_be32(&conn.StatSN, 4321); 1462 1463 rc = iscsi_pdu_hdr_op_text(&conn, &pdu); 1464 CU_ASSERT(rc == 0); 1465 CU_ASSERT(conn.StatSN == 1234); 1466 1467 /* Case 4 - Text request is the first in the sequence of text requests and responses, 1468 * and so its ITT is hold to the current connection. 1469 */ 1470 sess.current_text_itt = 0xffffffffU; 1471 to_be32(&text_reqh->itt, 5678); 1472 1473 rc = iscsi_pdu_hdr_op_text(&conn, &pdu); 1474 CU_ASSERT(rc == 0); 1475 CU_ASSERT(sess.current_text_itt == 5678); 1476 1477 /* Case 5 - If text request is sent as part of a sequence of text requests and responses, 1478 * its ITT must be the same for all the text requests. But it was not. */ 1479 sess.current_text_itt = 5679; 1480 1481 rc = iscsi_pdu_hdr_op_text(&conn, &pdu); 1482 CU_ASSERT(rc == 0); 1483 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1484 1485 /* Case 6 - Different from case 5, its ITT matches the value saved in the connection. */ 1486 text_reqh->flags = 0; 1487 sess.current_text_itt = 5678; 1488 1489 rc = iscsi_pdu_hdr_op_text(&conn, &pdu); 1490 CU_ASSERT(rc == 0); 1491 } 1492 1493 static void 1494 check_logout_response(uint8_t response, uint32_t stat_sn, uint32_t exp_cmd_sn, 1495 uint32_t max_cmd_sn) 1496 { 1497 struct spdk_iscsi_pdu *rsp_pdu; 1498 struct iscsi_bhs_logout_resp *logout_rsph; 1499 1500 rsp_pdu = TAILQ_FIRST(&g_write_pdu_list); 1501 CU_ASSERT(rsp_pdu != NULL); 1502 logout_rsph = (struct iscsi_bhs_logout_resp *)&rsp_pdu->bhs; 1503 CU_ASSERT(logout_rsph->response == response); 1504 CU_ASSERT(from_be32(&logout_rsph->stat_sn) == stat_sn); 1505 CU_ASSERT(from_be32(&logout_rsph->exp_cmd_sn) == exp_cmd_sn); 1506 CU_ASSERT(from_be32(&logout_rsph->max_cmd_sn) == max_cmd_sn); 1507 1508 TAILQ_REMOVE(&g_write_pdu_list, rsp_pdu, tailq); 1509 iscsi_put_pdu(rsp_pdu); 1510 } 1511 1512 static void 1513 pdu_hdr_op_logout_test(void) 1514 { 1515 struct spdk_iscsi_sess sess = {}; 1516 struct spdk_iscsi_conn conn = {}; 1517 struct spdk_iscsi_pdu pdu = {}; 1518 struct iscsi_bhs_logout_req *logout_reqh; 1519 int rc; 1520 1521 logout_reqh = (struct iscsi_bhs_logout_req *)&pdu.bhs; 1522 1523 /* Case 1 - Target can accept logout request only with the reason "close the session" 1524 * on discovery session. 1525 */ 1526 logout_reqh->reason = 1; 1527 conn.sess = &sess; 1528 sess.session_type = SESSION_TYPE_DISCOVERY; 1529 1530 rc = iscsi_pdu_hdr_op_logout(&conn, &pdu); 1531 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1532 1533 /* Case 2 - Session is not established yet but connection was closed successfully. */ 1534 conn.sess = NULL; 1535 conn.StatSN = 1234; 1536 to_be32(&logout_reqh->exp_stat_sn, 1234); 1537 pdu.cmd_sn = 5678; 1538 1539 rc = iscsi_pdu_hdr_op_logout(&conn, &pdu); 1540 CU_ASSERT(rc == 0); 1541 check_logout_response(0, 1234, 5678, 5678); 1542 CU_ASSERT(conn.StatSN == 1235); 1543 1544 /* Case 3 - Session type is normal but CID was not found. Hence connection or session 1545 * was not closed. 1546 */ 1547 sess.session_type = SESSION_TYPE_NORMAL; 1548 sess.ExpCmdSN = 5679; 1549 sess.connections = 1; 1550 conn.sess = &sess; 1551 conn.cid = 1; 1552 1553 rc = iscsi_pdu_hdr_op_logout(&conn, &pdu); 1554 CU_ASSERT(rc == 0); 1555 check_logout_response(1, 1235, 5679, 1); 1556 CU_ASSERT(conn.StatSN == 1236); 1557 CU_ASSERT(sess.MaxCmdSN == 1); 1558 1559 /* Case 4 - Session type is normal and CID was found. Connection or session was closed 1560 * successfully. 1561 */ 1562 to_be16(&logout_reqh->cid, 1); 1563 1564 rc = iscsi_pdu_hdr_op_logout(&conn, &pdu); 1565 CU_ASSERT(rc == 0); 1566 check_logout_response(0, 1236, 5679, 2); 1567 CU_ASSERT(conn.StatSN == 1237); 1568 CU_ASSERT(sess.MaxCmdSN == 2); 1569 1570 /* Case 5 - PDU pool is empty. */ 1571 g_pdu_pool_is_empty = true; 1572 1573 rc = iscsi_pdu_hdr_op_logout(&conn, &pdu); 1574 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1575 1576 g_pdu_pool_is_empty = false; 1577 } 1578 1579 static void 1580 check_scsi_task(struct spdk_iscsi_pdu *pdu, enum spdk_scsi_data_dir dir) 1581 { 1582 struct spdk_iscsi_task *task; 1583 1584 task = pdu->task; 1585 CU_ASSERT(task != NULL); 1586 CU_ASSERT(task->pdu == pdu); 1587 CU_ASSERT(task->scsi.dxfer_dir == (uint32_t)dir); 1588 1589 iscsi_task_put(task); 1590 pdu->task = NULL; 1591 } 1592 1593 static void 1594 pdu_hdr_op_scsi_test(void) 1595 { 1596 struct spdk_iscsi_sess sess = {}; 1597 struct spdk_iscsi_conn conn = {}; 1598 struct spdk_iscsi_pdu pdu = {}; 1599 struct spdk_scsi_dev dev = {}; 1600 struct spdk_scsi_lun lun = {}; 1601 struct iscsi_bhs_scsi_req *scsi_reqh; 1602 int rc; 1603 1604 scsi_reqh = (struct iscsi_bhs_scsi_req *)&pdu.bhs; 1605 1606 conn.sess = &sess; 1607 conn.dev = &dev; 1608 1609 /* Case 1 - SCSI command is acceptable only on normal session. */ 1610 sess.session_type = SESSION_TYPE_DISCOVERY; 1611 1612 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1613 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1614 1615 /* Case 2 - Task pool is empty. */ 1616 g_task_pool_is_empty = true; 1617 1618 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1619 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1620 1621 g_task_pool_is_empty = false; 1622 1623 /* Case 3 - bidirectional operations (both R and W flags are set to 1) are not supported. */ 1624 sess.session_type = SESSION_TYPE_NORMAL; 1625 scsi_reqh->read_bit = 1; 1626 scsi_reqh->write_bit = 1; 1627 1628 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1629 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1630 1631 /* Case 4 - LUN is hot-removed, and return immediately. */ 1632 scsi_reqh->write_bit = 0; 1633 1634 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1635 CU_ASSERT(rc == 0); 1636 CU_ASSERT(pdu.task == NULL); 1637 1638 /* Case 5 - SCSI read command PDU is correct, and the configured iSCSI task is set to the PDU. */ 1639 TAILQ_INIT(&dev.luns); 1640 TAILQ_INSERT_TAIL(&dev.luns, &lun, tailq); 1641 1642 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1643 CU_ASSERT(rc == 0); 1644 check_scsi_task(&pdu, SPDK_SCSI_DIR_FROM_DEV); 1645 1646 /* Case 6 - For SCSI write command PDU, its data segment length must not be more than 1647 * FirstBurstLength plus extra space to account for digests. 1648 */ 1649 scsi_reqh->read_bit = 0; 1650 scsi_reqh->write_bit = 1; 1651 pdu.data_segment_len = iscsi_get_max_immediate_data_size() + 1; 1652 1653 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1654 CU_ASSERT(rc == 0); 1655 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1656 1657 /* Case 7 - For SCSI write command PDU, its data segment length must not be more than 1658 * Expected Data Transfer Length (EDTL). 1659 */ 1660 pdu.data_segment_len = iscsi_get_max_immediate_data_size(); 1661 to_be32(&scsi_reqh->expected_data_xfer_len, pdu.data_segment_len - 1); 1662 1663 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1664 CU_ASSERT(rc == 0); 1665 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1666 1667 /* Case 8 - If ImmediateData is not enabled for the session, SCSI write command PDU 1668 * cannot have data segment. 1669 */ 1670 to_be32(&scsi_reqh->expected_data_xfer_len, pdu.data_segment_len); 1671 1672 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1673 CU_ASSERT(rc == 0); 1674 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1675 1676 /* Case 9 - For SCSI write command PDU, its data segment length must not be more 1677 * than FirstBurstLength. 1678 */ 1679 sess.ImmediateData = true; 1680 1681 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1682 CU_ASSERT(rc == 0); 1683 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1684 1685 /* Case 10 - SCSI write command PDU is correct, and the configured iSCSI task is set to the PDU. */ 1686 sess.FirstBurstLength = pdu.data_segment_len; 1687 1688 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1689 CU_ASSERT(rc == 0); 1690 check_scsi_task(&pdu, SPDK_SCSI_DIR_TO_DEV); 1691 1692 /* Case 11 - R and W must not both be 0 when EDTL is not 0. */ 1693 scsi_reqh->write_bit = 0; 1694 1695 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1696 CU_ASSERT(rc == 0); 1697 check_iscsi_reject(&pdu, ISCSI_REASON_INVALID_PDU_FIELD); 1698 1699 /* Case 11 - R and W are both 0 and EDTL is also 0, and hence SCSI command PDU is accepted. */ 1700 to_be32(&scsi_reqh->expected_data_xfer_len, 0); 1701 1702 rc = iscsi_pdu_hdr_op_scsi(&conn, &pdu); 1703 CU_ASSERT(rc == 0); 1704 check_scsi_task(&pdu, SPDK_SCSI_DIR_NONE); 1705 } 1706 1707 static void 1708 check_iscsi_task_mgmt_response(uint8_t response, uint32_t task_tag, uint32_t stat_sn, 1709 uint32_t exp_cmd_sn, uint32_t max_cmd_sn) 1710 { 1711 struct spdk_iscsi_pdu *rsp_pdu; 1712 struct iscsi_bhs_task_resp *rsph; 1713 1714 rsp_pdu = TAILQ_FIRST(&g_write_pdu_list); 1715 CU_ASSERT(rsp_pdu != NULL); 1716 rsph = (struct iscsi_bhs_task_resp *)&rsp_pdu->bhs; 1717 CU_ASSERT(rsph->response == response); 1718 CU_ASSERT(from_be32(&rsph->itt) == task_tag); 1719 CU_ASSERT(from_be32(&rsph->exp_cmd_sn) == exp_cmd_sn); 1720 CU_ASSERT(from_be32(&rsph->max_cmd_sn) == max_cmd_sn); 1721 1722 TAILQ_REMOVE(&g_write_pdu_list, rsp_pdu, tailq); 1723 iscsi_put_pdu(rsp_pdu); 1724 } 1725 1726 static void 1727 pdu_hdr_op_task_mgmt_test(void) 1728 { 1729 struct spdk_iscsi_sess sess = {}; 1730 struct spdk_iscsi_conn conn = {}; 1731 struct spdk_iscsi_pdu pdu = {}; 1732 struct spdk_scsi_dev dev = {}; 1733 struct spdk_scsi_lun lun = {}; 1734 struct iscsi_bhs_task_req *task_reqh; 1735 int rc; 1736 1737 /* TBD: This test covers only error paths before creating iSCSI task for now. 1738 * Testing iSCSI task creation in iscsi_pdu_hdr_op_task() by UT is not simple 1739 * and do it separately later. 1740 */ 1741 1742 task_reqh = (struct iscsi_bhs_task_req *)&pdu.bhs; 1743 1744 conn.sess = &sess; 1745 conn.dev = &dev; 1746 1747 /* Case 1 - Task Management Function request PDU is acceptable only on normal session. */ 1748 sess.session_type = SESSION_TYPE_DISCOVERY; 1749 1750 rc = iscsi_pdu_hdr_op_task(&conn, &pdu); 1751 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1752 1753 /* Case 2 - LUN is hot removed. "LUN does not exist" response is sent. */ 1754 sess.session_type = SESSION_TYPE_NORMAL; 1755 task_reqh->immediate = 0; 1756 to_be32(&task_reqh->itt, 1234); 1757 1758 rc = iscsi_pdu_hdr_op_task(&conn, &pdu); 1759 CU_ASSERT(rc == 0); 1760 check_iscsi_task_mgmt_response(ISCSI_TASK_FUNC_RESP_LUN_NOT_EXIST, 1234, 0, 0, 1); 1761 1762 /* Case 3 - Unassigned function is specified. "Function rejected" response is sent. */ 1763 TAILQ_INIT(&dev.luns); 1764 TAILQ_INSERT_TAIL(&dev.luns, &lun, tailq); 1765 task_reqh->flags = 0; 1766 1767 rc = iscsi_pdu_hdr_op_task(&conn, &pdu); 1768 CU_ASSERT(rc == 0); 1769 check_iscsi_task_mgmt_response(ISCSI_TASK_FUNC_REJECTED, 1234, 0, 0, 2); 1770 1771 /* Case 4 - CLEAR TASK SET is not supported. "Task management function not supported" 1772 * response is sent. 1773 */ 1774 task_reqh->flags = ISCSI_TASK_FUNC_CLEAR_TASK_SET; 1775 1776 rc = iscsi_pdu_hdr_op_task(&conn, &pdu); 1777 CU_ASSERT(rc == 0); 1778 check_iscsi_task_mgmt_response(ISCSI_TASK_FUNC_RESP_FUNC_NOT_SUPPORTED, 1234, 0, 0, 3); 1779 1780 /* Case 5 - CLEAR ACA is not supported. "Task management function not supported" is sent. */ 1781 task_reqh->flags = ISCSI_TASK_FUNC_CLEAR_ACA; 1782 1783 rc = iscsi_pdu_hdr_op_task(&conn, &pdu); 1784 CU_ASSERT(rc == 0); 1785 check_iscsi_task_mgmt_response(ISCSI_TASK_FUNC_RESP_FUNC_NOT_SUPPORTED, 1234, 0, 0, 4); 1786 1787 /* Case 6 - TARGET WARM RESET is not supported. "Task management function not supported 1788 * is sent. 1789 */ 1790 task_reqh->flags = ISCSI_TASK_FUNC_TARGET_WARM_RESET; 1791 1792 rc = iscsi_pdu_hdr_op_task(&conn, &pdu); 1793 CU_ASSERT(rc == 0); 1794 check_iscsi_task_mgmt_response(ISCSI_TASK_FUNC_RESP_FUNC_NOT_SUPPORTED, 1234, 0, 0, 5); 1795 1796 /* Case 7 - TARGET COLD RESET is not supported. "Task management function not supported 1797 * is sent. 1798 */ 1799 task_reqh->flags = ISCSI_TASK_FUNC_TARGET_COLD_RESET; 1800 1801 rc = iscsi_pdu_hdr_op_task(&conn, &pdu); 1802 CU_ASSERT(rc == 0); 1803 check_iscsi_task_mgmt_response(ISCSI_TASK_FUNC_RESP_FUNC_NOT_SUPPORTED, 1234, 0, 0, 6); 1804 1805 /* Case 8 - TASK REASSIGN is not supported. "Task management function not supported" is sent. */ 1806 task_reqh->flags = ISCSI_TASK_FUNC_TASK_REASSIGN; 1807 1808 rc = iscsi_pdu_hdr_op_task(&conn, &pdu); 1809 CU_ASSERT(rc == 0); 1810 check_iscsi_task_mgmt_response(ISCSI_TASK_FUNC_RESP_FUNC_NOT_SUPPORTED, 1234, 0, 0, 7); 1811 } 1812 1813 static void 1814 pdu_hdr_op_nopout_test(void) 1815 { 1816 struct spdk_iscsi_sess sess = {}; 1817 struct spdk_iscsi_conn conn = {}; 1818 struct spdk_iscsi_pdu pdu = {}; 1819 struct iscsi_bhs_nop_out *nopout_reqh; 1820 int rc; 1821 1822 nopout_reqh = (struct iscsi_bhs_nop_out *)&pdu.bhs; 1823 1824 conn.sess = &sess; 1825 1826 /* Case 1 - NOP-Out PDU is acceptable only on normal session. */ 1827 sess.session_type = SESSION_TYPE_DISCOVERY; 1828 1829 rc = iscsi_pdu_hdr_op_nopout(&conn, &pdu); 1830 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1831 1832 /* Case 2 - The length of the reflected ping data is limited to MaxRecvDataSegmentLength. */ 1833 sess.session_type = SESSION_TYPE_NORMAL; 1834 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH + 1; 1835 1836 rc = iscsi_pdu_hdr_op_nopout(&conn, &pdu); 1837 CU_ASSERT(rc == 0); 1838 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1839 1840 /* Case 3 - If Initiator Task Tag contains 0xffffffff, the I bit must be set 1841 * to 1 and Target Transfer Tag should be copied from NOP-In PDU. This case 1842 * satisfies the former but doesn't satisfy the latter, but ignore the error 1843 * for now. 1844 */ 1845 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 1846 conn.id = 1234; 1847 to_be32(&nopout_reqh->ttt, 1235); 1848 to_be32(&nopout_reqh->itt, 0xffffffffU); 1849 nopout_reqh->immediate = 1; 1850 1851 rc = iscsi_pdu_hdr_op_nopout(&conn, &pdu); 1852 CU_ASSERT(rc == 0); 1853 1854 /* Case 4 - This case doesn't satisfy the above former. This error is not ignored. */ 1855 nopout_reqh->immediate = 0; 1856 1857 rc = iscsi_pdu_hdr_op_nopout(&conn, &pdu); 1858 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1859 } 1860 1861 static void 1862 check_iscsi_r2t(struct spdk_iscsi_task *task, uint32_t len) 1863 { 1864 struct spdk_iscsi_pdu *rsp_pdu; 1865 struct iscsi_bhs_r2t *rsph; 1866 1867 rsp_pdu = TAILQ_FIRST(&g_write_pdu_list); 1868 CU_ASSERT(rsp_pdu != NULL); 1869 rsph = (struct iscsi_bhs_r2t *)&rsp_pdu->bhs; 1870 CU_ASSERT(rsph->opcode == ISCSI_OP_R2T); 1871 CU_ASSERT(from_be64(&rsph->lun) == spdk_scsi_lun_id_int_to_fmt(task->lun_id)); 1872 CU_ASSERT(from_be32(&rsph->buffer_offset) + len == task->next_r2t_offset); 1873 CU_ASSERT(from_be32(&rsph->desired_xfer_len) == len); 1874 1875 TAILQ_REMOVE(&g_write_pdu_list, rsp_pdu, tailq); 1876 iscsi_put_pdu(rsp_pdu); 1877 } 1878 1879 static void 1880 pdu_hdr_op_data_test(void) 1881 { 1882 struct spdk_iscsi_sess sess = {}; 1883 struct spdk_iscsi_conn conn = {}; 1884 struct spdk_iscsi_pdu pdu = {}; 1885 struct spdk_iscsi_task primary = {}; 1886 struct spdk_scsi_dev dev = {}; 1887 struct spdk_scsi_lun lun = {}; 1888 struct iscsi_bhs_data_out *data_reqh; 1889 int rc; 1890 1891 data_reqh = (struct iscsi_bhs_data_out *)&pdu.bhs; 1892 1893 conn.sess = &sess; 1894 conn.dev = &dev; 1895 TAILQ_INIT(&conn.active_r2t_tasks); 1896 1897 /* Case 1 - SCSI Data-Out PDU is acceptable only on normal session. */ 1898 sess.session_type = SESSION_TYPE_DISCOVERY; 1899 1900 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1901 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1902 1903 /* Case 2 - Data segment length must not be more than MaxRecvDataSegmentLength. */ 1904 sess.session_type = SESSION_TYPE_NORMAL; 1905 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH + 1; 1906 1907 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1908 CU_ASSERT(rc == 0); 1909 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1910 1911 /* Case 3 - R2T task whose Target Transfer Tag matches is not found. */ 1912 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 1913 1914 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1915 CU_ASSERT(rc == 0); 1916 check_iscsi_reject(&pdu, ISCSI_REASON_INVALID_PDU_FIELD); 1917 1918 /* Case 4 - R2T task whose Target Transfer Tag matches is found but data segment length 1919 * is more than Desired Data Transfer Length of the R2T. 1920 */ 1921 primary.desired_data_transfer_length = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH - 1; 1922 conn.pending_r2t = 1; 1923 TAILQ_INSERT_TAIL(&conn.active_r2t_tasks, &primary, link); 1924 1925 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1926 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1927 1928 /* Case 5 - Initiator task tag doesn't match tag of R2T task. */ 1929 primary.desired_data_transfer_length = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 1930 to_be32(&data_reqh->itt, 1); 1931 1932 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1933 CU_ASSERT(rc == 0); 1934 check_iscsi_reject(&pdu, ISCSI_REASON_INVALID_PDU_FIELD); 1935 1936 /* Case 6 - DataSN doesn't match the Data-Out PDU number within the current 1937 * output sequence. 1938 */ 1939 to_be32(&data_reqh->itt, 0); 1940 to_be32(&data_reqh->data_sn, 1); 1941 1942 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1943 CU_ASSERT(rc == 0); 1944 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1945 1946 /* Case 7 - Output sequence must be in increasing buffer offset and must not 1947 * be overlaid but they are not satisfied. 1948 */ 1949 to_be32(&data_reqh->data_sn, 0); 1950 to_be32(&data_reqh->buffer_offset, 4096); 1951 1952 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1953 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1954 1955 /* Case 8 - Data segment length must not exceed MaxBurstLength. */ 1956 to_be32(&data_reqh->buffer_offset, 0); 1957 sess.MaxBurstLength = pdu.data_segment_len - 1; 1958 1959 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1960 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL); 1961 1962 /* Case 9 - LUN is hot removed. */ 1963 sess.MaxBurstLength = pdu.data_segment_len * 4; 1964 to_be32(&data_reqh->data_sn, primary.r2t_datasn); 1965 to_be32(&data_reqh->buffer_offset, primary.next_expected_r2t_offset); 1966 1967 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1968 CU_ASSERT(rc == 0); 1969 check_iscsi_reject(&pdu, ISCSI_REASON_PROTOCOL_ERROR); 1970 1971 /* Case 10 - SCSI Data-Out PDU is correct and processed. Its F bit is 0 and hence 1972 * R2T is not sent. 1973 */ 1974 TAILQ_INIT(&dev.luns); 1975 TAILQ_INSERT_TAIL(&dev.luns, &lun, tailq); 1976 to_be32(&data_reqh->data_sn, primary.r2t_datasn); 1977 to_be32(&data_reqh->buffer_offset, primary.next_expected_r2t_offset); 1978 1979 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1980 CU_ASSERT(rc == 0); 1981 CU_ASSERT(!pdu.is_rejected); 1982 CU_ASSERT(pdu.data_buf_len == SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH); 1983 pdu.task = NULL; 1984 1985 /* Case 11 - SCSI Data-Out PDU is correct and processed. Its F bit is 1 and hence 1986 * R2T is sent. 1987 */ 1988 data_reqh->flags |= ISCSI_FLAG_FINAL; 1989 to_be32(&data_reqh->data_sn, primary.r2t_datasn); 1990 to_be32(&data_reqh->buffer_offset, primary.next_expected_r2t_offset); 1991 primary.scsi.transfer_len = pdu.data_segment_len * 5; 1992 1993 rc = iscsi_pdu_hdr_op_data(&conn, &pdu); 1994 CU_ASSERT(rc == 0); 1995 CU_ASSERT(!pdu.is_rejected); 1996 check_iscsi_r2t(&primary, pdu.data_segment_len * 4); 1997 } 1998 1999 /* Test an ISCSI_OP_TEXT PDU with CONTINUE bit set but 2000 * no data. 2001 */ 2002 static void 2003 empty_text_with_cbit_test(void) 2004 { 2005 struct spdk_iscsi_sess sess = {}; 2006 struct spdk_iscsi_conn conn = {}; 2007 struct spdk_scsi_dev dev = {}; 2008 struct spdk_iscsi_pdu *req_pdu; 2009 int rc; 2010 2011 req_pdu = iscsi_get_pdu(&conn); 2012 2013 sess.ExpCmdSN = 0; 2014 sess.MaxCmdSN = 64; 2015 sess.session_type = SESSION_TYPE_NORMAL; 2016 sess.MaxBurstLength = 1024; 2017 2018 conn.full_feature = 1; 2019 conn.sess = &sess; 2020 conn.dev = &dev; 2021 conn.state = ISCSI_CONN_STATE_RUNNING; 2022 2023 memset(&req_pdu->bhs, 0, sizeof(req_pdu->bhs)); 2024 req_pdu->bhs.opcode = ISCSI_OP_TEXT; 2025 req_pdu->bhs.flags = ISCSI_TEXT_CONTINUE; 2026 2027 rc = iscsi_pdu_hdr_handle(&conn, req_pdu); 2028 CU_ASSERT(rc == 0); 2029 CU_ASSERT(!req_pdu->is_rejected); 2030 rc = iscsi_pdu_payload_handle(&conn, req_pdu); 2031 CU_ASSERT(rc == 0); 2032 2033 iscsi_put_pdu(req_pdu); 2034 } 2035 2036 static void 2037 check_pdu_payload_read(struct spdk_iscsi_pdu *pdu, struct spdk_mobj *mobj, 2038 int rc, int index, uint32_t read_offset) 2039 { 2040 uint64_t buf_offset; 2041 uint32_t *data; 2042 uint32_t i; 2043 2044 data = (uint32_t *)pdu->data; 2045 buf_offset = (uint64_t)pdu->data - (uint64_t)mobj->buf; 2046 2047 CU_ASSERT(pdu->mobj[index] == mobj); 2048 CU_ASSERT(pdu->data_from_mempool == true); 2049 CU_ASSERT(buf_offset == 0 || pdu->data_offset == 0); 2050 CU_ASSERT(mobj->data_len + pdu->data_offset == buf_offset + pdu->data_valid_bytes); 2051 CU_ASSERT(rc > 0 || pdu->data_valid_bytes == pdu->data_segment_len); 2052 2053 for (i = 0; i < pdu->data_valid_bytes - pdu->data_offset; i += 4) { 2054 CU_ASSERT(data[i / 4] == (uint32_t)(read_offset + i)); 2055 } 2056 } 2057 2058 static void 2059 pdu_payload_read_test(void) 2060 { 2061 struct spdk_iscsi_conn conn = {}; 2062 struct spdk_iscsi_pdu pdu = {}; 2063 struct spdk_mobj mobj1 = {}, mobj2 = {}; 2064 int rc; 2065 2066 g_iscsi.FirstBurstLength = SPDK_ISCSI_FIRST_BURST_LENGTH; 2067 2068 mobj1.buf = calloc(1, SPDK_BDEV_BUF_SIZE_WITH_MD(SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH)); 2069 SPDK_CU_ASSERT_FATAL(mobj1.buf != NULL); 2070 2071 mobj2.buf = calloc(1, SPDK_BDEV_BUF_SIZE_WITH_MD(SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH)); 2072 SPDK_CU_ASSERT_FATAL(mobj2.buf != NULL); 2073 2074 MOCK_SET(spdk_mempool_get, &mobj1); 2075 2076 /* The following tests assume that a iscsi_conn_read_data() call could read 2077 * the required length of the data and all read lengths are 4 bytes multiples. 2078 * The latter is to verify data is copied to the correct offset by using data patterns. 2079 */ 2080 2081 /* Case 1: data segment size is equal with max immediate data size. */ 2082 pdu.data_segment_len = iscsi_get_max_immediate_data_size(); 2083 pdu.data_buf_len = pdu.data_segment_len; 2084 g_conn_read_len = 0; 2085 2086 rc = iscsi_pdu_payload_read(&conn, &pdu); 2087 check_pdu_payload_read(&pdu, &mobj1, rc, 0, 0); 2088 2089 memset(&pdu, 0, sizeof(pdu)); 2090 mobj1.data_len = 0; 2091 2092 /* Case 2: data segment size is equal with SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH. */ 2093 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 2094 pdu.data_buf_len = pdu.data_segment_len; 2095 g_conn_read_len = 0; 2096 2097 rc = iscsi_pdu_payload_read(&conn, &pdu); 2098 check_pdu_payload_read(&pdu, &mobj1, rc, 0, 0); 2099 2100 memset(&pdu, 0, sizeof(pdu)); 2101 mobj1.data_len = 0; 2102 2103 /* Case 3: data segment size is larger than SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH. 2104 * This should result in error. 2105 */ 2106 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH + 1; 2107 pdu.data_buf_len = pdu.data_segment_len; 2108 g_conn_read_len = 0; 2109 2110 rc = iscsi_pdu_payload_read(&conn, &pdu); 2111 CU_ASSERT(rc < 0); 2112 2113 /* Case 4: read starts from the middle of the 1st data buffer, the 1st data buffer 2114 * ran out, allocate the 2nd data buffer, and read the remaining data to the 2nd 2115 * data buffer. 2116 */ 2117 mobj1.data_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2; 2118 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 2119 pdu.data_buf_len = SPDK_BDEV_BUF_SIZE_WITH_MD(SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH); 2120 pdu.mobj[0] = &mobj1; 2121 pdu.data = (void *)((uint64_t)mobj1.buf + SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2); 2122 pdu.data_from_mempool = true; 2123 g_conn_read_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2; 2124 2125 rc = iscsi_pdu_payload_read(&conn, &pdu); 2126 check_pdu_payload_read(&pdu, &mobj1, rc, 0, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2); 2127 2128 MOCK_SET(spdk_mempool_get, &mobj2); 2129 2130 rc = iscsi_pdu_payload_read(&conn, &pdu); 2131 check_pdu_payload_read(&pdu, &mobj2, rc, 1, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH); 2132 2133 MOCK_CLEAR(spdk_mempool_get); 2134 2135 free(mobj1.buf); 2136 free(mobj2.buf); 2137 } 2138 2139 static void 2140 check_pdu_hdr_handle(struct spdk_iscsi_pdu *pdu, struct spdk_mobj *mobj, uint32_t offset, 2141 struct spdk_iscsi_task *primary) 2142 { 2143 CU_ASSERT(pdu->mobj[0] == mobj); 2144 CU_ASSERT(pdu->data == NULL || pdu->data == (void *)((uint64_t)mobj->buf + offset)); 2145 CU_ASSERT(primary->mobj == NULL); 2146 } 2147 2148 static void 2149 check_pdu_payload_handle(struct spdk_iscsi_pdu *pdu, struct spdk_iscsi_task *primary, 2150 struct spdk_mobj *pdu_mobj0, struct spdk_mobj *pdu_mobj1, 2151 struct spdk_mobj *primary_mobj, uint32_t primary_offset) 2152 { 2153 CU_ASSERT(pdu->mobj[0] == pdu_mobj0); 2154 CU_ASSERT(pdu->mobj[1] == pdu_mobj1); 2155 CU_ASSERT(primary->mobj == primary_mobj); 2156 CU_ASSERT(primary->current_data_offset == primary_offset); 2157 } 2158 2159 static void 2160 check_write_subtask_submit(struct spdk_scsi_lun *lun, struct spdk_mobj *mobj, 2161 struct spdk_iscsi_pdu *pdu, 2162 int index, uint32_t offset, uint32_t length) 2163 { 2164 struct spdk_scsi_task *scsi_task; 2165 struct spdk_iscsi_task *subtask; 2166 uint32_t *data; 2167 uint32_t i; 2168 2169 scsi_task = TAILQ_FIRST(&lun->tasks); 2170 SPDK_CU_ASSERT_FATAL(scsi_task != NULL); 2171 TAILQ_REMOVE(&lun->tasks, scsi_task, scsi_link); 2172 2173 subtask = iscsi_task_from_scsi_task(scsi_task); 2174 2175 CU_ASSERT(iscsi_task_get_pdu(subtask) == pdu); 2176 CU_ASSERT(pdu->mobj[index] == mobj); 2177 CU_ASSERT(subtask->scsi.offset == offset); 2178 CU_ASSERT(subtask->scsi.length == length); 2179 CU_ASSERT(subtask->scsi.iovs[0].iov_base == mobj->buf); 2180 CU_ASSERT(subtask->scsi.iovs[0].iov_len == length); 2181 2182 data = (uint32_t *)mobj->buf; 2183 for (i = 0; i < length; i += 4) { 2184 CU_ASSERT(data[i / 4] == offset + i); 2185 } 2186 2187 free(subtask); 2188 } 2189 2190 static void 2191 data_out_pdu_sequence_test(void) 2192 { 2193 struct spdk_scsi_lun lun = { .tasks = TAILQ_HEAD_INITIALIZER(lun.tasks), }; 2194 struct spdk_scsi_dev dev = { .luns = TAILQ_HEAD_INITIALIZER(dev.luns), }; 2195 struct spdk_iscsi_sess sess = { 2196 .session_type = SESSION_TYPE_NORMAL, 2197 .MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH, 2198 }; 2199 struct spdk_iscsi_conn conn = { 2200 .full_feature = true, 2201 .state = ISCSI_CONN_STATE_RUNNING, 2202 .sess = &sess, 2203 .dev = &dev, 2204 .active_r2t_tasks = TAILQ_HEAD_INITIALIZER(conn.active_r2t_tasks), 2205 }; 2206 struct spdk_iscsi_task primary = {}; 2207 struct spdk_iscsi_pdu pdu = {}; 2208 struct spdk_mobj mobj1 = {}, mobj2 = {}, mobj3 = {}; 2209 struct iscsi_bhs_data_out *data_reqh; 2210 int rc; 2211 2212 TAILQ_INSERT_TAIL(&dev.luns, &lun, tailq); 2213 2214 mobj1.buf = calloc(1, SPDK_BDEV_BUF_SIZE_WITH_MD(SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH)); 2215 SPDK_CU_ASSERT_FATAL(mobj1.buf != NULL); 2216 2217 mobj2.buf = calloc(1, SPDK_BDEV_BUF_SIZE_WITH_MD(SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH)); 2218 SPDK_CU_ASSERT_FATAL(mobj2.buf != NULL); 2219 2220 mobj3.buf = calloc(1, SPDK_BDEV_BUF_SIZE_WITH_MD(SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH)); 2221 SPDK_CU_ASSERT_FATAL(mobj3.buf != NULL); 2222 2223 /* Test scenario is as follows. 2224 * 2225 * Some iSCSI initiator sends a Data-OUT PDU sequence such that the size of 2226 * the data segment of any Data-OUT PDU is not block size multiples. 2227 * Test if such complex Data-OUT PDU sequence is processed correctly. 2228 * 2229 * Desired Data Transfer Length is 5 * SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2. 2230 * Number of Data-OUT PDUs is 4. Length of the data segment of the first two PDUs are 2231 * SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2 - 4. Length of the data segment of the 2232 * third PDU is SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH. Length of the data segment 2233 * of the final PDU is SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2 + 8. 2234 * 2235 * Three data buffers should be used and three subtasks should be created and submitted. 2236 * 2237 * The test scenario assume that a iscsi_conn_read_data() call could read 2238 * the required length of the data and all read lengths are 4 bytes multiples. 2239 * The latter is to verify data is copied to the correct offset by using data patterns. 2240 */ 2241 2242 primary.scsi.transfer_len = 5 * SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2; 2243 primary.desired_data_transfer_length = primary.scsi.transfer_len; 2244 TAILQ_INSERT_TAIL(&conn.active_r2t_tasks, &primary, link); 2245 conn.pending_r2t = 1; 2246 g_conn_read_len = 0; 2247 2248 /* The 1st Data-OUT PDU */ 2249 data_reqh = (struct iscsi_bhs_data_out *)&pdu.bhs; 2250 pdu.bhs.opcode = ISCSI_OP_SCSI_DATAOUT; 2251 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2 - 4; 2252 2253 rc = iscsi_pdu_hdr_handle(&conn, &pdu); 2254 CU_ASSERT(rc == 0); 2255 check_pdu_hdr_handle(&pdu, NULL, 0, &primary); 2256 2257 MOCK_SET(spdk_mempool_get, &mobj1); 2258 2259 rc = iscsi_pdu_payload_read(&conn, &pdu); 2260 CU_ASSERT(rc == 0); 2261 check_pdu_payload_read(&pdu, &mobj1, rc, 0, 0); 2262 2263 rc = iscsi_pdu_payload_handle(&conn, &pdu); 2264 CU_ASSERT(rc == 0); 2265 check_pdu_payload_handle(&pdu, &primary, NULL, NULL, &mobj1, 0); 2266 2267 /* The 2nd Data-OUT PDU */ 2268 memset(&pdu, 0, sizeof(pdu)); 2269 pdu.bhs.opcode = ISCSI_OP_SCSI_DATAOUT; 2270 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2 - 4; 2271 to_be32(&data_reqh->data_sn, 1); 2272 to_be32(&data_reqh->buffer_offset, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2 - 4); 2273 2274 rc = iscsi_pdu_hdr_handle(&conn, &pdu); 2275 CU_ASSERT(rc == 0); 2276 check_pdu_hdr_handle(&pdu, &mobj1, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2 - 4, &primary); 2277 2278 rc = iscsi_pdu_payload_read(&conn, &pdu); 2279 CU_ASSERT(rc == 0); 2280 check_pdu_payload_read(&pdu, &mobj1, rc, 0, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2 - 4); 2281 2282 rc = iscsi_pdu_payload_handle(&conn, &pdu); 2283 CU_ASSERT(rc == 0); 2284 check_pdu_payload_handle(&pdu, &primary, NULL, NULL, &mobj1, 0); 2285 2286 /* The 3rd Data-OUT PDU */ 2287 memset(&pdu, 0, sizeof(pdu)); 2288 pdu.bhs.opcode = ISCSI_OP_SCSI_DATAOUT; 2289 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 2290 to_be32(&data_reqh->data_sn, 2); 2291 to_be32(&data_reqh->buffer_offset, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH - 8); 2292 2293 rc = iscsi_pdu_hdr_handle(&conn, &pdu); 2294 CU_ASSERT(rc == 0); 2295 check_pdu_hdr_handle(&pdu, &mobj1, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH - 8, &primary); 2296 2297 rc = iscsi_pdu_payload_read(&conn, &pdu); 2298 CU_ASSERT(rc > 0); 2299 check_pdu_payload_read(&pdu, &mobj1, rc, 0, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH - 8); 2300 2301 MOCK_SET(spdk_mempool_get, &mobj2); 2302 2303 rc = iscsi_pdu_payload_read(&conn, &pdu); 2304 CU_ASSERT(rc == 0); 2305 check_pdu_payload_read(&pdu, &mobj2, rc, 1, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH); 2306 2307 rc = iscsi_pdu_payload_handle(&conn, &pdu); 2308 CU_ASSERT(rc == 0); 2309 check_pdu_payload_handle(&pdu, &primary, &mobj1, NULL, &mobj2, 2310 SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH); 2311 2312 check_write_subtask_submit(&lun, &mobj1, &pdu, 0, 0, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH); 2313 2314 /* The 4th and final Data-OUT PDU */ 2315 memset(&pdu, 0, sizeof(pdu)); 2316 pdu.bhs.opcode = ISCSI_OP_SCSI_DATAOUT; 2317 pdu.data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2 + 8; 2318 data_reqh->flags |= ISCSI_FLAG_FINAL; 2319 to_be32(&data_reqh->data_sn, 3); 2320 to_be32(&data_reqh->buffer_offset, 2 * SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH - 8); 2321 2322 rc = iscsi_pdu_hdr_handle(&conn, &pdu); 2323 CU_ASSERT(rc == 0); 2324 check_pdu_hdr_handle(&pdu, &mobj2, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH - 8, &primary); 2325 2326 rc = iscsi_pdu_payload_read(&conn, &pdu); 2327 CU_ASSERT(rc > 0); 2328 check_pdu_payload_read(&pdu, &mobj2, rc, 0, 2 * SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH - 8); 2329 2330 MOCK_SET(spdk_mempool_get, &mobj3); 2331 2332 rc = iscsi_pdu_payload_read(&conn, &pdu); 2333 CU_ASSERT(rc == 0); 2334 check_pdu_payload_read(&pdu, &mobj3, rc, 1, 2 * SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH); 2335 2336 rc = iscsi_pdu_payload_handle(&conn, &pdu); 2337 CU_ASSERT(rc == 0); 2338 check_pdu_payload_handle(&pdu, &primary, &mobj2, &mobj3, NULL, 2339 5 * SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2); 2340 2341 check_write_subtask_submit(&lun, &mobj2, &pdu, 0, SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH, 2342 SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH); 2343 2344 check_write_subtask_submit(&lun, &mobj3, &pdu, 1, 2 * SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH, 2345 SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH / 2); 2346 2347 CU_ASSERT(TAILQ_EMPTY(&lun.tasks)); 2348 2349 MOCK_CLEAR(spdk_mempool_get); 2350 2351 free(mobj1.buf); 2352 free(mobj2.buf); 2353 free(mobj3.buf); 2354 } 2355 2356 int 2357 main(int argc, char **argv) 2358 { 2359 CU_pSuite suite = NULL; 2360 unsigned int num_failures; 2361 2362 CU_set_error_action(CUEA_ABORT); 2363 CU_initialize_registry(); 2364 2365 suite = CU_add_suite("iscsi_suite", NULL, NULL); 2366 2367 CU_ADD_TEST(suite, op_login_check_target_test); 2368 CU_ADD_TEST(suite, op_login_session_normal_test); 2369 CU_ADD_TEST(suite, maxburstlength_test); 2370 CU_ADD_TEST(suite, underflow_for_read_transfer_test); 2371 CU_ADD_TEST(suite, underflow_for_zero_read_transfer_test); 2372 CU_ADD_TEST(suite, underflow_for_request_sense_test); 2373 CU_ADD_TEST(suite, underflow_for_check_condition_test); 2374 CU_ADD_TEST(suite, add_transfer_task_test); 2375 CU_ADD_TEST(suite, get_transfer_task_test); 2376 CU_ADD_TEST(suite, del_transfer_task_test); 2377 CU_ADD_TEST(suite, clear_all_transfer_tasks_test); 2378 CU_ADD_TEST(suite, build_iovs_test); 2379 CU_ADD_TEST(suite, build_iovs_with_md_test); 2380 CU_ADD_TEST(suite, pdu_hdr_op_login_test); 2381 CU_ADD_TEST(suite, pdu_hdr_op_text_test); 2382 CU_ADD_TEST(suite, pdu_hdr_op_logout_test); 2383 CU_ADD_TEST(suite, pdu_hdr_op_scsi_test); 2384 CU_ADD_TEST(suite, pdu_hdr_op_task_mgmt_test); 2385 CU_ADD_TEST(suite, pdu_hdr_op_nopout_test); 2386 CU_ADD_TEST(suite, pdu_hdr_op_data_test); 2387 CU_ADD_TEST(suite, empty_text_with_cbit_test); 2388 CU_ADD_TEST(suite, pdu_payload_read_test); 2389 CU_ADD_TEST(suite, data_out_pdu_sequence_test); 2390 2391 CU_basic_set_mode(CU_BRM_VERBOSE); 2392 CU_basic_run_tests(); 2393 num_failures = CU_get_number_of_failures(); 2394 CU_cleanup_registry(); 2395 return num_failures; 2396 } 2397