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