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