]> git.proxmox.com Git - ceph.git/blame - ceph/src/spdk/test/unit/lib/iscsi/iscsi.c/iscsi_ut.c
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import 15.2.0 Octopus source
[ceph.git] / ceph / src / spdk / test / unit / lib / iscsi / iscsi.c / iscsi_ut.c
CommitLineData
11fdf7f2
TL		 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"
11fdf7f2
TL		 45#include "iscsi/portal_grp.h"
46#include "scsi/scsi_internal.h"
9f95a23c
TL		 47#include "common/lib/test_env.c"
48
49#include "spdk_internal/mock.h"
11fdf7f2
TL		 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
56struct spdk_iscsi_tgt_node *
57spdk_iscsi_find_tgt_node(const char *target_name)
58{
59 if (strcasecmp(target_name, UT_TARGET_NAME1) == 0) {
60 return (struct spdk_iscsi_tgt_node *)1;
61 } else {
62 return NULL;
63 }
64}
65
66bool
67spdk_iscsi_tgt_node_access(struct spdk_iscsi_conn *conn,
68 struct spdk_iscsi_tgt_node *target,
69 const char *iqn, const char *addr)
70{
71 if (strcasecmp(conn->initiator_name, UT_INITIATOR_NAME1) == 0) {
72 return true;
73 } else {
74 return false;
75 }
76}
77
9f95a23c
TL		 78DEFINE_STUB(spdk_iscsi_send_tgts, int,
79 (struct spdk_iscsi_conn *conn, const char *iiqn, const char *iaddr,
80 const char *tiqn, uint8_t *data, int alloc_len, int data_len),
81 0);
11fdf7f2 82
9f95a23c
TL		 83DEFINE_STUB(spdk_iscsi_tgt_node_is_destructed, bool,
84 (struct spdk_iscsi_tgt_node *target), false);
11fdf7f2 85
9f95a23c 86DEFINE_STUB_V(spdk_iscsi_portal_grp_close_all, (void));
11fdf7f2 87
9f95a23c 88DEFINE_STUB_V(spdk_iscsi_conn_schedule, (struct spdk_iscsi_conn *conn));
11fdf7f2 89
9f95a23c
TL		 90DEFINE_STUB_V(spdk_iscsi_conn_free_pdu,
91 (struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu));
92
93DEFINE_STUB(spdk_iscsi_chap_get_authinfo, int,
94 (struct iscsi_chap_auth *auth, const char *authuser, int ag_tag),
95 0);
11fdf7f2
TL		 96
97int
98spdk_scsi_lun_get_id(const struct spdk_scsi_lun *lun)
99{
100 return lun->id;
101}
102
9f95a23c
TL		 103DEFINE_STUB(spdk_scsi_lun_is_removing, bool, (const struct spdk_scsi_lun *lun),
104 true);
11fdf7f2
TL		 105
106struct spdk_scsi_lun *
107spdk_scsi_dev_get_lun(struct spdk_scsi_dev *dev, int lun_id)
108{
109 if (lun_id < 0 || lun_id >= SPDK_SCSI_DEV_MAX_LUN) {
110 return NULL;
111 }
112
113 return dev->lun[lun_id];
114}
115
9f95a23c
TL		 116DEFINE_STUB(spdk_scsi_lun_id_int_to_fmt, uint64_t, (int lun_id), 0);
117
118DEFINE_STUB(spdk_scsi_lun_id_fmt_to_int, int, (uint64_t lun_fmt), 0);
119
11fdf7f2
TL		 120static void
121op_login_check_target_test(void)
122{
123 struct spdk_iscsi_conn conn;
124 struct spdk_iscsi_pdu rsp_pdu;
125 struct spdk_iscsi_tgt_node *target;
126 int rc;
127
128 /* expect success */
129 snprintf(conn.initiator_name, sizeof(conn.initiator_name),
130 "%s", UT_INITIATOR_NAME1);
131
9f95a23c
TL		 132 rc = iscsi_op_login_check_target(&conn, &rsp_pdu,
133 UT_TARGET_NAME1, &target);
11fdf7f2
TL		 134 CU_ASSERT(rc == 0);
135
136 /* expect failure */
137 snprintf(conn.initiator_name, sizeof(conn.initiator_name),
138 "%s", UT_INITIATOR_NAME1);
139
9f95a23c
TL		 140 rc = iscsi_op_login_check_target(&conn, &rsp_pdu,
141 UT_TARGET_NAME2, &target);
11fdf7f2
TL		 142 CU_ASSERT(rc != 0);
143
144 /* expect failure */
145 snprintf(conn.initiator_name, sizeof(conn.initiator_name),
146 "%s", UT_INITIATOR_NAME2);
147
9f95a23c
TL		 148 rc = iscsi_op_login_check_target(&conn, &rsp_pdu,
149 UT_TARGET_NAME1, &target);
11fdf7f2
TL		 150 CU_ASSERT(rc != 0);
151}
152
153static void
154maxburstlength_test(void)
155{
156 struct spdk_iscsi_sess sess;
157 struct spdk_iscsi_conn conn;
158 struct spdk_scsi_dev dev;
159 struct spdk_scsi_lun lun;
160 struct spdk_iscsi_pdu *req_pdu, *data_out_pdu, *r2t_pdu;
161 struct iscsi_bhs_scsi_req *req;
162 struct iscsi_bhs_r2t *r2t;
163 struct iscsi_bhs_data_out *data_out;
164 struct spdk_iscsi_pdu *response_pdu;
165 int rc;
166
167 memset(&sess, 0, sizeof(sess));
168 memset(&conn, 0, sizeof(conn));
169 memset(&dev, 0, sizeof(dev));
170 memset(&lun, 0, sizeof(lun));
171
172 req_pdu = spdk_get_pdu();
173 data_out_pdu = spdk_get_pdu();
174
175 sess.ExpCmdSN = 0;
176 sess.MaxCmdSN = 64;
177 sess.session_type = SESSION_TYPE_NORMAL;
178 sess.MaxBurstLength = 1024;
179
180 lun.id = 0;
181
182 dev.lun[0] = &lun;
183
184 conn.full_feature = 1;
185 conn.sess = &sess;
186 conn.dev = &dev;
187 conn.state = ISCSI_CONN_STATE_RUNNING;
188 TAILQ_INIT(&conn.write_pdu_list);
189 TAILQ_INIT(&conn.active_r2t_tasks);
190
191 TAILQ_INIT(&g_write_pdu_list);
192
193 req_pdu->bhs.opcode = ISCSI_OP_SCSI;
194 req_pdu->data_segment_len = 0;
195
196 req = (struct iscsi_bhs_scsi_req *)&req_pdu->bhs;
197
198 to_be32(&req->cmd_sn, 0);
199 to_be32(&req->expected_data_xfer_len, 1028);
200 to_be32(&req->itt, 0x1234);
201 req->write_bit = 1;
202 req->final_bit = 1;
203
204 rc = spdk_iscsi_execute(&conn, req_pdu);
205 CU_ASSERT(rc == 0);
206
207 response_pdu = TAILQ_FIRST(&g_write_pdu_list);
208 SPDK_CU_ASSERT_FATAL(response_pdu != NULL);
209
210 /*
211 * Confirm that a correct R2T reply was sent in response to the
212 * SCSI request.
213 */
214 TAILQ_REMOVE(&g_write_pdu_list, response_pdu, tailq);
215 CU_ASSERT(response_pdu->bhs.opcode == ISCSI_OP_R2T);
216 r2t = (struct iscsi_bhs_r2t *)&response_pdu->bhs;
217 CU_ASSERT(from_be32(&r2t->desired_xfer_len) == 1024);
218 CU_ASSERT(from_be32(&r2t->buffer_offset) == 0);
219 CU_ASSERT(from_be32(&r2t->itt) == 0x1234);
220
221 data_out_pdu->bhs.opcode = ISCSI_OP_SCSI_DATAOUT;
222 data_out_pdu->bhs.flags = ISCSI_FLAG_FINAL;
223 data_out_pdu->data_segment_len = 1028;
224 data_out = (struct iscsi_bhs_data_out *)&data_out_pdu->bhs;
225 data_out->itt = r2t->itt;
226 data_out->ttt = r2t->ttt;
227 DSET24(data_out->data_segment_len, 1028);
228
229 rc = spdk_iscsi_execute(&conn, data_out_pdu);
230 CU_ASSERT(rc == SPDK_ISCSI_CONNECTION_FATAL);
231
232 SPDK_CU_ASSERT_FATAL(response_pdu->task != NULL);
233 spdk_iscsi_task_disassociate_pdu(response_pdu->task);
234 spdk_iscsi_task_put(response_pdu->task);
235 spdk_put_pdu(response_pdu);
236
237 r2t_pdu = TAILQ_FIRST(&g_write_pdu_list);
238 CU_ASSERT(r2t_pdu != NULL);
239 TAILQ_REMOVE(&g_write_pdu_list, r2t_pdu, tailq);
240 spdk_put_pdu(r2t_pdu);
241
242 spdk_put_pdu(data_out_pdu);
243 spdk_put_pdu(req_pdu);
244}
245
246static void
247underflow_for_read_transfer_test(void)
248{
249 struct spdk_iscsi_sess sess;
250 struct spdk_iscsi_conn conn;
251 struct spdk_iscsi_task task;
252 struct spdk_iscsi_pdu *pdu;
253 struct iscsi_bhs_scsi_req *scsi_req;
254 struct iscsi_bhs_data_in *datah;
255 uint32_t residual_count = 0;
256
257 TAILQ_INIT(&g_write_pdu_list);
258
259 memset(&sess, 0, sizeof(sess));
260 memset(&conn, 0, sizeof(conn));
261 memset(&task, 0, sizeof(task));
262
263 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH;
264
265 conn.sess = &sess;
266 conn.MaxRecvDataSegmentLength = 8192;
267
268 pdu = spdk_get_pdu();
269 SPDK_CU_ASSERT_FATAL(pdu != NULL);
270
271 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu->bhs;
272 scsi_req->read_bit = 1;
273
274 spdk_iscsi_task_set_pdu(&task, pdu);
275 task.parent = NULL;
276
277 task.scsi.iovs = &task.scsi.iov;
278 task.scsi.iovcnt = 1;
279 task.scsi.length = 512;
280 task.scsi.transfer_len = 512;
281 task.bytes_completed = 512;
282 task.scsi.data_transferred = 256;
283 task.scsi.status = SPDK_SCSI_STATUS_GOOD;
284
285 spdk_iscsi_task_response(&conn, &task);
286 spdk_put_pdu(pdu);
287
288 /*
289 * In this case, a SCSI Data-In PDU should contain the Status
290 * for the data transfer.
291 */
292 to_be32(&residual_count, 256);
293
294 pdu = TAILQ_FIRST(&g_write_pdu_list);
295 SPDK_CU_ASSERT_FATAL(pdu != NULL);
296
297 CU_ASSERT(pdu->bhs.opcode == ISCSI_OP_SCSI_DATAIN);
298
299 datah = (struct iscsi_bhs_data_in *)&pdu->bhs;
300
301 CU_ASSERT(datah->flags == (ISCSI_DATAIN_UNDERFLOW | ISCSI_FLAG_FINAL | ISCSI_DATAIN_STATUS));
302 CU_ASSERT(datah->res_cnt == residual_count);
303
304 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq);
305 spdk_put_pdu(pdu);
306
307 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list));
308}
309
310static void
311underflow_for_zero_read_transfer_test(void)
312{
313 struct spdk_iscsi_sess sess;
314 struct spdk_iscsi_conn conn;
315 struct spdk_iscsi_task task;
316 struct spdk_iscsi_pdu *pdu;
317 struct iscsi_bhs_scsi_req *scsi_req;
318 struct iscsi_bhs_scsi_resp *resph;
319 uint32_t residual_count = 0, data_segment_len;
320
321 TAILQ_INIT(&g_write_pdu_list);
322
323 memset(&sess, 0, sizeof(sess));
324 memset(&conn, 0, sizeof(conn));
325 memset(&task, 0, sizeof(task));
326
327 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH;
328
329 conn.sess = &sess;
330 conn.MaxRecvDataSegmentLength = 8192;
331
332 pdu = spdk_get_pdu();
333 SPDK_CU_ASSERT_FATAL(pdu != NULL);
334
335 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu->bhs;
336 scsi_req->read_bit = 1;
337
338 spdk_iscsi_task_set_pdu(&task, pdu);
339 task.parent = NULL;
340
341 task.scsi.length = 512;
342 task.scsi.transfer_len = 512;
343 task.bytes_completed = 512;
344 task.scsi.data_transferred = 0;
345 task.scsi.status = SPDK_SCSI_STATUS_GOOD;
346
347 spdk_iscsi_task_response(&conn, &task);
348 spdk_put_pdu(pdu);
349
350 /*
351 * In this case, only a SCSI Response PDU is expected and
352 * underflow must be set in it.
353 * */
354 to_be32(&residual_count, 512);
355
356 pdu = TAILQ_FIRST(&g_write_pdu_list);
357 SPDK_CU_ASSERT_FATAL(pdu != NULL);
358
359 CU_ASSERT(pdu->bhs.opcode == ISCSI_OP_SCSI_RSP);
360
361 resph = (struct iscsi_bhs_scsi_resp *)&pdu->bhs;
362
363 CU_ASSERT(resph->flags == (ISCSI_SCSI_UNDERFLOW | 0x80));
364
365 data_segment_len = DGET24(resph->data_segment_len);
366 CU_ASSERT(data_segment_len == 0);
367 CU_ASSERT(resph->res_cnt == residual_count);
368
369 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq);
370 spdk_put_pdu(pdu);
371
372 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list));
373}
374
375static void
376underflow_for_request_sense_test(void)
377{
378 struct spdk_iscsi_sess sess;
379 struct spdk_iscsi_conn conn;
380 struct spdk_iscsi_task task;
381 struct spdk_iscsi_pdu *pdu1, *pdu2;
382 struct iscsi_bhs_scsi_req *scsi_req;
383 struct iscsi_bhs_data_in *datah;
384 struct iscsi_bhs_scsi_resp *resph;
385 uint32_t residual_count = 0, data_segment_len;
386
387 TAILQ_INIT(&g_write_pdu_list);
388
389 memset(&sess, 0, sizeof(sess));
390 memset(&conn, 0, sizeof(conn));
391 memset(&task, 0, sizeof(task));
392
393 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH;
394
395 conn.sess = &sess;
396 conn.MaxRecvDataSegmentLength = 8192;
397
398 pdu1 = spdk_get_pdu();
399 SPDK_CU_ASSERT_FATAL(pdu1 != NULL);
400
401 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu1->bhs;
402 scsi_req->read_bit = 1;
403
404 spdk_iscsi_task_set_pdu(&task, pdu1);
405 task.parent = NULL;
406
407 task.scsi.iovs = &task.scsi.iov;
408 task.scsi.iovcnt = 1;
409 task.scsi.length = 512;
410 task.scsi.transfer_len = 512;
411 task.bytes_completed = 512;
412
413 task.scsi.sense_data_len = 18;
414 task.scsi.data_transferred = 18;
415 task.scsi.status = SPDK_SCSI_STATUS_GOOD;
416
417 spdk_iscsi_task_response(&conn, &task);
418 spdk_put_pdu(pdu1);
419
420 /*
421 * In this case, a SCSI Data-In PDU and a SCSI Response PDU are returned.
422 * Sense data are set both in payload and sense area.
423 * The SCSI Data-In PDU sets FINAL and the SCSI Response PDU sets UNDERFLOW.
424 *
425 * Probably there will be different implementation but keeping current SPDK
426 * implementation by adding UT will be valuable for any implementation.
427 */
428 to_be32(&residual_count, 494);
429
430 pdu1 = TAILQ_FIRST(&g_write_pdu_list);
431 SPDK_CU_ASSERT_FATAL(pdu1 != NULL);
432
433 CU_ASSERT(pdu1->bhs.opcode == ISCSI_OP_SCSI_DATAIN);
434
435 datah = (struct iscsi_bhs_data_in *)&pdu1->bhs;
436
437 CU_ASSERT(datah->flags == ISCSI_FLAG_FINAL);
438
439 data_segment_len = DGET24(datah->data_segment_len);
440 CU_ASSERT(data_segment_len == 18);
441 CU_ASSERT(datah->res_cnt == 0);
442
443 TAILQ_REMOVE(&g_write_pdu_list, pdu1, tailq);
444 spdk_put_pdu(pdu1);
445
446 pdu2 = TAILQ_FIRST(&g_write_pdu_list);
447 /* inform scan-build (clang 6) that these pointers are not the same */
448 SPDK_CU_ASSERT_FATAL(pdu1 != pdu2);
449 SPDK_CU_ASSERT_FATAL(pdu2 != NULL);
450
451 CU_ASSERT(pdu2->bhs.opcode == ISCSI_OP_SCSI_RSP);
452
453 resph = (struct iscsi_bhs_scsi_resp *)&pdu2->bhs;
454
455 CU_ASSERT(resph->flags == (ISCSI_SCSI_UNDERFLOW | 0x80));
456
457 data_segment_len = DGET24(resph->data_segment_len);
458 CU_ASSERT(data_segment_len == task.scsi.sense_data_len + 2);
459 CU_ASSERT(resph->res_cnt == residual_count);
460
461 TAILQ_REMOVE(&g_write_pdu_list, pdu2, tailq);
462 spdk_put_pdu(pdu2);
463
464 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list));
465}
466
467static void
468underflow_for_check_condition_test(void)
469{
470 struct spdk_iscsi_sess sess;
471 struct spdk_iscsi_conn conn;
472 struct spdk_iscsi_task task;
473 struct spdk_iscsi_pdu *pdu;
474 struct iscsi_bhs_scsi_req *scsi_req;
475 struct iscsi_bhs_scsi_resp *resph;
476 uint32_t data_segment_len;
477
478 TAILQ_INIT(&g_write_pdu_list);
479
480 memset(&sess, 0, sizeof(sess));
481 memset(&conn, 0, sizeof(conn));
482 memset(&task, 0, sizeof(task));
483
484 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH;
485
486 conn.sess = &sess;
487 conn.MaxRecvDataSegmentLength = 8192;
488
489 pdu = spdk_get_pdu();
490 SPDK_CU_ASSERT_FATAL(pdu != NULL);
491
492 scsi_req = (struct iscsi_bhs_scsi_req *)&pdu->bhs;
493 scsi_req->read_bit = 1;
494
495 spdk_iscsi_task_set_pdu(&task, pdu);
496 task.parent = NULL;
497
498 task.scsi.iovs = &task.scsi.iov;
499 task.scsi.iovcnt = 1;
500 task.scsi.length = 512;
501 task.scsi.transfer_len = 512;
502 task.bytes_completed = 512;
503
504 task.scsi.sense_data_len = 18;
505 task.scsi.data_transferred = 18;
506 task.scsi.status = SPDK_SCSI_STATUS_CHECK_CONDITION;
507
508 spdk_iscsi_task_response(&conn, &task);
509 spdk_put_pdu(pdu);
510
511 /*
512 * In this case, a SCSI Response PDU is returned.
513 * Sense data is set in sense area.
514 * Underflow is not set.
515 */
516 pdu = TAILQ_FIRST(&g_write_pdu_list);
517 SPDK_CU_ASSERT_FATAL(pdu != NULL);
518
519 CU_ASSERT(pdu->bhs.opcode == ISCSI_OP_SCSI_RSP);
520
521 resph = (struct iscsi_bhs_scsi_resp *)&pdu->bhs;
522
523 CU_ASSERT(resph->flags == 0x80);
524
525 data_segment_len = DGET24(resph->data_segment_len);
526 CU_ASSERT(data_segment_len == task.scsi.sense_data_len + 2);
527 CU_ASSERT(resph->res_cnt == 0);
528
529 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq);
530 spdk_put_pdu(pdu);
531
532 CU_ASSERT(TAILQ_EMPTY(&g_write_pdu_list));
533}
534
535static void
536add_transfer_task_test(void)
537{
538 struct spdk_iscsi_sess sess;
539 struct spdk_iscsi_conn conn;
540 struct spdk_iscsi_task task;
541 struct spdk_iscsi_pdu *pdu, *tmp;
542 struct iscsi_bhs_r2t *r2th;
543 int rc, count = 0;
544 uint32_t buffer_offset, desired_xfer_len;
545
546 memset(&sess, 0, sizeof(sess));
547 memset(&conn, 0, sizeof(conn));
548 memset(&task, 0, sizeof(task));
549
550 sess.MaxBurstLength = SPDK_ISCSI_MAX_BURST_LENGTH; /* 1M */
551 sess.MaxOutstandingR2T = DEFAULT_MAXR2T; /* 4 */
552
553 conn.sess = &sess;
554 TAILQ_INIT(&conn.queued_r2t_tasks);
555 TAILQ_INIT(&conn.active_r2t_tasks);
556
557 pdu = spdk_get_pdu();
558 SPDK_CU_ASSERT_FATAL(pdu != NULL);
559
560 pdu->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; /* 64K */
561 task.scsi.transfer_len = 16 * 1024 * 1024;
562 spdk_iscsi_task_set_pdu(&task, pdu);
563
564 /* The following tests if the task is queued because R2T tasks are full. */
565 conn.pending_r2t = DEFAULT_MAXR2T;
566
9f95a23c 567 rc = add_transfer_task(&conn, &task);
11fdf7f2 568
9f95a23c 569 CU_ASSERT(rc == 0);
11fdf7f2
TL		 570 CU_ASSERT(TAILQ_FIRST(&conn.queued_r2t_tasks) == &task);
571
572 TAILQ_REMOVE(&conn.queued_r2t_tasks, &task, link);
573 CU_ASSERT(TAILQ_EMPTY(&conn.queued_r2t_tasks));
574
575 /* The following tests if multiple R2Ts are issued. */
576 conn.pending_r2t = 0;
577
9f95a23c 578 rc = add_transfer_task(&conn, &task);
11fdf7f2 579
9f95a23c 580 CU_ASSERT(rc == 0);
11fdf7f2
TL		 581 CU_ASSERT(TAILQ_FIRST(&conn.active_r2t_tasks) == &task);
582
583 TAILQ_REMOVE(&conn.active_r2t_tasks, &task, link);
584 CU_ASSERT(TAILQ_EMPTY(&conn.active_r2t_tasks));
585
586 CU_ASSERT(conn.data_out_cnt == 255);
587 CU_ASSERT(conn.pending_r2t == 1);
588 CU_ASSERT(conn.outstanding_r2t_tasks[0] == &task);
589 CU_ASSERT(conn.ttt == 1);
590
591 CU_ASSERT(task.data_out_cnt == 255);
592 CU_ASSERT(task.ttt == 1);
593 CU_ASSERT(task.outstanding_r2t == sess.MaxOutstandingR2T);
594 CU_ASSERT(task.next_r2t_offset ==
595 pdu->data_segment_len + sess.MaxBurstLength * sess.MaxOutstandingR2T);
596
597
598 while (!TAILQ_EMPTY(&g_write_pdu_list)) {
599 tmp = TAILQ_FIRST(&g_write_pdu_list);
600 TAILQ_REMOVE(&g_write_pdu_list, tmp, tailq);
601
602 r2th = (struct iscsi_bhs_r2t *)&tmp->bhs;
603
604 buffer_offset = from_be32(&r2th->buffer_offset);
605 CU_ASSERT(buffer_offset == pdu->data_segment_len + sess.MaxBurstLength * count);
606
607 desired_xfer_len = from_be32(&r2th->desired_xfer_len);
608 CU_ASSERT(desired_xfer_len == sess.MaxBurstLength);
609
610 spdk_put_pdu(tmp);
611 count++;
612 }
613
614 CU_ASSERT(count == DEFAULT_MAXR2T);
615
616 spdk_put_pdu(pdu);
617}
618
619static void
620get_transfer_task_test(void)
621{
622 struct spdk_iscsi_sess sess;
623 struct spdk_iscsi_conn conn;
624 struct spdk_iscsi_task task1, task2, *task;
625 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu;
626 int rc;
627
628 memset(&sess, 0, sizeof(sess));
629 memset(&conn, 0, sizeof(conn));
630 memset(&task1, 0, sizeof(task1));
631 memset(&task2, 0, sizeof(task2));
632
633 sess.MaxBurstLength = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
634 sess.MaxOutstandingR2T = 1;
635
636 conn.sess = &sess;
637 TAILQ_INIT(&conn.active_r2t_tasks);
638
639 pdu1 = spdk_get_pdu();
640 SPDK_CU_ASSERT_FATAL(pdu1 != NULL);
641
642 pdu1->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
643 task1.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
644 spdk_iscsi_task_set_pdu(&task1, pdu1);
645
9f95a23c
TL		 646 rc = add_transfer_task(&conn, &task1);
647 CU_ASSERT(rc == 0);
11fdf7f2
TL		 648
649 pdu2 = spdk_get_pdu();
650 SPDK_CU_ASSERT_FATAL(pdu2 != NULL);
651
652 pdu2->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
653 task2.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
654 spdk_iscsi_task_set_pdu(&task2, pdu2);
655
9f95a23c
TL		 656 rc = add_transfer_task(&conn, &task2);
657 CU_ASSERT(rc == 0);
11fdf7f2 658
9f95a23c 659 task = get_transfer_task(&conn, 1);
11fdf7f2
TL		 660 CU_ASSERT(task == &task1);
661
9f95a23c 662 task = get_transfer_task(&conn, 2);
11fdf7f2
TL		 663 CU_ASSERT(task == &task2);
664
665 while (!TAILQ_EMPTY(&conn.active_r2t_tasks)) {
666 task = TAILQ_FIRST(&conn.active_r2t_tasks);
667 TAILQ_REMOVE(&conn.active_r2t_tasks, task, link);
668 }
669
670 while (!TAILQ_EMPTY(&g_write_pdu_list)) {
671 pdu = TAILQ_FIRST(&g_write_pdu_list);
672 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq);
673 spdk_put_pdu(pdu);
674 }
675
676 spdk_put_pdu(pdu2);
677 spdk_put_pdu(pdu1);
678}
679
680static void
681del_transfer_task_test(void)
682{
683 struct spdk_iscsi_sess sess;
684 struct spdk_iscsi_conn conn;
685 struct spdk_iscsi_task task1, task2, task3, task4, task5, *task;
686 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu3, *pdu4, *pdu5, *pdu;
687 int rc;
688
689 memset(&sess, 0, sizeof(sess));
690 memset(&conn, 0, sizeof(conn));
691 memset(&task1, 0, sizeof(task1));
692 memset(&task2, 0, sizeof(task2));
693 memset(&task3, 0, sizeof(task3));
694 memset(&task4, 0, sizeof(task4));
695 memset(&task5, 0, sizeof(task5));
696
697 sess.MaxBurstLength = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
698 sess.MaxOutstandingR2T = 1;
699
700 conn.sess = &sess;
701 TAILQ_INIT(&conn.active_r2t_tasks);
702 TAILQ_INIT(&conn.queued_r2t_tasks);
703
704 pdu1 = spdk_get_pdu();
705 SPDK_CU_ASSERT_FATAL(pdu1 != NULL);
706
707 pdu1->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
708 task1.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
709 spdk_iscsi_task_set_pdu(&task1, pdu1);
710 task1.tag = 11;
711
9f95a23c
TL		 712 rc = add_transfer_task(&conn, &task1);
713 CU_ASSERT(rc == 0);
11fdf7f2
TL		 714
715 pdu2 = spdk_get_pdu();
716 SPDK_CU_ASSERT_FATAL(pdu2 != NULL);
717
718 pdu2->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
719 task2.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
720 spdk_iscsi_task_set_pdu(&task2, pdu2);
721 task2.tag = 12;
722
9f95a23c
TL		 723 rc = add_transfer_task(&conn, &task2);
724 CU_ASSERT(rc == 0);
11fdf7f2
TL		 725
726 pdu3 = spdk_get_pdu();
727 SPDK_CU_ASSERT_FATAL(pdu3 != NULL);
728
729 pdu3->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
730 task3.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
731 spdk_iscsi_task_set_pdu(&task3, pdu3);
732 task3.tag = 13;
733
9f95a23c
TL		 734 rc = add_transfer_task(&conn, &task3);
735 CU_ASSERT(rc == 0);
11fdf7f2
TL		 736
737 pdu4 = spdk_get_pdu();
738 SPDK_CU_ASSERT_FATAL(pdu4 != NULL);
739
740 pdu4->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
741 task4.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
742 spdk_iscsi_task_set_pdu(&task4, pdu4);
743 task4.tag = 14;
744
9f95a23c
TL		 745 rc = add_transfer_task(&conn, &task4);
746 CU_ASSERT(rc == 0);
11fdf7f2
TL		 747
748 pdu5 = spdk_get_pdu();
749 SPDK_CU_ASSERT_FATAL(pdu5 != NULL);
750
751 pdu5->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
752 task5.scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
753 spdk_iscsi_task_set_pdu(&task5, pdu5);
754 task5.tag = 15;
755
9f95a23c
TL		 756 rc = add_transfer_task(&conn, &task5);
757 CU_ASSERT(rc == 0);
11fdf7f2 758
9f95a23c
TL		 759 CU_ASSERT(get_transfer_task(&conn, 1) == &task1);
760 CU_ASSERT(get_transfer_task(&conn, 5) == NULL);
11fdf7f2 761 spdk_del_transfer_task(&conn, 11);
9f95a23c
TL		 762 CU_ASSERT(get_transfer_task(&conn, 1) == NULL);
763 CU_ASSERT(get_transfer_task(&conn, 5) == &task5);
11fdf7f2 764
9f95a23c 765 CU_ASSERT(get_transfer_task(&conn, 2) == &task2);
11fdf7f2 766 spdk_del_transfer_task(&conn, 12);
9f95a23c 767 CU_ASSERT(get_transfer_task(&conn, 2) == NULL);
11fdf7f2 768
9f95a23c 769 CU_ASSERT(get_transfer_task(&conn, 3) == &task3);
11fdf7f2 770 spdk_del_transfer_task(&conn, 13);
9f95a23c 771 CU_ASSERT(get_transfer_task(&conn, 3) == NULL);
11fdf7f2 772
9f95a23c 773 CU_ASSERT(get_transfer_task(&conn, 4) == &task4);
11fdf7f2 774 spdk_del_transfer_task(&conn, 14);
9f95a23c 775 CU_ASSERT(get_transfer_task(&conn, 4) == NULL);
11fdf7f2 776
9f95a23c 777 CU_ASSERT(get_transfer_task(&conn, 5) == &task5);
11fdf7f2 778 spdk_del_transfer_task(&conn, 15);
9f95a23c 779 CU_ASSERT(get_transfer_task(&conn, 5) == NULL);
11fdf7f2
TL		 780
781 while (!TAILQ_EMPTY(&conn.active_r2t_tasks)) {
782 task = TAILQ_FIRST(&conn.active_r2t_tasks);
783 TAILQ_REMOVE(&conn.active_r2t_tasks, task, link);
784 }
785
786 while (!TAILQ_EMPTY(&g_write_pdu_list)) {
787 pdu = TAILQ_FIRST(&g_write_pdu_list);
788 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq);
789 spdk_put_pdu(pdu);
790 }
791
792 spdk_put_pdu(pdu5);
793 spdk_put_pdu(pdu4);
794 spdk_put_pdu(pdu3);
795 spdk_put_pdu(pdu2);
796 spdk_put_pdu(pdu1);
797}
798
799static void
800clear_all_transfer_tasks_test(void)
801{
802 struct spdk_iscsi_sess sess;
803 struct spdk_iscsi_conn conn;
9f95a23c
TL		 804 struct spdk_iscsi_task *task1, *task2, *task3, *task4, *task5, *task6;
805 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu3, *pdu4, *pdu5, *pdu6, *pdu;
806 struct spdk_iscsi_pdu *mgmt_pdu1, *mgmt_pdu2;
11fdf7f2 807 struct spdk_scsi_lun lun1, lun2;
9f95a23c 808 uint32_t alloc_cmd_sn;
11fdf7f2
TL		 809 int rc;
810
811 memset(&sess, 0, sizeof(sess));
812 memset(&conn, 0, sizeof(conn));
813 memset(&lun1, 0, sizeof(lun1));
814 memset(&lun2, 0, sizeof(lun2));
815
816 sess.MaxBurstLength = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
817 sess.MaxOutstandingR2T = 1;
818
819 conn.sess = &sess;
820 TAILQ_INIT(&conn.active_r2t_tasks);
821 TAILQ_INIT(&conn.queued_r2t_tasks);
822
9f95a23c
TL		 823 alloc_cmd_sn = 10;
824
11fdf7f2
TL		 825 task1 = spdk_iscsi_task_get(&conn, NULL, NULL);
826 SPDK_CU_ASSERT_FATAL(task1 != NULL);
827 pdu1 = spdk_get_pdu();
828 SPDK_CU_ASSERT_FATAL(pdu1 != NULL);
829
830 pdu1->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
9f95a23c
TL		 831 pdu1->cmd_sn = alloc_cmd_sn;
832 alloc_cmd_sn++;
11fdf7f2
TL		 833 task1->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
834 task1->scsi.lun = &lun1;
835 spdk_iscsi_task_set_pdu(task1, pdu1);
836
9f95a23c
TL		 837 rc = add_transfer_task(&conn, task1);
838 CU_ASSERT(rc == 0);
839
840 mgmt_pdu1 = spdk_get_pdu();
841 SPDK_CU_ASSERT_FATAL(mgmt_pdu1 != NULL);
842
843 mgmt_pdu1->cmd_sn = alloc_cmd_sn;
844 alloc_cmd_sn++;
11fdf7f2
TL		 845
846 task2 = spdk_iscsi_task_get(&conn, NULL, NULL);
847 SPDK_CU_ASSERT_FATAL(task2 != NULL);
848 pdu2 = spdk_get_pdu();
849 SPDK_CU_ASSERT_FATAL(pdu2 != NULL);
850
851 pdu2->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
9f95a23c
TL		 852 pdu2->cmd_sn = alloc_cmd_sn;
853 alloc_cmd_sn++;
11fdf7f2
TL		 854 task2->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
855 task2->scsi.lun = &lun1;
856 spdk_iscsi_task_set_pdu(task2, pdu2);
857
9f95a23c
TL		 858 rc = add_transfer_task(&conn, task2);
859 CU_ASSERT(rc == 0);
11fdf7f2
TL		 860
861 task3 = spdk_iscsi_task_get(&conn, NULL, NULL);
862 SPDK_CU_ASSERT_FATAL(task3 != NULL);
863 pdu3 = spdk_get_pdu();
864 SPDK_CU_ASSERT_FATAL(pdu3 != NULL);
865
866 pdu3->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
9f95a23c
TL		 867 pdu3->cmd_sn = alloc_cmd_sn;
868 alloc_cmd_sn++;
11fdf7f2
TL		 869 task3->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
870 task3->scsi.lun = &lun1;
871 spdk_iscsi_task_set_pdu(task3, pdu3);
872
9f95a23c
TL		 873 rc = add_transfer_task(&conn, task3);
874 CU_ASSERT(rc == 0);
11fdf7f2
TL		 875
876 task4 = spdk_iscsi_task_get(&conn, NULL, NULL);
877 SPDK_CU_ASSERT_FATAL(task4 != NULL);
878 pdu4 = spdk_get_pdu();
879 SPDK_CU_ASSERT_FATAL(pdu4 != NULL);
880
881 pdu4->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
9f95a23c
TL		 882 pdu4->cmd_sn = alloc_cmd_sn;
883 alloc_cmd_sn++;
11fdf7f2
TL		 884 task4->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
885 task4->scsi.lun = &lun2;
886 spdk_iscsi_task_set_pdu(task4, pdu4);
887
9f95a23c
TL		 888 rc = add_transfer_task(&conn, task4);
889 CU_ASSERT(rc == 0);
11fdf7f2
TL		 890
891 task5 = spdk_iscsi_task_get(&conn, NULL, NULL);
892 SPDK_CU_ASSERT_FATAL(task5 != NULL);
893 pdu5 = spdk_get_pdu();
894 SPDK_CU_ASSERT_FATAL(pdu5 != NULL);
895
896 pdu5->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
9f95a23c
TL		 897 pdu5->cmd_sn = alloc_cmd_sn;
898 alloc_cmd_sn++;
11fdf7f2
TL		 899 task5->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
900 task5->scsi.lun = &lun2;
901 spdk_iscsi_task_set_pdu(task5, pdu5);
902
9f95a23c
TL		 903 rc = add_transfer_task(&conn, task5);
904 CU_ASSERT(rc == 0);
905
906 mgmt_pdu2 = spdk_get_pdu();
907 SPDK_CU_ASSERT_FATAL(mgmt_pdu2 != NULL);
908
909 mgmt_pdu2->cmd_sn = alloc_cmd_sn;
910 alloc_cmd_sn++;
911
912 task6 = spdk_iscsi_task_get(&conn, NULL, NULL);
913 SPDK_CU_ASSERT_FATAL(task6 != NULL);
914 pdu6 = spdk_get_pdu();
915 SPDK_CU_ASSERT_FATAL(pdu6 != NULL);
916
917 pdu6->data_segment_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
918 pdu6->cmd_sn = alloc_cmd_sn;
919 alloc_cmd_sn++;
920 task5->scsi.transfer_len = SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
921 task6->scsi.lun = &lun2;
922 spdk_iscsi_task_set_pdu(task6, pdu6);
923
924 rc = add_transfer_task(&conn, task6);
925 CU_ASSERT(rc == 0);
11fdf7f2
TL		 926
927 CU_ASSERT(conn.ttt == 4);
928
9f95a23c
TL		 929 CU_ASSERT(get_transfer_task(&conn, 1) == task1);
930 CU_ASSERT(get_transfer_task(&conn, 2) == task2);
931 CU_ASSERT(get_transfer_task(&conn, 3) == task3);
932 CU_ASSERT(get_transfer_task(&conn, 4) == task4);
933 CU_ASSERT(get_transfer_task(&conn, 5) == NULL);
934
935 spdk_clear_all_transfer_task(&conn, &lun1, mgmt_pdu1);
11fdf7f2 936
9f95a23c
TL		 937 CU_ASSERT(!TAILQ_EMPTY(&conn.queued_r2t_tasks));
938 CU_ASSERT(get_transfer_task(&conn, 1) == NULL);
939 CU_ASSERT(get_transfer_task(&conn, 2) == task2);
940 CU_ASSERT(get_transfer_task(&conn, 3) == task3);
941 CU_ASSERT(get_transfer_task(&conn, 4) == task4);
942 CU_ASSERT(get_transfer_task(&conn, 5) == task5);
943 CU_ASSERT(get_transfer_task(&conn, 6) == NULL);
944
945 spdk_clear_all_transfer_task(&conn, &lun1, NULL);
11fdf7f2
TL		 946
947 CU_ASSERT(TAILQ_EMPTY(&conn.queued_r2t_tasks));
9f95a23c
TL		 948 CU_ASSERT(get_transfer_task(&conn, 1) == NULL);
949 CU_ASSERT(get_transfer_task(&conn, 2) == NULL);
950 CU_ASSERT(get_transfer_task(&conn, 3) == NULL);
951 CU_ASSERT(get_transfer_task(&conn, 4) == task4);
952 CU_ASSERT(get_transfer_task(&conn, 5) == task5);
953 CU_ASSERT(get_transfer_task(&conn, 6) == task6);
954
955 spdk_clear_all_transfer_task(&conn, &lun2, mgmt_pdu2);
956
957 CU_ASSERT(get_transfer_task(&conn, 4) == NULL);
958 CU_ASSERT(get_transfer_task(&conn, 5) == NULL);
959 CU_ASSERT(get_transfer_task(&conn, 6) == task6);
11fdf7f2 960
9f95a23c 961 spdk_clear_all_transfer_task(&conn, NULL, NULL);
11fdf7f2 962
9f95a23c 963 CU_ASSERT(get_transfer_task(&conn, 6) == NULL);
11fdf7f2
TL		 964
965 CU_ASSERT(TAILQ_EMPTY(&conn.active_r2t_tasks));
966 while (!TAILQ_EMPTY(&g_write_pdu_list)) {
967 pdu = TAILQ_FIRST(&g_write_pdu_list);
968 TAILQ_REMOVE(&g_write_pdu_list, pdu, tailq);
969 spdk_put_pdu(pdu);
970 }
971
9f95a23c
TL		 972 spdk_put_pdu(mgmt_pdu2);
973 spdk_put_pdu(mgmt_pdu1);
974 spdk_put_pdu(pdu6);
975 spdk_put_pdu(pdu5);
976 spdk_put_pdu(pdu4);
977 spdk_put_pdu(pdu3);
978 spdk_put_pdu(pdu2);
979 spdk_put_pdu(pdu1);
980}
981
982static void
983abort_queued_datain_task_test(void)
984{
985 struct spdk_iscsi_conn conn;
986 struct spdk_iscsi_task *task, *task2, *task3;
987 int rc;
988
989 TAILQ_INIT(&conn.queued_datain_tasks);
990
991 task = spdk_iscsi_task_get(&conn, NULL, NULL);
992 SPDK_CU_ASSERT_FATAL(task != NULL);
993 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task, link);
994
995 /* Slot of data in tasks are full */
996 conn.data_in_cnt = MAX_LARGE_DATAIN_PER_CONNECTION;
997
998 rc = _iscsi_conn_abort_queued_datain_task(&conn, task);
999 CU_ASSERT(rc != 0);
1000
1001 /* Only one slot remains and no subtasks are submitted yet. */
1002 conn.data_in_cnt--;
1003 task->current_datain_offset = 0;
1004
1005 rc = _iscsi_conn_abort_queued_datain_task(&conn, task);
1006 CU_ASSERT(rc == 0);
1007 CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks));
1008
1009 task = spdk_iscsi_task_get(&conn, NULL, NULL);
1010 SPDK_CU_ASSERT_FATAL(task != NULL);
1011 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task, link);
1012
1013 /* Only one slot remains and a subtask is submitted. */
1014 task->scsi.transfer_len = SPDK_BDEV_LARGE_BUF_MAX_SIZE * 3;
1015 task->current_datain_offset = SPDK_BDEV_LARGE_BUF_MAX_SIZE;
1016
1017 rc = _iscsi_conn_abort_queued_datain_task(&conn, task);
1018 CU_ASSERT(rc != 0);
1019 CU_ASSERT(task->current_datain_offset == SPDK_BDEV_LARGE_BUF_MAX_SIZE * 2);
1020 CU_ASSERT(conn.data_in_cnt == MAX_LARGE_DATAIN_PER_CONNECTION);
1021
1022 /* Additional one slot becomes vacant. */
1023 conn.data_in_cnt--;
1024
1025 rc = _iscsi_conn_abort_queued_datain_task(&conn, task);
1026 CU_ASSERT(rc == 0);
1027 CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks));
1028
1029 spdk_iscsi_task_cpl(&task->scsi);
1030
1031 /* Queue three data in tasks and abort each task sequentially */
1032 task = spdk_iscsi_task_get(&conn, NULL, NULL);
1033 SPDK_CU_ASSERT_FATAL(task != NULL);
1034 task->tag = 1;
1035 task->current_datain_offset = 0;
1036 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task, link);
1037
1038 task2 = spdk_iscsi_task_get(&conn, NULL, NULL);
1039 SPDK_CU_ASSERT_FATAL(task2 != NULL);
1040 task2->tag = 2;
1041 task2->current_datain_offset = 0;
1042 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task2, link);
1043
1044 task3 = spdk_iscsi_task_get(&conn, NULL, NULL);
1045 SPDK_CU_ASSERT_FATAL(task3 != NULL);
1046 task3->tag = 3;
1047 task3->current_datain_offset = 0;
1048 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task3, link);
1049
1050 conn.data_in_cnt--;
1051
1052 rc = iscsi_conn_abort_queued_datain_task(&conn, 1);
1053 CU_ASSERT(rc == 0);
1054
1055 rc = iscsi_conn_abort_queued_datain_task(&conn, 2);
1056 CU_ASSERT(rc == 0);
1057
1058 rc = iscsi_conn_abort_queued_datain_task(&conn, 3);
1059 CU_ASSERT(rc == 0);
1060
1061 CU_ASSERT(TAILQ_EMPTY(&conn.queued_datain_tasks));
1062}
1063
1064static bool
1065datain_task_is_queued(struct spdk_iscsi_conn *conn,
1066 struct spdk_iscsi_task *task)
1067{
1068 struct spdk_iscsi_task *tmp;
1069
1070 TAILQ_FOREACH(tmp, &conn->queued_datain_tasks, link) {
1071 if (tmp == task) {
1072 return true;
1073 }
1074 }
1075 return false;
1076}
1077
1078static void
1079abort_queued_datain_tasks_test(void)
1080{
1081 struct spdk_iscsi_conn conn;
1082 struct spdk_iscsi_task *task1, *task2, *task3, *task4, *task5, *task6;
1083 struct spdk_iscsi_task *task, *tmp;
1084 struct spdk_iscsi_pdu *pdu1, *pdu2, *pdu3, *pdu4, *pdu5, *pdu6;
1085 struct spdk_iscsi_pdu *mgmt_pdu1, *mgmt_pdu2;
1086 struct spdk_scsi_lun lun1, lun2;
1087 uint32_t alloc_cmd_sn;
1088 int rc;
1089
1090 TAILQ_INIT(&conn.queued_datain_tasks);
1091 conn.data_in_cnt = 0;
1092
1093 alloc_cmd_sn = 88;
1094
1095 task1 = spdk_iscsi_task_get(&conn, NULL, NULL);
1096 SPDK_CU_ASSERT_FATAL(task1 != NULL);
1097 pdu1 = spdk_get_pdu();
1098 SPDK_CU_ASSERT_FATAL(pdu1 != NULL);
1099
1100 pdu1->cmd_sn = alloc_cmd_sn;
1101 alloc_cmd_sn++;
1102 task1->current_datain_offset = 0;
1103 task1->scsi.lun = &lun1;
1104 spdk_iscsi_task_set_pdu(task1, pdu1);
1105 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task1, link);
1106
1107 task2 = spdk_iscsi_task_get(&conn, NULL, NULL);
1108 SPDK_CU_ASSERT_FATAL(task2 != NULL);
1109 pdu2 = spdk_get_pdu();
1110 SPDK_CU_ASSERT_FATAL(pdu2 != NULL);
1111
1112 pdu2->cmd_sn = alloc_cmd_sn;
1113 alloc_cmd_sn++;
1114 task2->current_datain_offset = 0;
1115 task2->scsi.lun = &lun2;
1116 spdk_iscsi_task_set_pdu(task2, pdu2);
1117 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task2, link);
1118
1119 mgmt_pdu1 = spdk_get_pdu();
1120 SPDK_CU_ASSERT_FATAL(mgmt_pdu1 != NULL);
1121
1122 mgmt_pdu1->cmd_sn = alloc_cmd_sn;
1123 alloc_cmd_sn++;
1124
1125 task3 = spdk_iscsi_task_get(&conn, NULL, NULL);
1126 SPDK_CU_ASSERT_FATAL(task3 != NULL);
1127 pdu3 = spdk_get_pdu();
1128 SPDK_CU_ASSERT_FATAL(pdu3 != NULL);
1129
1130 pdu3->cmd_sn = alloc_cmd_sn;
1131 alloc_cmd_sn++;
1132 task3->current_datain_offset = 0;
1133 task3->scsi.lun = &lun1;
1134 spdk_iscsi_task_set_pdu(task3, pdu3);
1135 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task3, link);
1136
1137 task4 = spdk_iscsi_task_get(&conn, NULL, NULL);
1138 SPDK_CU_ASSERT_FATAL(task4 != NULL);
1139 pdu4 = spdk_get_pdu();
1140 SPDK_CU_ASSERT_FATAL(pdu4 != NULL);
1141
1142 pdu4->cmd_sn = alloc_cmd_sn;
1143 alloc_cmd_sn++;
1144 task4->current_datain_offset = 0;
1145 task4->scsi.lun = &lun2;
1146 spdk_iscsi_task_set_pdu(task4, pdu4);
1147 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task4, link);
1148
1149 task5 = spdk_iscsi_task_get(&conn, NULL, NULL);
1150 SPDK_CU_ASSERT_FATAL(task5 != NULL);
1151 pdu5 = spdk_get_pdu();
1152 SPDK_CU_ASSERT_FATAL(pdu5 != NULL);
1153
1154 pdu5->cmd_sn = alloc_cmd_sn;
1155 alloc_cmd_sn++;
1156 task5->current_datain_offset = 0;
1157 task5->scsi.lun = &lun1;
1158 spdk_iscsi_task_set_pdu(task5, pdu5);
1159 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task5, link);
1160
1161 mgmt_pdu2 = spdk_get_pdu();
1162 SPDK_CU_ASSERT_FATAL(mgmt_pdu2 != NULL);
1163
1164 mgmt_pdu2->cmd_sn = alloc_cmd_sn;
1165 alloc_cmd_sn++;
1166
1167 task6 = spdk_iscsi_task_get(&conn, NULL, NULL);
1168 SPDK_CU_ASSERT_FATAL(task6 != NULL);
1169 pdu6 = spdk_get_pdu();
1170 SPDK_CU_ASSERT_FATAL(pdu6 != NULL);
1171
1172 pdu6->cmd_sn = alloc_cmd_sn;
1173 alloc_cmd_sn++;
1174 task6->current_datain_offset = 0;
1175 task6->scsi.lun = &lun2;
1176 spdk_iscsi_task_set_pdu(task6, pdu6);
1177 TAILQ_INSERT_TAIL(&conn.queued_datain_tasks, task6, link);
1178
1179 rc = iscsi_conn_abort_queued_datain_tasks(&conn, &lun1, mgmt_pdu1);
1180 CU_ASSERT(rc == 0);
1181 CU_ASSERT(!datain_task_is_queued(&conn, task1));
1182 CU_ASSERT(datain_task_is_queued(&conn, task2));
1183 CU_ASSERT(datain_task_is_queued(&conn, task3));
1184 CU_ASSERT(datain_task_is_queued(&conn, task4));
1185 CU_ASSERT(datain_task_is_queued(&conn, task5));
1186 CU_ASSERT(datain_task_is_queued(&conn, task6));
1187
1188 rc = iscsi_conn_abort_queued_datain_tasks(&conn, &lun2, mgmt_pdu2);
1189 CU_ASSERT(rc == 0);
1190 CU_ASSERT(!datain_task_is_queued(&conn, task2));
1191 CU_ASSERT(datain_task_is_queued(&conn, task3));
1192 CU_ASSERT(!datain_task_is_queued(&conn, task4));
1193 CU_ASSERT(datain_task_is_queued(&conn, task5));
1194 CU_ASSERT(datain_task_is_queued(&conn, task6));
1195
1196 TAILQ_FOREACH_SAFE(task, &conn.queued_datain_tasks, link, tmp) {
1197 TAILQ_REMOVE(&conn.queued_datain_tasks, task, link);
1198 spdk_iscsi_task_cpl(&task->scsi);
1199 }
1200
1201 spdk_put_pdu(mgmt_pdu2);
1202 spdk_put_pdu(mgmt_pdu1);
1203 spdk_put_pdu(pdu6);
11fdf7f2
TL		 1204 spdk_put_pdu(pdu5);
1205 spdk_put_pdu(pdu4);
1206 spdk_put_pdu(pdu3);
1207 spdk_put_pdu(pdu2);
1208 spdk_put_pdu(pdu1);
1209}
1210
9f95a23c
TL		 1211static void
1212build_iovs_test(void)
1213{
1214 struct spdk_iscsi_conn conn = {};
1215 struct spdk_iscsi_pdu pdu = {};
1216 struct iovec iovs[5] = {};
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, 512);
1225 data = calloc(1, 512);
1226 SPDK_CU_ASSERT_FATAL(data != NULL);
1227 pdu.data = data;
1228
1229 pdu.bhs.total_ahs_len = 0;
1230 pdu.bhs.opcode = ISCSI_OP_SCSI;
1231
1232 pdu.writev_offset = 0;
1233 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length);
1234 CU_ASSERT(rc == 4);
1235 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs);
1236 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN);
1237 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest);
1238 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN);
1239 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data);
1240 CU_ASSERT(iovs[2].iov_len == 512);
1241 CU_ASSERT(iovs[3].iov_base == (void *)pdu.data_digest);
1242 CU_ASSERT(iovs[3].iov_len == ISCSI_DIGEST_LEN);
1243 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN);
1244
1245 pdu.writev_offset = ISCSI_BHS_LEN / 2;
1246 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length);
1247 CU_ASSERT(rc == 4);
1248 CU_ASSERT(iovs[0].iov_base == (void *)((uint8_t *)&pdu.bhs + ISCSI_BHS_LEN / 2));
1249 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN / 2);
1250 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest);
1251 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN);
1252 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data);
1253 CU_ASSERT(iovs[2].iov_len == 512);
1254 CU_ASSERT(iovs[3].iov_base == (void *)pdu.data_digest);
1255 CU_ASSERT(iovs[3].iov_len == ISCSI_DIGEST_LEN);
1256 CU_ASSERT(mapped_length == ISCSI_BHS_LEN / 2 + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN);
1257
1258 pdu.writev_offset = ISCSI_BHS_LEN;
1259 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length);
1260 CU_ASSERT(rc == 3);
1261 CU_ASSERT(iovs[0].iov_base == (void *)pdu.header_digest);
1262 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN);
1263 CU_ASSERT(iovs[1].iov_base == (void *)pdu.data);
1264 CU_ASSERT(iovs[1].iov_len == 512);
1265 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data_digest);
1266 CU_ASSERT(iovs[2].iov_len == ISCSI_DIGEST_LEN);
1267 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN);
1268
1269 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN / 2;
1270 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length);
1271 CU_ASSERT(rc == 3);
1272 CU_ASSERT(iovs[0].iov_base == (void *)((uint8_t *)pdu.header_digest + ISCSI_DIGEST_LEN / 2));
1273 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN / 2);
1274 CU_ASSERT(iovs[1].iov_base == (void *)pdu.data);
1275 CU_ASSERT(iovs[1].iov_len == 512);
1276 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data_digest);
1277 CU_ASSERT(iovs[2].iov_len == ISCSI_DIGEST_LEN);
1278 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN / 2 + 512 + ISCSI_DIGEST_LEN);
1279
1280 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN;
1281 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length);
1282 CU_ASSERT(rc == 2);
1283 CU_ASSERT(iovs[0].iov_base == (void *)pdu.data);
1284 CU_ASSERT(iovs[0].iov_len == 512);
1285 CU_ASSERT(iovs[1].iov_base == (void *)pdu.data_digest);
1286 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN);
1287 CU_ASSERT(mapped_length == 512 + ISCSI_DIGEST_LEN);
1288
1289 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512;
1290 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length);
1291 CU_ASSERT(rc == 1);
1292 CU_ASSERT(iovs[0].iov_base == (void *)pdu.data_digest);
1293 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN);
1294 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN);
1295
1296 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN / 2;
1297 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length);
1298 CU_ASSERT(rc == 1);
1299 CU_ASSERT(iovs[0].iov_base == (void *)((uint8_t *)pdu.data_digest + ISCSI_DIGEST_LEN / 2));
1300 CU_ASSERT(iovs[0].iov_len == ISCSI_DIGEST_LEN / 2);
1301 CU_ASSERT(mapped_length == ISCSI_DIGEST_LEN / 2);
1302
1303 pdu.writev_offset = ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN;
1304 rc = spdk_iscsi_build_iovs(&conn, iovs, 5, &pdu, &mapped_length);
1305 CU_ASSERT(rc == 0);
1306 CU_ASSERT(mapped_length == 0);
1307
1308 pdu.writev_offset = 0;
1309 rc = spdk_iscsi_build_iovs(&conn, iovs, 1, &pdu, &mapped_length);
1310 CU_ASSERT(rc == 1);
1311 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs);
1312 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN);
1313 CU_ASSERT(mapped_length == ISCSI_BHS_LEN);
1314
1315 rc = spdk_iscsi_build_iovs(&conn, iovs, 2, &pdu, &mapped_length);
1316 CU_ASSERT(rc == 2);
1317 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs);
1318 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN);
1319 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest);
1320 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN);
1321 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN);
1322
1323 rc = spdk_iscsi_build_iovs(&conn, iovs, 3, &pdu, &mapped_length);
1324 CU_ASSERT(rc == 3);
1325 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs);
1326 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN);
1327 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest);
1328 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN);
1329 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data);
1330 CU_ASSERT(iovs[2].iov_len == 512);
1331 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512);
1332
1333 rc = spdk_iscsi_build_iovs(&conn, iovs, 4, &pdu, &mapped_length);
1334 CU_ASSERT(rc == 4);
1335 CU_ASSERT(iovs[0].iov_base == (void *)&pdu.bhs);
1336 CU_ASSERT(iovs[0].iov_len == ISCSI_BHS_LEN);
1337 CU_ASSERT(iovs[1].iov_base == (void *)pdu.header_digest);
1338 CU_ASSERT(iovs[1].iov_len == ISCSI_DIGEST_LEN);
1339 CU_ASSERT(iovs[2].iov_base == (void *)pdu.data);
1340 CU_ASSERT(iovs[2].iov_len == 512);
1341 CU_ASSERT(iovs[3].iov_base == (void *)pdu.data_digest);
1342 CU_ASSERT(iovs[3].iov_len == ISCSI_DIGEST_LEN);
1343 CU_ASSERT(mapped_length == ISCSI_BHS_LEN + ISCSI_DIGEST_LEN + 512 + ISCSI_DIGEST_LEN);
1344
1345 free(data);
1346}
1347
11fdf7f2
TL		 1348int
1349main(int argc, char **argv)
1350{
1351 CU_pSuite suite = NULL;
1352 unsigned int num_failures;
1353
1354 if (CU_initialize_registry() != CUE_SUCCESS) {
1355 return CU_get_error();
1356 }
1357
1358 suite = CU_add_suite("iscsi_suite", NULL, NULL);
1359 if (suite == NULL) {
1360 CU_cleanup_registry();
1361 return CU_get_error();
1362 }
1363
1364 if (
1365 CU_add_test(suite, "login check target test", op_login_check_target_test) == NULL
1366 || CU_add_test(suite, "maxburstlength test", maxburstlength_test) == NULL
1367 || CU_add_test(suite, "underflow for read transfer test",
1368 underflow_for_read_transfer_test) == NULL
1369 || CU_add_test(suite, "underflow for zero read transfer test",
1370 underflow_for_zero_read_transfer_test) == NULL
1371 || CU_add_test(suite, "underflow for request sense test",
1372 underflow_for_request_sense_test) == NULL
1373 || CU_add_test(suite, "underflow for check condition test",
1374 underflow_for_check_condition_test) == NULL
1375 || CU_add_test(suite, "add transfer task test", add_transfer_task_test) == NULL
1376 || CU_add_test(suite, "get transfer task test", get_transfer_task_test) == NULL
1377 || CU_add_test(suite, "del transfer task test", del_transfer_task_test) == NULL
1378 || CU_add_test(suite, "clear all transfer tasks test",
1379 clear_all_transfer_tasks_test) == NULL
9f95a23c
TL		 1380 || CU_add_test(suite, "abort_queued_datain_task_test",
1381 abort_queued_datain_task_test) == NULL
1382 || CU_add_test(suite, "abort_queued_datain_tasks_test",
1383 abort_queued_datain_tasks_test) == NULL
1384 || CU_add_test(suite, "build_iovs_test", build_iovs_test) == NULL
11fdf7f2
TL		 1385 ) {
1386 CU_cleanup_registry();
1387 return CU_get_error();
1388 }
1389
1390 CU_basic_set_mode(CU_BRM_VERBOSE);
1391 CU_basic_run_tests();
1392 num_failures = CU_get_number_of_failures();
1393 CU_cleanup_registry();
1394 return num_failures;
1395}
Ceph