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