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